Voor onze minor Data Science aan de Haagse Hogeschool hebben wij in een groep van 4 mensen een opdracht uitgevoerd namens het CBS. Daarbij werd er getracht de top 10 categorieen, van gegeven data van het CBS, eruit te filteren. Data die door het CBS beschikbaar is gesteld en tevens gebruikt is voor deze opdracht zijn de gestelde vragen per e-mail aan het CBS. Omdat dit zodanig groot bleek te zijn, door het aantal categorieen waarin vragen kunnen worden gesteld meer dan 180 bleek, hebben wij ons als groep beperkt tot 2 datasets:

• Inkomen
• Bevolkingsgroep

Deze datasets hebben wij handmatig gelabeld en vervolgens geprobeerd om ons algoritme op los te laten. Daarbij hebben wij voornamelijk volgende modellen gebruikt:

• Multionomial Naive Bayes
• Complement Naive Bayes
• Logistic Regression

Dit waren ook tevens de modellen met het beste resultaat op onze skewed dataset.

• Naive Bayes = Naive Bayes is een familie van simpele "probabilistic classifier" gebaseerd op de Bayes' theorem met een sterke (naief) onafhankelijkheid veronderstellingen tussen de features
• Machine Learning = Is het wetenschappelijke onderzoek van algoritme en statistische modellen die computers gebruiken om progressieve verbetering te boeken op de prestaties van een specifieke taak.
• Skewed Dataset = Ongebalanceerde dataset tussen verschillende classen
• Logistic Regression = Logistische Regressie binnen de statistiek wordt gebruikt om een dichotome uitkomstvariabele te relateren aan een of meerdere variabelen
• Feature = De input gegeven aan een predictive model.
• Data Cleaning = Het verschonen en categoriseren van de dataset
• TF - IDF Ngram = Hoe belangrijk een woord is in een document of in een collectie van documenten
• Ngram = Model over de relatie tussen woorden. Daarbij creeert het bijvoorbeeld, Unigram(1 woord), Bigram(2 woorden), Trigram (3 woorden) etc. In het geval van een bigram kunnen we meegeven dat 2 bepaalde woorden bij elkaar een bepaalde opbouw van een zin aangeven bijvoorbeeld.
• Data Visualisatie = Het visualiseren van data om zo een beeld te geven van je resultaten of bevindingen
• Data Manipuleren = Het veranderen van metadata van je dataset
• Data Importeren = Het importeren van Data
• Data Preparatie = Het cleanen van "raw data" om als input te dienen voor een predictive model
• Pentesting = Het vinden van kwetsbaarheden in systemen
• OneVsRest = Het kiezen van een class en het trainen van een two class classifier met de samples van een geselecteerde class aan de ene kant en alle andere voorbeelden aan de andere kant.

Alle benodigde opdrachten beschreven in de wekelijkse agenda voor datacamp zijn voltooid. Hieronder wordt per course een korte stuk beschreven over de toegevoegde waarde van de course ten behoeve van mijn ontwikkeling.

Voor bewijs van voltooiing refereer ik graag naar mijn Datacamp Account:

Datacamp Account

• Programmeren (19100 XP)

1. (Course) Introduction to Python , Statement of Accomplishment
2. (Course) Intermediate Python for Data Science , Statement of Accomplishment
3. (Chapter) Writing your own functions , (Chapter dus geen SOA)
4. (Chapter) Default arguments, variable-length arguments and scope , (Chapter dus geen SOA)
5. (Course) Python Data Science Toolbox (Part 2) , Statement of Accomplishment

Het leren van het programmeren van Python heeft er tot bijgedragen dat ik op een basis-gevorderd niveau Python code kan begrijpen. Dit zorgde direct ervoor dat bij het lezen van de code gemaakt (vooral tutorials gevolgd op internet) door de programmeurs van de groep, de code niet vreemd overkwam bij mij op persoon. Dit zorgde er tevens voor dat ik gericht ideeen/feedback kon geven passend op de haalbaarheid van de opdracht zonder dat dit buiten proporties kwam te liggen.

Boven alles heeft dit ervoor gezorgd dat ik kundiger met Linux en tegelijk met Python ben geworden. Dit heeft ervoor gezorgd dat ik in mijn eigen vakgebied (IT - Security) scripts kan begrijpen & schrijven als ik bijvoorbeeld iets aan het pentesten ben. Deze relatie had ik voorheen niet kunnen leggen en dit is zodoende ook een grote positieve bijdrage in mijn carriere.

• Importeren en Cleanen van Data (8020 XP)

1. (Course) Importing Data in Python (Part 1) & Mandatory , Statement of Accomplishment
2. (Chapter) Introduction and flat files , Statement of Accomplishment
3. (Course) Cleaning data in Python , Statement of Accomplishment

Dit gedeelte van Python heeft ervoor gezorgd dat ik nu weet hoe ik verschillende soorten data kan invoeren in python, en vervolgens met deze data aan de slag kan gaan. Het lijkt iets simpels, maar het invoeren van data was voorheen al een hele uitdaging. Bovendien heeft het een beeld gegeven hoe ik met mijn blote oog op zoek moet gaan naar nieuwe "raw" data. Tevens heeft deze course ook bijgedragen aan het leren van cleanen van coding met de pandas package. Dit heb ik in kleine schaal toegepast in de hoofdstuk Data Preparation. Tot slot heeft dit mij een algehele beeld gegeven van hoe ik data kan importeren en cleanen om het bruikbaar te maken voor mijn predictive models.

• Data Manipulatie (2080 XP)

1. (Chapter) Data ingestion & inspection (Chapter dus geen SOA)
2. (Chapter) Exploratory Data Analysis (Chapter dus geen SOA)

In deze chapters heb ik kort geleerd hoe ik met Pandas om kan gaan en heb ik ingezien wat een krachtige tool dit kan zijn. Ik heb dit echter niet toegepast binnen mijn project.

• Data Visualisatie (3520 XP)

1. (Chapter) Plotting 2D Arrays (Chapter dus geen SOA)
2. (Chapter) Statistical plots with Seaborn (Chapter dus geen SOA)
3. (Chapter) Customizing Plots (Chapter dus geen SOA)

Mijn favoriete onderdeel en volgens mij ook het onderdeel wat ik dagelijks gebruik voor mijn eigen werk. Ik heb hierbij geleerd hoe ik mijn grafieken zo goed mogelijk kan visualiseren en heb zelfs Excel afgezworen na het volgen van deze tutorials. Ik gebruik de package seaborn nog dagelijks voor het maken van heatmaps voor mijn werk. Visualisatie is echt key als dit zo goed mogelijk de data vertegenwoordigd. Dit heb ik geleerd van deze course en zal het zonder twijfel een leven lang meedragen.

• Waarschijnlijkheid & Statistiek (4350 XP)

1. (Course) Statistical Thinking in Python (Part 1) Statement of Accomplishment

Een course waarbij wordt weergegeven hoe je statistiek kan vertalen binnen Python. Een cruciale stap binnen Data Science, want je kan zoveel moeite doen om je data te vergaren en het vormen in een product waar je mee kan werken. Het zal je niets opbrengen als je geen duidelijke conclusies van je data kan trekken. Deze course heeft geholpen bij het formuleren van duidelijke resultaten en conclusies voor de paper.

• Machine Learning (4300 XP)

1. (Course) Supervised Learning with scikit-learn , Statement of Accomplishment

De Course die mij heeft geholpen met het maken van een predictive model. Hierbij heb ik informatie vergaard over classificatie, regressie maar ook het fine tunen van mijn model wat cruciaal is. Mijn code voor predictive modelling is veelal gebaseerd op stukjes van de course.

Voor Coursera zijn de weken 1,2,3 en 6 afgerond. De bijbehorende opdrachten zijn daarbij niet gemaakt. Alle quiz onderdelen zijn met een voldoende afgerond.

De video's van Coursera en de bijbehorende quiz hebben bijgedragen tot een betere kennis op het gebied van machine learning. Bij Datacamp lag de focus meer op het toepassen en programmeren. Bij Coursera werd de achterliggende gedachte, formules etc. het gehele concept uitgelegd over machine learning dus ook toepassen. Dat ik de stof begreep getuigd ook van mijn voldoende op de toets. Tevens zorgde het bestuderen van Coursera ervoor dat ik nieuwe ideeen opdeed en dit zorgde er direct voor dat bepaalde handelingen veel makkelijker konden uitgevoerd. Immers, wij begrepen het concept van machine learning veel beter nu.  

In dit hoofdstuk worden de stukjes code die ik heb gemaakt voor het project uitgelegd. Tevens worden er een aantal basis data science technieken beschreven die men acht te beheersen na deze minor.

Voor onze dataset bleek het beste dat er gekozen werd voor een supervised manier van leren. Hierbij zijn wij voorbarig begonnen met allerlei modellen te testen op onze data alvorens wij uberhaupt iets wisten over data science. Na wat onderzoek en veel verder in het project, zijn wij tot conclusie gekomen dat de volgende 3 modellen het best werken voor onze dataset.

• Multinomial Naive Bayes
• Complement Naive Bayes
• Logistic Regression

Deze 3 predictive models hebben wij vervolgens ook toegepast op onze dataset. Daarbij behoort onder andere de volgende code:

class MultiClassifier(BaseModel):
    def __init__(self, trainDF):
        super().__init__()
        prePro = PreProcessor()
        self.pf = PlotFunctions()
        self.trainDF = trainDF
        self.X_train, self.X_test, self.y_train, self.y_test = \
            prePro.split_train_test(trainDF['cleaned_sentence'], trainDF['classification'], 0.4)
        self.X_test, self.X_cross, self.y_test, self.y_cross = \
            prePro.split_train_test(self.X_test, self.y_test, 0.5)
        
        self.all_scores = list()
        self.models = {
            'MultinomialNB': naive_bayes.MultinomialNB(alpha=0.767, class_prior=None, fit_prior=True),
            'ComplementNB': naive_bayes.ComplementNB(alpha=0.767, class_prior=None, fit_prior=True),
            'LogisticRegression': linear_model.LogisticRegression(solver='lbfgs')
        }
        

Dit stukje code is het begin van het testen van ons model. Het bevat onder andere een preprocessor(voor het cleanen van de data). De code test op de 3 predictive modellen hierboven genoemd, ook split de code de dataset in een training / test / cross set. Dit was in het begin niet voldoende, alleen testen op modellen bleek niet de juiste resultaat weer te geven op onze dataset. Na uitgebreid onderzoek en advies zijn wij terecht gekomen op zogeheten word embeddings. Deze word embeddings geven tekst een bepaalde waarde in nummers. Hierdoor kan het model beter begrijpen welke woordcombinatie zwaarder weegt dan het ander. In dit geval zou het gebruikt worden om een bepaalde vraag te herkennen. Zo hebben wij gekeken hoe een vraag zin wordt opgebouwd in het Nederlands en dit als input gegeven aan het model.

Omdat Word Embeddings meerdere modellen kent heb ik er twee gekozen om dit te gebruiken voor ons model. Dit waren de modellen TF - IDF Ngram en Count Vectors.

• TF - IDF
• Count Vectors

    def tfidf_ngram(self, features):
        tfidf_vect_ngram = TfidfVectorizer(
            analyzer='word', token_pattern=r'\w{1,}', ngram_range=(2, 5), max_features=features)
        tfidf_vect_ngram.fit(self.trainDF['cleaned_sentence'])
        xtrain_tfidf = tfidf_vect_ngram.transform(self.X_train)
        xvalid_tfidf = tfidf_vect_ngram.transform(self.X_test)
        xcross_tfidf = tfidf_vect_ngram.transform(self.X_cross)

        for model_name, model in self.models.items():
            mc_model = multiclass.OneVsRestClassifier(model)
            classifier = mc_model.fit(xtrain_tfidf, self.y_train)

            # Training predictions
            self.check_model(classifier, xtrain_tfidf, self.y_train, model_name, features, 'tfidf_ngram', 'training')

            # Test predictions
            self.check_model(classifier, xvalid_tfidf, self.y_test, model_name, features, 'tfidf_ngram', 'test')

            # Cross Validation predictions
            self.check_model(classifier, xcross_tfidf, self.y_cross, model_name, features, 'tfidf_ngram', 'cross')

Predictive model met TFIDF - ngram op onze dataset

Dit model traint op de aantal features en daarbij is gekozen voor een OneVsRest classifier. Deze strategie zorgt ervoor dat je een classifier fit per class. Voor elke classifier is de class gefit tegen alle andere classes. Het is gebruikelijk om voor de OneVsRest classifier te kiezen bij een Multi-class classification. Tot slot split dit stukje code de data in Training, Test en een Cross Validation set.

Voor het model van de count_vectors is hetzelfde principe toegepast. Te zien hieronder:

• Count Vectors.

    def count_vectors(self, features):
        count_vect = CountVectorizer(analyzer='word', token_pattern=r'\w{1,}', max_df=1.0, max_features=features)
        count_vect.fit(self.trainDF['cleaned_sentence'])
        xtrain_count = count_vect.transform(self.X_train)
        xvalid_count = count_vect.transform(self.X_test)
        xcross_count = count_vect.transform(self.X_cross)

        for model_name, model in self.models.items():
            mc_model = multiclass.OneVsRestClassifier(model)
            classifier = mc_model.fit(xtrain_count, self.y_train)

            # Training predictions
            self.check_model(classifier, xtrain_count, self.y_train, model_name, features, 'count_vectors', 'training')

            # Test predictions
            self.check_model(classifier, xvalid_count, self.y_test, model_name, features, 'count_vectors', 'test')

            # Cross Validation predictions
            self.check_model(classifier, xcross_count, self.y_cross, model_name, features, 'count_vectors', 'cross')

Predictive model met count vectors op onze dataset.

De toegevoegde waarde van mijn code op het project was het feit dat er ten eerste predictive model(len) zijn toegepast. Vervolgens zijn deze modellen ook met bovengenoemde vormen van word embedding toegepast op onze data. Daaruit is gebleken welk model het beste was voor onze dataset. Uiteindelijk heeft het ervoor gezorgd dat er een vergelijking is gemaakt tussen allerlei modellen, en daaruit is het beste model gekozen. Ook omdat elk model getest is tegenover Logistic Regression, Multinomial NB & Complement NB, kan de conclusie getrokken worden welk predictive model + word embeddings het best werken op de dataset.

Tot slot is gebleken dat de predictive model Logistic Regression met count vectors het beste model bleek te zijn voor ons dataset.

Uiteindelijke resultaat van F1-score bij cross validatie set op datasets met verschillende verhoudingen van classificatie 3 vs de rest.

Voor het project heb ik op het gebied van Data preparation een stukje datacleaning toegepast.

Dit kan uitgevoerd worden in verschillende manieren, ik heb er twee toegepast op de dataset:

• Aggregeren van Data - Het in een leesbare tabel zetten van verkregen e-mail data(uitgevoerd door mij op de dataset )

Hiervoor heb ik gebruik gemaakt van de package pandas in Python. Dit is geleerd op de courses van datacamp:

import pandas as pd


# Data laden van een .csv file
data = pd.DataFrame.from_csv('cbs.data')
# Converteren van data van een string naar tijd
data['date'] = data['date'].apply(dateutil.parser.parse, dayfirst=True)

Dit was een stukje die ik had toegepast om in ieder geval de data van CBS e-mails in een datum formaat te zetten zodat het duidelijk was welke email op welke datum is verstuurd.

&

• Het invoeren van data waar cellen leeg staan - Meestal wordt er door een script gekeken waar data leegstaat. Alle data die het model als <1 herkent wordt vervangen met een 0. Soms wordt het vervangen door een NaN = Not a Number.

Bij het zogeheten cleanen en voorbereiden van data heb ik een aantal tutorials gevolgd waarbij naar voren kwam hoe men leegstaande cellen zo goed mogelijk kon aanpakken. Daarbij is door mij de volgende code gehanteerd:

# Lijst van alle leegstaande waarde
lege_waarden = ["n/a", "na", "--"]
df = pd.read_csv("cbs.csv", na_values = lege_waarden)

Zoals in de comment staat, zorgt dit stukje code ervoor dat het een lijst maakt van de dataset waarbij alle data die leegstaat wordt geinventariseerd. Vervolgens heb ik gekozen om leegstaande vakken te vervangen door een nummer met de volgende code:

# Leegstaande waarde veranderen door een nummer
df['cbs].fillna(125, inplace=True)

De toegevoegde waarde van het cleanen van data is dat er vooral een overzicht komt van de bruikbare data. Ook kan het ervoor zorgen dat men een verborgen patroon herkent in de data die voorheen niet gezien kon worden. Tot slot kan het ervoor zorgen dat men bij het debuggen uren werk minder hoeft te doen wanneer je een diagnose / analyse gaat uitvoeren op je data. Echter, moet er opgemerkt worden dat bij het teveel "cleanen" van data je veel cruciale data kan verliezen, gelukkig was mijn bijdrage niet te ingrijpend om dit daadwerkelijk zien te gebeuren.

Tevens heb ik samen met mijn collega's data gelabeld in 4 classificaties voor het predictive model. De code hiervoor en mijn aandeel staat beschreven in het kopje Predictive Models

Confusion Matrix Visualisatie

def create_confusion_matrix(self, valid_y, predictions_valid, model_name):
    # Compute confusion matrix
    cnf_matrix = confusion_matrix(valid_y, predictions_valid)
    np.set_printoptions(precision=2)
    # Plot non-normalized confusion matrix
    plt.figure()
    class_names = ['Beschikbaarheidsvraag', 'Verduidelijkingsvraag', 'Niet relevant', 'Relevante query vraag']
    self.plot_confusion_matrix(cnf_matrix,
                               classes=class_names,
                               title=model_name + ' Confusion matrix, without normalization')

    # Plot normalized confusion matrix
    plt.figure()
    self.plot_confusion_matrix(cnf_matrix, classes=class_names,
                               normalize=True,
                               title=model_name + ' Normalized confusion matrix')

    plt.show()

Het idee van het uitvoeren van een confusion matrix op de test set is om te kijken hoe het model een voorspelling uitvoert ten opzichte van onze classificatie. Zo kon er vervolgens bepaald worden op welke punten het model niet een goede voorspelling deed, of dat er sprake was van een overfit of iets dergelijks. Ook kon er een diagnose worden gedaan van de machine learning model in vorm van een Error Analyse.

In de gemaakte code kan men 2 soorten modellen van de confusion matrix onderscheiden:

• Normalized Confusion Matrix
• Non - Normalized Confusion Matrix

• Van beide confusion matrix visualisaties is de input het geschetste model beschreven in hoofdstuk predictive modelling. Daar is ook beschreven dat Logistic Regression uiteindelijk het best mogelijke model is voor onze dataset.
• Te zien is hoe wij data hebben gelabeld op de "True Label" en hoe het model dit heeft voorspelt op de "Predicted Label".
• Alhoewel ik de confusion matrix op de Training, Cross validation en Test set heb gemaakt, schrijft de error analyse voor dat het uitgevoerd zal moeten worden op de test set. Vandaar de visualisatie van de test set.
• Normalization is gedaan om de snelheid van data te optimaliseren. Ook geeft het model verschil aan tussen zinnen en percentage. Dit bleek achteraf handig te zijn om letterlijk uit te vinden waarom een model iets voorspelt wat wij anders hebben geclassificeerd.

Credits: Om het bovenstaande te visualiseren heb ik samengewerkt met Timo Frionnet om de code te realiseren. Voor de error analyse gebaseerd op de gemaakte confusion matrix verwijs ik naar het kopje Evaluatie

Multi-class classification | Vier classificaties
De multi-class classification bestaat uit de volgende vier classificaties:
•	Niet-relevante beschikbaarheidsvraag: classificatie 1
Beschikbaarheidsvragen zijn niet-relevante vragen waarin een verzoek wordt gediend om informatie te verkrijgen over:
o	wanneer nieuwe cijfers gepubliceerd en/of geüpdatet zullen worden.
•	Niet-relevante verduidelijkingsvraag: classificatie 2
Verduidelijkingsvragen zijn niet-relevante vragen waarin een verzoek wordt gediend om informatie te verkrijgen over één of meerdere onderdelen:
o	totstandkoming van specifieke cijfers in publicaties en/of Statline.
o	definities van de gehanteerde termen in publicaties en/of Statline.
•	Niet-relevante zinnen: classificatie 3
Niet-relevante zinnen zijn zinnen waarin meningsuitingen over maatschappelijke onderwerpen worden gegeven, afsluitingen van e-mails en introductie van e-mails.

•	Relevante query vraag: classificatie 4
Query vragen zijn relevante vragen waarin een verzoek wordt gediend om informatie te verkrijgen over één of meerdere onderdelen:
o	specifieke cijfers van een onderwerp wat binnen een thema van het CBS valt. 
o	concrete gegevens van een onderwerp wat binnen een thema van het CBS valt. Denk hierbij aan inkomen wat onder CBS-categorie ‘Beroepsbevolking’ valt.
Bij een query vraag wordt de context van de vraag tevens als query vraag geclassificeerd, zodat de input van een query als volledig wordt beschouwd. 

    def count_vectors(self, cvalue):
        count_vect = CountVectorizer(analyzer='word', token_pattern=r'\w{1,}', max_df=1.0, max_features=1500)
        count_vect.fit(self.trainDF['cleaned_sentence'])
        xtrain_count = count_vect.transform(self.X_train)
        xvalid_count = count_vect.transform(self.X_test)
        xcross_count = count_vect.transform(self.X_cross)

        for model_name, model in self.models.items():
            model.C = cvalue
            mc_model = multiclass.OneVsRestClassifier(model)
            classifier = mc_model.fit(xtrain_count, self.y_train)

            # Training predictions
            self.check_model(classifier, xtrain_count, self.y_train, model_name, features, 'count_vectors', 'training')

            # Test predictions
            self.check_model(classifier, xvalid_count, self.y_test, model_name, features, 'count_vectors', 'test')

            # Cross Validation predictions
            self.check_model(classifier, xcross_count, self.y_cross, model_name, features, 'count_vectors', 'cross')

Voor de evaluatie van het model om te zien wanneer er precies sprake is van een overfit of underfit is ongeveer hetzelfde soort code toegepast bij predictive modelling. Echter, zijn er een aantal wijzigingen gemaakt:

• Data die uit mijn code is voortgevloeid is als .csv bestand in excel geimporteerd en vervolgens gevisualiseerd. Hierbij is geen code gebruikt van Python
• Input van data voor de visualisatie is de data output waarbij modellen die ik heb beschreven zijn gebruikt in het hoofdstuk: Predictive Modelling
• In plaats van features wordt nu gebruik gemaakt van cvalue (nieuwe feature)
• Max aantal features is nu 1500, uit eerdere tests van mijn collega's bleek dat na 1500 features sprake was van een overfit.
• Gehanteerde range is nu veranderd van -5 tot 5.
• Alle gehanteerde inputs zijn de standaard inputs zoals max_df (verwijderen van termen dat te vaak voorkomen) = 1.0 etc. Deze bleek ook goed op de data te passen, te zien op de screenshot hier onder.

    def get_and_print_all_scores(self):
        print('Running for count_vectors')
        for i in range(-5, 5):
            self.count_vectors(10**i)
            self.tfidf_words(i)
            self.tfidf_ngram(i)
            self.tfidf_char(i)

Code voor het veranderen van de range

In dit model is te zien dat alles onder <1 Range underfit is en boven de 1 Range overfit. Hierbij is te zien dat de default input van het model werkt op ons model. Door middel van deze code is dus af te leiden voor de onderzoekers wanneer er sprake zou kunnen zijn van een overfit.

Ook hebben wij constant in het project geevalueerd op F1 Score, Recall en Precision. Door deze scores te hanteren kon men in een opslag zien welk model het beste werkte voor onze dataset.

Aanvullend op de confusion matrix visualisatie, heb ik een diagnose uitgevoerd op dit model en de test dataset. Dit zorgde ervoor dat wij konden zien waar het model problemen had met het voorspellen. Door middel van de error analyse herkende wij ook patronen in onze data, dit zorgde er direct voor dat wij het model zodanig konden tweaken dat het beter zou performen.

Een aantal punten die uit de error analyse is voortgekomen:

• Het model voorspelt vragen met aanhef meestal als geen vraag
• Het model heeft relevante vragen beter voorspelt dan de onderzoekers
• Het model had een precision & recall van bijna 80&

Presentaties zijn altijd gezamenlijk gemaakt met de inbreng van de groep. Omdat ik, zoals aangegeven, meer in de kant van het onderzoeken was, presenteerde ik ook veel meer. In totaal heb ik 10 keer gepresenteerd waarvan 2 keer alleen.

Presentaties per week:

• Week 1
• Week 2
• Week 3
• Week 4
• Week 5
• Week 6
• Week 7
• Week 8
• Week 9
• Week 10
• Week 11
• Week 12
• Week 13
• Week 14
• Week 15
• Week 16

De paper is een gezamenlijke bijdrage van de gehele groep. Omdat ik geen fervente coder ben, heb ik samen met mijn collega Seyma Irilmazbilek vooral gericht tot de taak onderzoeken en delen van kennis(o.a. aanpak, ideeen etc.) aan ons groepsgenoten binnen dit blok. Zodoende was de paper meer mijn domein.

Zo heb ik het volgende uitgevoerd binnen de paper:

• Related Work
• Gedeelte Methode
• Gedeelte Aanpak
• Bronnen uitzoeken relevant voor ons opdracht, uitdragen en citeren in het verslag (Graag verwijs ik naar kopje literatuur)
• (Code)Error Analyse samen met Timo Frionnet
• Conclusie & Discussie
• APA Verslag, Figuren, Vergelijkingen, Bronnen
• Layout

Het gehele rapport zal ook apart worden ingeleverd. I.v.m. de vertrouwelijkheid van data zal ik niet naar het rapport verwijzen in dit portfolio.

Taken en activiteiten beknopt:

• Domein Studie: Dit houdt in dat ik onderzoek deed naar alle gerelateerde onderzoeken op dit gebied. Maar ook naar bepaalde gehanteerde methodieken etc. Dit heb ik vervolgens geinventariseerd en uitgedragen binnen het project groep.
• Het onderzoeksplan voor ons opdracht opstellen en presenteren aan het CBS
• Linear Classifier Methode Onderzoeken & Beschrijven
• Logistic Regression Methode Onderzoeken & Beschrijven
• Word Level TF - IDF Methode Onderzoeken & Beschrijven
• Linear Regression & TF - IDF & Naive Bayes Voordelen, Nadelen omschrijven per type model
• Language Models Onderzoeken
• Formule uitleggen Extreme Gradient Boosting & Linear Regression
• Onderzoek Deep Learning Models
• Related Work - Bronnen onderzoeken gerelateerd aan ons project
• Research Paper
• POS Tagging > Text Classificatie methoden en modellen onderzoek
• Multinomial Naive Bayes > Onderzoek
• Text Classificatie methoden en modellen onderzoeken & uitschrijven
• Datasets labelen in 4 classificaties
• Confusion Matrixes maken van gelabelde datasets
• Error Analyse over Training - Test - Cross set

Daarentegen waren er onderwerpen die ik probleemloos afmaakte, ook het coderen van python en het keer op keer falen vond ik niet erg. Ik had er mijn passie in gevonden en ik zou het blijven doen tot ik er voldoende skilled in was. Ik heb bovendien heel veel geleerd op het gebied van Machine Learning, vooral het onderzoeken en het vertalen naar een model was leerzaam. Ik heb wel het idee dat ik aardig kan meepraten als men het nu over data science heeft. Wellicht was dat mijn doel ook al die tijd, ik had sowieso niet verwacht de beste data scientist te worden binnen 5 maanden. Stiekem had ik wel verwacht dat ik een carriere in de data science zag. Dat is nu wel veranderd, ik denk dat ik toch meer hou van mijn eigen vakgebied (IT-Security).

Sommige lessen gingen wel eens van 0 naar 100 voor mijn gevoel, lang leve de internet en jaar 2018 waar alles tegenwoordig online te vinden staat zeg ik dan maar. Ik heb ook een hele goede groep gehad moet ik bekennen die elkaar steunde door dik en dun. Wij als groep hebben het ook niet makkelijk gehad, zo zijn er vroegtijdig al 2 groepsgenoten ons project verlaten. Dit zorgde ervoor dat ons groep tijdelijk ons evenwicht kwijtraakte. Gelukkig hebben wij dat kunnen herpakken.

Ik heb veel geleerd over Data Science en hoe men dit kan toepassen in de praktijk. Maar vooral van het vak zelf. Wat inspireert mensen, wat beweegt mensen. Hoe krijg je van niets naar een prachtig model. Het is toch een passie die niet voor vele is weggelegd. Maar als men mij zal vragen zal je ooit iets met data science doen? Wellicht, maar niet in de nabije toekomst. Wel zal ik Python vaak gebruiken, dat is een taal die ik inmiddels goed heb omarmd en dit zal ik dan ook zeer zeker voor een lange tijd gebruiken.

Ik vind wel dat de course een strengere eis moet gaan stellen voor het programmeren en het begrijpen van wiskunde op gebied van statistiek. Ik begrijp overigens dat de minor niet vraagt dat je opeens een prodigy bent na 5 maanden, maar toch is het soms lastig in te komen.

Tot slot wil ik zeggen dat ik wel een positief gevoel heb over gehouden aan de leraren en de sfeer in de klas. De leraren wisten waar ze over praatte en bij Jeroen had ik het idee dat er geen een onderwerp was in Machine Learning waar hij geen weet van had. Dat is toch prettig af en toe, dat je leraren hebt die weten waar ze over praten. Dat is naar mijn ervaring niet altijd zo geweest.