A Suggestion System For Tutorial Analysis (And Different Information Sorts)! | by Benjamin McCloskey | Mar, 2023
Implementing Pure Language Processing and Graph Principle to match and advocate several types of paperwork
Most of the tasks folks develop at this time typically start with the primary essential step: Energetic Analysis. Investing in what different folks have finished and constructing on their work is essential on your undertaking’s capability so as to add worth. Not solely must you study from the robust conclusions of what different folks have finished, however you additionally will wish to determine what you shouldn’t do in your undertaking to make sure its success.
As I labored via my thesis, I began gathering numerous several types of analysis information. For instance, I had collections of various educational publications I learn via in addition to excel sheets with info containing the outcomes of various experiments. As I accomplished the analysis for my thesis, I questioned: Is there a technique to create a advice system that may evaluate all of the analysis I’ve in my archive and assist information me in my subsequent undertaking?
In reality, there’s!
Observe: Not solely would this be for a repository of all the analysis chances are you’ll be gathering from varied search engines like google and yahoo, however it should additionally work for any listing you’ve containing varied varieties of completely different paperwork.
I developed this advice with my staff utilizing Python 3.
There are many APIs that help this advice system and researching what every particular API can carry out could also be useful on your personal studying.
import string
import csv
from io import StringIO
from pptx import Presentation
import docx2txt
import PyPDF2
import spacy
import pandas as pd
import numpy as np
import nltk
import re
import openpyxl
from nltk.stem import WordNetLemmatizer
from sklearn.feature_extraction.textual content import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from gensim.parsing.preprocessing import STOPWORDS as SW
nltk.obtain('stopwords')
nltk.obtain('wordnet')
nltk.obtain('omw-1.4')
nltk.obtain('averaged_perceptron_tagger')
from nltk.corpus import wordnet
import networkx as nx
from networkx.algorithms.shortest_paths import weighted
import glob
The Hurdle
One huge hurdle I needed to overcome was the necessity for the advice machine’s capability to match several types of information. For instance, I wished to see if an excel spreadsheet has info related or is related to the knowledge inside a PowerPoint and educational PDF journal. The trick to doing this was studying each file kind into Python and reworking every object right into a single string of phrases. This normalizes all the info and permits for the calculation of a similarity metric.
PDF Studying Class
The primary class we’ll take a look at for this undertaking is the pdfReader class which is ready to format a PDF to be readable in Python. Of all of the file codecs, I might argue that PDFs are one of the vital essential since lots of the journal articles downloaded from analysis repositories equivalent to Google Scholar are in PDF format.
class pdfReader:def __init__(self, file_path: str) -> str:
self.file_path = file_path
def PDF_one_pager(self) -> str:
"""A operate which returns a one line string of the
pdf.
Returns:
one_page_pdf (str): A one line string of the pdf.
"""
content material = ""
p = open(self.file_path, "rb")
pdf = PyPDF2.PdfReader(p)
num_pages = len(pdf.pages)
for i in vary(0, num_pages):
content material += pdf.pages[i].extract_text() + "n"
content material = " ".be a part of(content material.change(u"xa0", " ").strip().cut up())
page_number_removal = r"d{1,3} of d{1,3}"
page_number_removal_pattern = re.compile(page_number_removal, re.IGNORECASE)
content material = re.sub(page_number_removal_pattern, '',content material)
return content material
def pdf_reader(self) -> str:
"""A operate which may learn .pdf formatted information
and returns a python readable pdf.
Returns:
read_pdf: A python readable .pdf file.
"""
opener = open(self.file_path,'rb')
read_pdf = PyPDF2.PdfFileReader(opener)
return read_pdf
def pdf_info(self) -> dict:
"""A operate which returns an info dictionary of a
pdf.
Returns:
dict(pdf_info_dict): A dictionary containing the meta
knowledge of the thing.
"""
opener = open(self.file_path,'rb')
read_pdf = PyPDF2.PdfFileReader(opener)
pdf_info_dict = {}
for key,worth in read_pdf.documentInfo.objects():
pdf_info_dict[re.sub('/',"",key)] = worth
return pdf_info_dict
def pdf_dictionary(self) -> dict:
"""A operate which returns a dictionary of
the thing the place the keys are the pages
and the textual content inside the pages are the
values.
Returns:
dict(pdf_dict): A dictionary pages and textual content.
"""
opener = open(self.file_path,'rb')
read_pdf = PyPDF2.PdfReader(opener)
size = read_pdf.pages
pdf_dict = {}
for i in vary(size):
web page = read_pdf.getPage(i)
textual content = web page.extract_text()
pdf_dict[i] = textual content
return pdf_dict
Microsoft Powerpoint Reader
The pptReader class is able to studying Microsoft Powerpoint information into Python.
class pptReader:def __init__(self, file_path: str) -> None:
self.file_path = file_path
def ppt_text(self) -> str:
"""A operate that returns a string of textual content from all
of the slides in a pptReader object.
Returns:
textual content (str): A single string containing the textual content
inside every slide of the pptReader object.
"""
prs = Presentation(self.file_path)
textual content = str()
for slide in prs.slides:
for form in slide.shapes:
if not form.has_text_frame:
proceed
for paragraph in form.text_frame.paragraphs:
for run in paragraph.runs:
textual content += ' ' + run.textual content
return textual content
Microsoft Phrase Doc Reader
The wordDocReader class can be utilized for studying Microsoft Phrase Paperwork in Python. It makes use of the doc2txt API and returns a string of the textual content/info positioned inside a given phrase doc.
class wordDocReader:
def __init__(self, file_path: str) -> str:
self.file_path = file_pathdef word_reader(self):
"""A operate that transforms a wordDocReader object right into a Python readable
phrase doc."""
textual content = docx2txt.course of(self.file_path)
textual content = textual content.change('n', ' ')
textual content = textual content.change('xa0', ' ')
textual content = textual content.change('t', ' ')
return textual content
Microsft Excel Reader
Generally researchers will embrace excel sheets of their outcomes with their publications. With the ability to learn the column names, and even the values, may assist with recommending outcomes which can be like what you’re trying to find. For instance, what for those who have been researching info on the previous efficiency of a sure inventory? Possibly you seek for the identify and image which is annotated in a historic efficiency excel sheet. This advice system would advocate the excel sheet to you to assist along with your analysis.
class xlsxReader:def __init__(self, file_path: str) -> str:
self.file_path = file_path
def xlsx_text(self):
"""A operate which returns the string of an
excel doc.
Returns:
textual content(str): String of textual content of a doc.
"""
inputExcelFile = self.file_path
textual content = str()
wb = openpyxl.load_workbook(inputExcelFile)
#It will save the excel sheet as a CSV file
for sn in wb.sheetnames:
excelFile = pd.read_excel(inputExcelFile, engine = 'openpyxl', sheet_name = sn)
excelFile.to_csv("ResultCsvFile.csv", index = None, header=True)
with open("ResultCsvFile.csv", "r") as csvFile:
strains = csvFile.learn().cut up(",") # "rn" if wanted
for val in strains:
if val != '':
textual content += val + ' '
textual content = textual content.change('ufeff', '')
textual content = textual content.change('n', ' ')
return textCSV File Reader
The csvReader class will enable for CSV information to be included in your database and for use within the system’s suggestions.
class csvReader:def __init__(self, file_path: str) -> str:
self.file_path = file_path
def csv_text(self):
"""A operate which returns the string of a
csv doc.
Returns:
textual content(str): String of textual content of a doc.
"""
textual content = str()
with open(self.file_path, "r") as csvFile:
strains = csvFile.learn().cut up(",") # "rn" if wanted
for val in strains:
textual content += val + ' '
textual content = textual content.change('ufeff', '')
textual content = textual content.change('n', ' ')
return textMicrosoft PowerPoint Reader
Right here’s a useful class. Not many individuals take into consideration how there’s invaluable info saved inside the our bodies of PowerPoint shows. These shows are by and huge created to visualise key concepts and data to the viewers. The next class will assist relate any PowerPoints you’ve in your database to different our bodies of knowledge in hopes of steering you in direction of related items of labor.
class pptReader:def __init__(self, file_path: str) -> str:
self.file_path = file_path
def ppt_text(self):
"""A operate which returns the string of a
Mirocsoft PowerPoint doc.
Returns:
textual content(str): String of textual content of a doc.
"""
prs = Presentation(self.file_path)
textual content = str()
for slide in prs.slides:
for form in slide.shapes:
if not form.has_text_frame:
proceed
for paragraph in form.text_frame.paragraphs:
for run in paragraph.runs:
textual content += ' ' + run.textual content
return textMicrosoft Phrase Doc Reader
The ultimate class for this technique is a Microsoft Phrase doc reader. Phrase paperwork are one other invaluable supply of knowledge. Many individuals will write stories, indicating their findings and concepts in phrase doc format.
class wordDocReader:
def __init__(self, file_path: str) -> str:
self.file_path = file_pathdef word_reader(self):
"""A operate which returns the string of a
Microsoft Phrase doc.
Returns:
textual content(str): String of textual content of a doc.
"""
textual content = docx2txt.course of(self.file_path)
textual content = textual content.change('n', ' ')
textual content = textual content.change('xa0', ' ')
textual content = textual content.change('t', ' ')
return textual content
That’s a wrap for the lessons utilized in at this time’s undertaking. Please word: there are tons of different file varieties you should use to reinforce your advice system. A present model of the code being developed will settle for photos and attempt to relate them to different paperwork inside a database!
Preprocessing
Let’s take a look at the best way to preprocess this knowledge. This advice system was constructed for a repository of educational analysis, subsequently the necessity to break the textual content down utilizing the preprocessing steps guided by Pure Language Processing (NLP) was essential.
The information processing class is just referred to as datapreprocessor and the primary operate inside the class is a phrase elements of speech tagger.
class dataprocessor:
def __init__(self):
return@staticmethod
def get_wordnet_pos(textual content: str) -> str:
"""Map POS tag to first character lemmatize() accepts
Inputs:
textual content(str): A string of textual content
Returns:
tag_dict(dict): A dictionary of tags
"""
tag = nltk.pos_tag([text])[0][1][0].higher()
tag_dict = {"J": wordnet.ADJ,
"N": wordnet.NOUN,
"V": wordnet.VERB,
"R": wordnet.ADV}
return tag_dict.get(tag, wordnet.NOUN)
This operate tags the elements of speech in a phrase and can turn out to be useful later within the undertaking.
Second, there’s a operate that conducts the traditional NLP steps many people have seen earlier than. These steps are:
- Lowercase every phrase
- Take away the punctuation
- Take away digits (I solely wished to have a look at non-numeric info. This step might be taken out if desired)
- Stopword removing.
- Lemmanitizaion. That is the place the get_wordnet_pos() operate turns out to be useful for together with elements of speech!
@staticmethod
def preprocess(textual content: str):
"""A operate that prepoccesses textual content via the
steps of Pure Language Processing (NLP).
Inputs:
textual content(str): A string of textual contentReturns:
textual content(str): A processed string of textual content
"""
#lowercase
textual content = textual content.decrease()
#punctuation removing
textual content = "".be a part of([i for i in text if i not in string.punctuation])
#Digit removing (Just for ALL numeric numbers)
textual content = [x for x in text.split(' ') if x.isnumeric() == False]
#Cease removing
stopwords = nltk.corpus.stopwords.phrases('english')
custom_stopwords = ['n','nn', '&', ' ', '.', '-', '$', '@']
stopwords.lengthen(custom_stopwords)
textual content = [i for i in text if i not in stopwords]
textual content = ' '.be a part of(phrase for phrase in textual content)
#lemmanization
lm = WordNetLemmatizer()
textual content = [lm.lemmatize(word, dataprocessor.get_wordnet_pos(word)) for word in text.split(' ')]
textual content = ' '.be a part of(phrase for phrase in textual content)
textual content = re.sub(' +', ' ',textual content)
return textual content
Subsequent, there’s a operate to learn all the information into the system.
@staticmethod
def data_reader(list_file_names):
"""A operate that reads within the knowledge from a listing of information.Inputs:
list_file_names(record): Listing of the filepaths in a listing.
Returns:
text_list (record): A listing the place every worth is a string of textual content
for every file within the listing
file_dict(dict): Dictionary the place the keys are the filename and the values
are the knowledge discovered inside every given file
"""
text_list = []
reader = dataprocessor()
for file in list_file_names:
temp = file.cut up('.')
filetype = temp[-1]
if filetype == "pdf":
file_pdf = pdfReader(file)
textual content = file_pdf.PDF_one_pager()
elif filetype == "docx":
word_doc_reader = wordDocReader(file)
textual content = word_doc_reader.word_reader()
elif filetype == "pptx" or filetype == 'ppt':
ppt_reader = pptReader(file)
textual content = ppt_reader.ppt_text()
elif filetype == "csv":
csv_reader = csvReader(file)
textual content = csv_reader.csv_text()
elif filetype == 'xlsx':
xl_reader = xlsxReader(file)
textual content = xl_reader.xlsx_text()
else:
print('File kind {} not supported!'.format(filetype))
proceed
textual content = reader.preprocess(textual content)
text_list.append(textual content)
file_dict = dict()
for i,file in enumerate(list_file_names):
file_dict[i] = (file, file.cut up('/')[-1])
return text_list, file_dict
As that is the primary model of this technique, I wish to foot stomp that the code may be tailored to incorporate many different file varieties!
The following operate known as the database_preprocess() which is used to course of all the information inside your given database. The enter is an inventory of the information, every with its related string of textual content (processed already). The strings of textual content are then vectorized utilizing sklearn’s tfidVectorizer. What’s that precisely? Principally, it should remodel all of the textual content into completely different characteristic vectors primarily based on the frequency of every given phrase. We do that so we will take a look at how intently associated paperwork are utilizing similarity formulation regarding vector arithmetic.
@staticmethod
@staticmethod
def database_processor(file_dict,text_list: record):
"""A operate that transforms the textual content of every file inside the
database right into a vector.Inputs:
file_dixt(dict): Dictionary the place the keys are the filename and the values
are the knowledge discovered inside every given file
text_list (record): A listing the place every worth is a string of the textual content
for every file within the listing
Returns:
list_dense(record): A listing of the information' textual content became vectors.
vectorizer: The vectorizor used to remodel the strings of textual content
file_vector_dict(dict): A dictionary the place the file names are the keys
and the vectors of every information' textual content are the values.
"""
file_vector_dict = dict()
vectorizer = TfidfVectorizer()
vectors = vectorizer.fit_transform(text_list)
feature_names = vectorizer.get_feature_names_out()
matrix = vectors.todense()
list_dense = matrix.tolist()
for i in vary(len(list_dense)):
file_vector_dict[file_dict[i][1]] = list_dense[i]
return list_dense, vectorizer, file_vector_dict
The rationale a vectorizer is created off of the database is that when a person offers an inventory of phrases to seek for within the database, these phrases might be vectorized primarily based on their frequency in mentioned database. That is the most important weak point of the present system. As we enhance the dimensions of the database, the time and computational allocation wanted for calculating similarities will enhance and decelerate the system. One advice given throughout a high quality management assembly was to make use of Reinforcement Studying for recommending completely different articles of information.
Subsequent, we will use an enter processor that processes any phrase offered right into a vector. That is synonymous to while you kind a request right into a search engine.
@staticmethod
def input_processor(textual content, TDIF_vectorizor):
"""A operate which accepts a string of textual content and vectorizes the textual content utilizing a
TDIF vectorizoer.Inputs:
textual content(str): A string of textual content
TDIF_vectorizor: A pretrained vectorizor
Returns:
phrases(record): A listing of the enter textual content in vectored kind.
"""
phrases = ''
total_words = len(textual content.cut up(' '))
for phrase in textual content.cut up(' '):
phrases += (phrase + ' ') * total_words
total_words -= 1
phrases = [words[:-1]]
phrases = TDIF_vectorizor.remodel(phrases)
phrases = phrases.todense()
phrases = phrases.tolist()
return phrases
Since all the info inside and given to the database might be vectors, we will use cosine similarity to compute the angle between the vectors. The nearer the angle is to 0, the much less related the 2 mentioned vectors might be.
@staticmethod
def similarity_checker(vector_1, vector_2):
"""A operate which accepts two vectors and computes their cosine similarity.Inputs:
vector_1(int): A numerical vector
vector_2(int): A numerical vector
Returns:
cosine_similarity([vector_1], vector_2) (int): Cosine similarity rating
"""
vectors = [vector_1, vector_2]
for vec in vectors:
if np.ndim(vec) == 1:
vec = np.expand_dims(vec, axis=0)
return cosine_similarity([vector_1], vector_2)
As soon as the aptitude of discovering the similarity rating between two vectors is finished, rankings can now be created between the phrases being searched and the paperwork positioned inside the database.
@staticmethod
def recommender(vector_file_list,query_vector, file_dict):
"""A operate which accepts an inventory of vectors, question vectors, and a dictionary
pertaining to the record of vectors with their unique values and file names.Inputs:
vector_file_list(record): A listing of vectors
query_vector(int): A numerical vector
file_dict(dict): A dictionary of filenames and textual content regarding the record
of vectors
Returns:
final_recommendation (record): A listing of the ultimate really useful information
similarity_list[:len(final_recommendation)] (record): A listing of the similarity
scores of the ultimate suggestions.
"""
similarity_list = []
score_dict = dict()
for i,file_vector in enumerate(vector_file_list):
x = dataprocessor.similarity_checker(file_vector, query_vector)
score_dict[file_dict[i][1]] = (x[0][0])
similarity_list.append(x)
similarity_list = sorted(similarity_list, reverse = True)
#Recommends the highest 20%
really useful = sorted(score_dict.objects(),
key=lambda x:-x[1])[:int(np.round(.5*len(similarity_list)))]
final_recommendation = []
for i in vary(len(really useful)):
final_recommendation.append(really useful[i][0])
#add in graph for better than 3 recommendationa
return final_recommendation, similarity_list[:len(final_recommendation)]
The vector file record is the record of vectors we created from the information earlier than. The question vector is a vector of the phrases being searched. The file dictionary was created earlier which makes use of file names for the keys and the information’ textual content as values. Similarities are computed, after which a rating is created favoring probably the most related items of knowledge to the queried phrases being really useful first. Observe, what if there are better than 3 suggestions? Incorporating components of Networks and Graph Principle will add an additional stage of computational profit to this technique and create extra assured suggestions.
Web page Rank Principle
Let’s take a fast detour and go over the idea of web page rank. Don’t get me flawed, cosine similarity is a strong computation for measuring the similarity between vectors, put incorporating web page rank into your advice algorithm permits for similarity comparisons throughout a number of vectors (knowledge inside your database).
Web page rank was first designed by Larry Web page to rank web sites and measure their significance [1]. The fundamental thought is {that a} web site may be deemed “extra essential” if extra web sites are linked to it. Drawing from this concept, a node on a graph may be ranked as extra essential if there’s a lower within the distance of its edge to different nodes. The shorter the collective distance a node has in comparison with different nodes in a graph, the extra essential mentioned node is.
In the present day we’ll use one variation of PageRank referred to as eigenvector centrality. Eigenvector centrality is like PageRank in that it measures the connections between nodes of a graph, assigning greater scores for stronger connections. Largest distinction? Eigenvector centrality will account for the significance of nodes related to a given node to estimate how essential that node is. That is synonymous with saying, an individual who is aware of numerous essential folks could also be crucial themselves via these robust relationships. All-in-all, these two algorithms are very shut in the best way they’re carried out.
For this database, after the vectors are computed, they are often positioned right into a graph the place their edge distance is decided by their similarity to different vectors.
@staticmethod
def ranker(recommendation_val, file_vec_dict):
"""A operate which accepts an inventory of recommendaton values and a dictionary
information wihin the databse and their vectors.Inputs:
reccomendation_val(record): A listing of suggestions discovered via cosine
similarity
file_vec_dic(dict): A dictionary of the filenames as keys and their
textual content in vectors because the values.
Returns:
ec_recommended(record): A listing of the highest 20% suggestions discovered utilizing the
eigenvector centrality algorithm.
"""
my_graph = nx.Graph()
for i in vary(len(recommendation_val)):
file_1 = recommendation_val[i]
for j in vary(len(recommendation_val)):
file_2 = recommendation_val[j]
if i != j:
#Calculate sim_score between two values (weight)
edge_dist = cosine_similarity([file_vec_dict[recommendation_val[i]]],[file_vec_dict[recommendation_val[j]]])
#add an edge from file 1 to file 2 with the load
my_graph.add_edge(file_1, file_2, weight=edge_dist)
#Pagerank the graph ]
rec = nx.eigenvector_centrality(my_graph)
#Takes 20% of the values
ec_recommended = sorted(rec.objects(), key=lambda x:-x[1])[:int(np.round(len(rec)))]
return ec_recommended
Okay, now what? We’ve got the suggestions created by utilizing the cosine similarity between every knowledge level within the database, and suggestions computed by the eigenvector centrality algorithm. Which suggestions ought to we output? Each!
@staticmethod
def weighted_final_rank(sim_list,ec_recommended,final_recommendation):
"""A operate which accepts an inventory of similiarity values discovered via
cosine similairty, suggestions discovered via eigenvector centrality,
and the ultimate suggestions produced by cosine similarity.Inputs:
sim_list(record): A listing of all the similarity values for the information
inside the database.
ec_recommended(record): A listing of the highest 20% suggestions discovered utilizing the
eigenvector centrality algorithm.
final_recommendation (record): A listing of the ultimate suggestions discovered
by utilizing cosine similarity.
Returns:
weighted_final_recommend(record): A listing of the ultimate suggestions for
the information within the database.
"""
final_dict = dict()
for i in vary(len(sim_list)):
val = (.8*sim_list[final_recommendation.index(ec_recommendation[i][0])].squeeze()) + (.2 * ec_recommendation[i][1])
final_dict[ec_recommendation[i][0]] = val
weighted_final_recommend = sorted(final_dict.objects(), key=lambda x:-x[1])[:int(np.round(len(final_dict)))]
return weighted_final_recommend
The ultimate operate of this script will weigh the completely different suggestions produced by cosine similarity and eigenvector centrality. Presently, 80% of the load might be given to the suggestions produced by the cosine similarity suggestions, and 20% of the load might be given to eigenvector centrality suggestions. The ultimate suggestions may be computed primarily based on these weights and aggregated collectively to supply suggestions which can be consultant of all of the similarity computations within the system. The weights can simply be modified by the developer to replicate which batch of suggestions they really feel are extra essential.
Let’s do a fast instance with this code. The paperwork inside my database are all within the codecs beforehand mentioned and pertain to completely different areas of machine studying. Extra paperwork within the database are associated to Generative Adversarial Networks (GANS), so I might suspect these to be really useful first when “Generative Adversarial Community” is the question time period.
path = '/content material/drive/MyDrive/database/'
db = [f for f in glob.glob(path + '*')]research_documents, file_dictionary = dataprocessor.data_reader(db)
list_files, vectorizer, file_vec_dict = dataprocessor.database_processor(file_dictionary,research_documents)
question = 'Generative Adversarial Networks'
question = dataprocessor.preprocess(question)
question = dataprocessor.input_processor(question, vectorizer)
advice, sim_list = dataprocessor.recommender(list_files,question, file_dictionary)
ec_recommendation = dataprocessor.ranker(advice, file_vec_dict)
final_weighted_recommended = dataprocessor.weighted_final_rank(sim_list,ec_recommendation, advice)
print(final_weighted_recommended)
Operating this block of code produces the next suggestions, together with the load worth for every advice.
[(‘GAN_presentation.pptx’, 0.3411272882084124), (‘Using GANs to Augment UAV Data_V2.docx’, 0.16293615818015078), (‘GANS_DAY_1.docx’, 0.12546058188955278), (‘ml_pdf.pdf’, 0.10864164490536887)]
Let’s attempt another. What if I question “Machine Studying” ?
[(‘ml_pdf.pdf’, 0.31244922151487337), (‘GAN_presentation.pptx’, 0.18170070184645432), (‘GANS_DAY_1.docx’, 0.14825501243059303), (‘Using GANs to Augment UAV Data_V2.docx’, 0.1309153863914564)]
Aha! As anticipated, the primary doc really useful is an introductory temporary to machine studying! I solely used 7 paperwork for this instance, and the extra paperwork added, the extra suggestions one will obtain!
In the present day we checked out how one can create a advice system for information you acquire (particularly in case you are gathering analysis for a undertaking). The primary characteristic of this technique is that it goes one step additional in computing the cosine similarity of vectors by adopting the eigenvector centrality algorithm for extra concise, and higher suggestions. Do that out at this time, and I hope it helps you get a greater understanding of how associated the items of information you possess are.
In case you loved at this time’s studying, PLEASE give me a observe and let me know if there’s one other matter you want to me to discover! In case you wouldn’t have a Medium account, enroll via my hyperlink here (I obtain a small fee while you do that)! Moreover, add me on LinkedIn, or be happy to achieve out! Thanks for studying!
Sources
