Cursus
Supervised Learning met scikit-learn
4 uur
305.8K
- Data verkennen
- De trainingsdata extraheren
- Vectorizer-classifiers bouwen
- Intermezzo: Count versus TF-IDF-features
- Conclusie
Het detecteren van zogenaamd “nepnieuws” is geen eenvoudige taak. Om te beginnen moet je definiëren wat nepnieuws is – een term die inmiddels ook een politieke lading heeft gekregen. Als je een definitie kunt vinden of overeenkomen, moet je vervolgens echt en nep nieuws verzamelen en correct labelen (bij voorkeur over vergelijkbare onderwerpen om duidelijke verschillen te laten zien). Eenmaal verzameld, moet je vervolgens bruikbare features vinden om nep van echt nieuws te onderscheiden.
Voor een diepgaandere kijk op dit probleem raad ik het artikel van Miguel Martinez-Alvarez aan: “How can Machine Learning and AI Help Solve the Fake News Problem”.
Ongeveer in dezelfde periode dat ik Miguels inzichtelijke post las, kwam ik een post op Open Data Science tegen over het bouwen van een succesvolle nepnieuwsdetector met Bayesiaanse modellen. De auteur maakte zelfs een repository met de dataset van gelabelde nep- en echte nieuwsvoorbeelden. Ik was benieuwd of ik de resultaten eenvoudig kon reproduceren en of ik vervolgens kon achterhalen wat het model had geleerd.
In deze tutorial loop je mee met een deel van mijn eerste verkenning en kijk je of je een succesvolle nepnieuwsdetector kunt bouwen!
Tip: wil je meer leren over de basis van Natural Language Processing (NLP), overweeg dan de cursus Natural Language Processing Fundamentals in Python.
Data verkennen
Begin altijd met een snelle blik op de data om gevoel te krijgen bij de inhoud. Gebruik hiervoor een Pandas DataFrame en controleer de shape, head en pas waar nodig transformaties toe.
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZCIsInNhbXBsZSI6IiMgSW1wb3J0IGBmYWtlX29yX3JlYWxfbmV3cy5jc3ZgIFxuZGYgPSBfXy5fX19fX19fXyhcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKVxuICAgIFxuIyBJbnNwZWN0IHNoYXBlIG9mIGBkZmAgXG5kZi5fX19fX1xuXG4jIFByaW50IGZpcnN0IGxpbmVzIG9mIGBkZmBcbmRmLl9fX19fXyIsInNvbHV0aW9uIjoiIyBJbXBvcnQgYGZha2Vfb3JfcmVhbF9uZXdzLmNzdmAgXG5kZiA9IHBkLnJlYWRfY3N2KFwiaHR0cHM6Ly9zMy5hbWF6b25hd3MuY29tL2Fzc2V0cy5kYXRhY2FtcC5jb20vYmxvZ19hc3NldHMvZmFrZV9vcl9yZWFsX25ld3MuY3N2XCIpXG4gICAgXG4jIEluc3BlY3Qgc2hhcGUgb2YgYGRmYCBcbmRmLnNoYXBlXG5cbiMgUHJpbnQgZmlyc3QgbGluZXMgb2YgYGRmYCBcbmRmLmhlYWQoKSIsInNjdCI6InRlc3Rfb2JqZWN0KFwiZGZcIiwgdW5kZWZpbmVkX21zZz1cIkRpZCB5b3UgaW1wb3J0IHRoZSBkYXRhIGNvcnJlY3RseT9cIixpbmNvcnJlY3RfbXNnPVwiTWFrZSBzdXJlIHRvIHVzZSB0aGUgUGFuZGFzIGByZWFkX2NzdigpYCBmdW5jdGlvbiB0byByZWFkIGluIHRoZSBkYXRhIVwiKVxudGVzdF9vYmplY3RfYWNjZXNzZWQoXCJkZi5zaGFwZVwiLCBub3RfYWNjZXNzZWRfbXNnPVwiRGlkIHlvdSB1c2UgYHNoYXBlYCB0byByZXRyaWV2ZSB0aGUgc2hhcGUgb2YgdGhlIGBkZmA/XCIpXG50ZXN0X2Z1bmN0aW9uKFwiZGYuaGVhZFwiKVxuc3VjY2Vzc19tc2coXCJOaWNlIG9uZSFcIikifQ==
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZGYgPSBwZC5yZWFkX2NzdihcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKSIsInNhbXBsZSI6IiMgU2V0IGluZGV4XG5kZiA9IGRmLnNldF9pbmRleChcIlVubmFtZWQ6IDBcIikgXG5cbiMgUHJpbnQgZmlyc3QgbGluZXMgb2YgYGRmYCBcbmRmLl9fX19fXyIsInNvbHV0aW9uIjoiIyBTZXQgaW5kZXggXG5kZiA9IGRmLnNldF9pbmRleChcIlVubmFtZWQ6IDBcIilcblxuIyBQcmludCBmaXJzdCBsaW5lcyBvZiBgZGZgIFxuZGYuaGVhZCgpIiwic2N0IjoidGVzdF9vYmplY3QoXCJkZlwiKVxudGVzdF9mdW5jdGlvbihcImRmLmhlYWRcIilcbnN1Y2Nlc3NfbXNnKFwiQXdlc29tZSBqb2IhXCIpIn0=
De trainingsdata extraheren
Nu de DataFrame meer lijkt op wat je nodig hebt, wil je de labels scheiden en trainings- en testdatasets instellen.
Voor dit notebook heb ik ervoor gekozen me te richten op de langere artikeltekst. Omdat ik wist dat ik bag-of-words en Term Frequency–Inverse Document Frequency (TF-IDF) zou gebruiken om features te extraheren, leek dit een goede keuze. Door langere tekst te gebruiken, krijg je hopelijk onderscheidende woorden en features voor mijn echte en nepnieuwsdata.
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdFxuaW1wb3J0IHBhbmRhcyBhcyBwZFxuZGYgPSBwZC5yZWFkX2NzdihcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKVxuZGYgPSBkZi5zZXRfaW5kZXgoXCJVbm5hbWVkOiAwXCIpICIsInNhbXBsZSI6IiNTZXQgYHlgIFxueSA9IGRmLl9fX19fIFxuIFxuIyBEcm9wIHRoZSBgbGFiZWxgIGNvbHVtbiBcbmRmLl9fX18oXCJsYWJlbFwiLCBheGlzPTEpIFxuIFxuIyBNYWtlIHRyYWluaW5nIGFuZCB0ZXN0IHNldHMgXG5YX3RyYWluLCBYX3Rlc3QsIHlfdHJhaW4sIHlfdGVzdCA9IF9fX19fX19fX19fX19fX18oZGZbJ3RleHQnXSwgeSwgdGVzdF9zaXplPTAuMzMsIHJhbmRvbV9zdGF0ZT01MykiLCJzb2x1dGlvbiI6IiMgU2V0IGB5YCBcbnkgPSBkZi5sYWJlbCBcblxuIyBEcm9wIHRoZSBgbGFiZWxgIGNvbHVtblxuZGYuZHJvcChcImxhYmVsXCIsIGF4aXM9MSlcblxuIyBNYWtlIHRyYWluaW5nIGFuZCB0ZXN0IHNldHMgXG5YX3RyYWluLCBYX3Rlc3QsIHlfdHJhaW4sIHlfdGVzdCA9IHRyYWluX3Rlc3Rfc3BsaXQoZGZbJ3RleHQnXSwgeSwgdGVzdF9zaXplPTAuMzMsIHJhbmRvbV9zdGF0ZT01MykiLCJzY3QiOiJ0ZXN0X29iamVjdChcInlcIilcbnRlc3Rfb2JqZWN0KFwiZGZcIilcbnRlc3Rfb2JqZWN0KFwiWF90ZXN0XCIsIGRvX2V2YWw9RmFsc2UsIHVuZGVmaW5lZF9tc2c9XCJEaWQgeW91IGRlZmluZSBgWF90ZXN0YD9cIilcbnRlc3Rfb2JqZWN0KFwiWF90cmFpblwiLCBkb19ldmFsPUZhbHNlLCB1bmRlZmluZWRfbXNnPVwiRGlkIHlvdSBkZWZpbmUgYFhfdHJhaW5gP1wiKVxudGVzdF9vYmplY3QoXCJ5X3RyYWluXCIsIGRvX2V2YWw9RmFsc2UsIHVuZGVmaW5lZF9tc2c9XCJEaWQgeW91IGRlZmluZSBgeV90cmFpbmA/XCIpXG50ZXN0X29iamVjdChcInlfdGVzdFwiLCBkb19ldmFsPUZhbHNlLCB1bmRlZmluZWRfbXNnPVwiRGlkIHlvdSBkZWZpbmUgYHlfdGVzdGA/XCIpXG5zdWNjZXNzX21zZyhcIkF3ZXNvbWUgam9iIVwiKSJ9
Vectorizer-classifiers bouwen
Nu je je trainings- en testdata hebt, kun je je classifiers bouwen. Om een goed beeld te krijgen of de woorden en tokens in de artikelen een significante invloed hadden op de vraag of het nieuws nep of echt was, begin je met CountVectorizer en TfidfVectorizer.
Je ziet dat in het voorbeeld een maximale drempel is ingesteld op .7 voor de TF-IDF-vectorizer tfidf_vectorizer met het argument max_df. Dit verwijdert woorden die in meer dan 70% van de artikelen voorkomen. Ook verwijdert de ingebouwde parameter stop_words Engelse stopwoorden uit de data voordat er vectors worden gemaakt.
Er zijn nog veel meer parameters beschikbaar en je kunt er alles over lezen in de scikit-learn-documentatie voor TfidfVectorizer en CountVectorizer.
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdCBcbmZyb20gc2tsZWFybi5mZWF0dXJlX2V4dHJhY3Rpb24udGV4dCBpbXBvcnQgQ291bnRWZWN0b3JpemVyIFxuZGYgPSBwZC5yZWFkX2NzdihcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKVxuZGYgPSBkZi5zZXRfaW5kZXgoJ1VubmFtZWQ6IDAnKVxueSA9IGRmLmxhYmVsXG5kZiA9IGRmLmRyb3AoJ2xhYmVsJywgYXhpcz0xKVxuWF90cmFpbiwgWF90ZXN0LCB5X3RyYWluLCB5X3Rlc3QgPSB0cmFpbl90ZXN0X3NwbGl0KGRmWyd0ZXh0J10sIHksIHRlc3Rfc2l6ZT0wLjMzLCByYW5kb21fc3RhdGU9NTMpIiwic2FtcGxlIjoiIyBJbml0aWFsaXplIHRoZSBgY291bnRfdmVjdG9yaXplcmAgXG5jb3VudF92ZWN0b3JpemVyID0gX19fX19fX19fX19fX19fKHN0b3Bfd29yZHM9J2VuZ2xpc2gnKSBcblxuIyBGaXQgYW5kIHRyYW5zZm9ybSB0aGUgdHJhaW5pbmcgZGF0YSBcbmNvdW50X3RyYWluID0gY291bnRfdmVjdG9yaXplci5fX19fX19fX19fX19fKFhfdHJhaW4pIFxuXG4jIFRyYW5zZm9ybSB0aGUgdGVzdCBzZXRcbmNvdW50X3Rlc3QgPSBjb3VudF92ZWN0b3JpemVyLl9fX19fX19fXyhYX3Rlc3QpIiwic29sdXRpb24iOiIjIEluaXRpYWxpemUgdGhlIGBjb3VudF92ZWN0b3JpemVyYCBcbmNvdW50X3ZlY3Rvcml6ZXIgPSBDb3VudFZlY3Rvcml6ZXIoc3RvcF93b3Jkcz0nZW5nbGlzaCcpXG5cbiMgRml0IGFuZCB0cmFuc2Zvcm0gdGhlIHRyYWluaW5nIGRhdGEgXG5jb3VudF90cmFpbiA9IGNvdW50X3ZlY3Rvcml6ZXIuZml0X3RyYW5zZm9ybShYX3RyYWluKSBcblxuIyBUcmFuc2Zvcm0gdGhlIHRlc3Qgc2V0IFxuY291bnRfdGVzdCA9IGNvdW50X3ZlY3Rvcml6ZXIudHJhbnNmb3JtKFhfdGVzdCkiLCJzY3QiOiJ0ZXN0X29iamVjdChcImNvdW50X3ZlY3Rvcml6ZXJcIiwgZG9fZXZhbD1GYWxzZSlcbnRlc3Rfb2JqZWN0KFwiY291bnRfdHJhaW5cIiwgZG9fZXZhbD1GYWxzZSlcbnRlc3Rfb2JqZWN0KFwiY291bnRfdGVzdFwiLCBkb19ldmFsPUZhbHNlLCB1bmRlZmluZWRfbXNnPVwiRGlkIHlvdSBkZWZpbmUgYGNvdW50X3Rlc3RgP1wiKVxuc3VjY2Vzc19tc2coXCJHcmVhdCBqb2IhXCIpIn0=
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdCBcbmZyb20gc2tsZWFybi5mZWF0dXJlX2V4dHJhY3Rpb24udGV4dCBpbXBvcnQgVGZpZGZWZWN0b3JpemVyIFxuZGYgPSBwZC5yZWFkX2NzdihcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKVxuZGYgPSBkZi5zZXRfaW5kZXgoJ1VubmFtZWQ6IDAnKVxueSA9IGRmLmxhYmVsXG5kZiA9IGRmLmRyb3AoJ2xhYmVsJywgYXhpcz0xKVxuWF90cmFpbiwgWF90ZXN0LCB5X3RyYWluLCB5X3Rlc3QgPSB0cmFpbl90ZXN0X3NwbGl0KGRmWyd0ZXh0J10sIHksIHRlc3Rfc2l6ZT0wLjMzLCByYW5kb21fc3RhdGU9NTMpIiwic2FtcGxlIjoiIyBJbml0aWFsaXplIHRoZSBgdGZpZGZfdmVjdG9yaXplcmBcbnRmaWRmX3ZlY3Rvcml6ZXIgPSBfX19fX19fX19fX19fX18oc3RvcF93b3Jkcz0nZW5nbGlzaCcsIG1heF9kZj0wLjcpIFxuXG4jIEZpdCBhbmQgdHJhbnNmb3JtIHRoZSB0cmFpbmluZyBkYXRhIFxudGZpZGZfdHJhaW4gPSB0ZmlkZl92ZWN0b3JpemVyLl9fX19fX19fX19fX18oWF90cmFpbikgXG5cbiMgVHJhbnNmb3JtIHRoZSB0ZXN0IHNldCBcbnRmaWRmX3Rlc3QgPSB0ZmlkZl92ZWN0b3JpemVyLl9fX19fX19fXyhYX3Rlc3QpIiwic29sdXRpb24iOiIjIEluaXRpYWxpemUgdGhlIGB0ZmlkZl92ZWN0b3JpemVyYCBcbnRmaWRmX3ZlY3Rvcml6ZXIgPSBUZmlkZlZlY3Rvcml6ZXIoc3RvcF93b3Jkcz0nZW5nbGlzaCcsIG1heF9kZj0wLjcpIFxuXG4jIEZpdCBhbmQgdHJhbnNmb3JtIHRoZSB0cmFpbmluZyBkYXRhIFxudGZpZGZfdHJhaW4gPSB0ZmlkZl92ZWN0b3JpemVyLmZpdF90cmFuc2Zvcm0oWF90cmFpbikgXG5cbiMgVHJhbnNmb3JtIHRoZSB0ZXN0IHNldCBcbnRmaWRmX3Rlc3QgPSB0ZmlkZl92ZWN0b3JpemVyLnRyYW5zZm9ybShYX3Rlc3QpIiwic2N0IjoidGVzdF9vYmplY3QoXCJ0ZmlkZl92ZWN0b3JpemVyXCIsIGRvX2V2YWw9RmFsc2UpXG50ZXN0X29iamVjdChcInRmaWRmX3RyYWluXCIsIGRvX2V2YWw9RmFsc2UpXG50ZXN0X29iamVjdChcInRmaWRmX3Rlc3RcIiwgZG9fZXZhbD1GYWxzZSwgdW5kZWZpbmVkX21zZz1cIkRpZCB5b3UgZGVmaW5lIGBjb3VudF90ZXN0YD9cIilcbnN1Y2Nlc3NfbXNnKFwiV2VsbCBkb25lIVwiKSJ9
Nu je vectors hebt, kun je vervolgens kijken naar de vectorfeatures, opgeslagen in count_vectorizer en tfidf_vectorizer.
Zie je opvallende problemen? (Ja!)
Er zitten duidelijk commentaren, metingen of andere onsamenhangende woorden in, evenals meertalige artikelen in de dataset die je gebruikt hebt. Normaal gesproken zou je meer tijd besteden aan preprocessing en het verwijderen van ruis, maar omdat deze tutorial slechts een kleine proof of concept laat zien, kijk je of het model de ruis kan overwinnen en ondanks deze problemen correct kan classificeren.
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdFxuZnJvbSBza2xlYXJuLmZlYXR1cmVfZXh0cmFjdGlvbi50ZXh0IGltcG9ydCBUZmlkZlZlY3Rvcml6ZXIsIENvdW50VmVjdG9yaXplciBcbmRmID0gcGQucmVhZF9jc3YoXCJodHRwczovL3MzLmFtYXpvbmF3cy5jb20vYXNzZXRzLmRhdGFjYW1wLmNvbS9ibG9nX2Fzc2V0cy9mYWtlX29yX3JlYWxfbmV3cy5jc3ZcIilcbmRmID0gZGYuc2V0X2luZGV4KCdVbm5hbWVkOiAwJylcbnkgPSBkZi5sYWJlbFxuZGYgPSBkZi5kcm9wKCdsYWJlbCcsIGF4aXM9MSlcblhfdHJhaW4sIFhfdGVzdCwgeV90cmFpbiwgeV90ZXN0ID0gdHJhaW5fdGVzdF9zcGxpdChkZlsndGV4dCddLCB5LCB0ZXN0X3NpemU9MC4zMywgcmFuZG9tX3N0YXRlPTUzKVxudGZpZGZfdmVjdG9yaXplciA9IFRmaWRmVmVjdG9yaXplcihzdG9wX3dvcmRzPSdlbmdsaXNoJywgbWF4X2RmPTAuNylcbnRmaWRmX3RyYWluID0gdGZpZGZfdmVjdG9yaXplci5maXRfdHJhbnNmb3JtKFhfdHJhaW4pXG50ZmlkZl90ZXN0ID0gdGZpZGZfdmVjdG9yaXplci50cmFuc2Zvcm0oWF90ZXN0KVxuY291bnRfdmVjdG9yaXplciA9IENvdW50VmVjdG9yaXplcihzdG9wX3dvcmRzPSdlbmdsaXNoJylcbmNvdW50X3RyYWluID0gY291bnRfdmVjdG9yaXplci5maXRfdHJhbnNmb3JtKFhfdHJhaW4pIFxuY291bnRfdGVzdCA9IGNvdW50X3ZlY3Rvcml6ZXIudHJhbnNmb3JtKFhfdGVzdCkiLCJzYW1wbGUiOiIjIEdldCB0aGUgZmVhdHVyZSBuYW1lcyBvZiBgdGZpZGZfdmVjdG9yaXplcmAgXG5wcmludCh0ZmlkZl92ZWN0b3JpemVyLl9fX19fX19fX19fKClbLTEwOl0pXG5cbiMgR2V0IHRoZSBmZWF0dXJlIG5hbWVzIG9mIGBjb3VudF92ZWN0b3JpemVyYCBcbnByaW50KGNvdW50X3ZlY3Rvcml6ZXIuX19fX19fX19fX18oKVs6MTBdKSIsInNvbHV0aW9uIjoiIyBHZXQgdGhlIGZlYXR1cmUgbmFtZXMgb2YgYHRmaWRmX3ZlY3Rvcml6ZXJgIFxucHJpbnQodGZpZGZfdmVjdG9yaXplci5nZXRfZmVhdHVyZV9uYW1lcygpWy0xMDpdKVxuXG4jIEdldCB0aGUgZmVhdHVyZSBuYW1lcyBvZiBgY291bnRfdmVjdG9yaXplcmAgXG5wcmludChjb3VudF92ZWN0b3JpemVyLmdldF9mZWF0dXJlX25hbWVzKClbOjEwXSkiLCJzY3QiOiJ0ZXN0X2Z1bmN0aW9uKFwicHJpbnRcIiwgMSlcbnRlc3RfZnVuY3Rpb24oXCJwcmludFwiLCAyKVxuc3VjY2Vzc19tc2coXCJXZWxsIGRvbmUhXCIpIn0=
Intermezzo: Count versus TF-IDF-features
Ik was benieuwd of mijn count- en TF-IDF-vectorizers verschillende tokens hadden geëxtraheerd. Om dit te bekijken en features te vergelijken, kun je de vectorinformatie terug in een DataFrame zetten om eenvoudige Python-vergelijkingen te maken.
Zoals je ziet als je de cellen hieronder uitvoert, hebben beide vectorizers dezelfde tokens geëxtraheerd, maar uiteraard met verschillende gewichten. Waarschijnlijk kan het aanpassen van de max_df en min_df van de TF-IDF-vectorizer het resultaat veranderen en tot verschillende features in elk leiden.
In [15]:
count_df = pd.DataFrame(count_train.A, columns=count_vectorizer.get_feature_names())In [16]:
tfidf_df = pd.DataFrame(tfidf_train.A, columns=tfidf_vectorizer.get_feature_names())In [17]:
difference = set(count_df.columns) - set(tfidf_df.columns)differenceOut[17]:
In [18]:
print(count_df.equals(tfidf_df))In [19]:
count_df.head()Out[19]:
In [20]:
tfidf_df.head()Out[20]:
Modellen vergelijken
Tijd om je modellen te trainen en te testen.
Hier begin je met een NLP-favoriet, MultinomialNB. Hiermee kun je TF-IDF vergelijken met bag-of-words. Mijn intuïtie was dat bag-of-words (oftewel CountVectorizer) beter zou presteren met dit model. (Voor meer over multinomiale verdelingen en waarom die het best werken met gehele getallen, bekijk deze korte uitleg uit een UPenn-statistiekcursus).
Persoonlijk vind ik confusion matrices makkelijker te vergelijken en te lezen, dus gebruikte ik de scikit-learn-documentatie om een paar goed leesbare confusion matrices te bouwen (dank je, open source!). Een confusion matrix toont de correcte labels op de hoofddiagonaal (linksboven naar rechtsonder). De andere cellen tonen de onjuiste labels, vaak false positives of false negatives genoemd. Afhankelijk van je probleem kan één van die twee zwaarder wegen. Bijvoorbeeld: bij het nepnieuwsprobleem is het belangrijker dat we echte artikelen niet als nep labelen? Zo ja, dan willen we onze accuracyscore uiteindelijk misschien wegen om deze zorg beter te weerspiegelen.
Naast confusion matrices biedt scikit-learn veel manieren om je modellen te visualiseren en te vergelijken. Een populaire manier is een ROC-curve gebruiken. Er zijn veel andere manieren om je model te evalueren in de scikit-learn metrics-module.
In [21]:
def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues): """ See full source and example: http://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html This function prints and plots the confusion matrix. Normalization can be applied by setting `normalize=True`. """ plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45) plt.yticks(tick_marks, classes) if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] print("Normalized confusion matrix") else: print('Confusion matrix, without normalization') thresh = cm.max() / 2. for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): plt.text(j, i, cm[i, j], horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label')In [22]:
clf = MultinomialNB()In [23]:
clf.fit(tfidf_train, y_train)pred = clf.predict(tfidf_test)score = metrics.accuracy_score(y_test, pred)print("accuracy: %0.3f" % score)cm = metrics.confusion_matrix(y_test, pred, labels=['FAKE', 'REAL'])plot_confusion_matrix(cm, classes=['FAKE', 'REAL'])accuracy: 0.857Confusion matrix, without normalization
In [24]:
clf = MultinomialNB() In [25]:
clf.fit(count_train, y_train)pred = clf.predict(count_test)score = metrics.accuracy_score(y_test, pred)print("accuracy: %0.3f" % score)cm = metrics.confusion_matrix(y_test, pred, labels=['FAKE', 'REAL'])plot_confusion_matrix(cm, classes=['FAKE', 'REAL'])accuracy: 0.893Confusion matrix, without normalization
En inderdaad, zonder enige parameterafstemming presteert je getelde, gevectoriseerde trainingsset count_train zichtbaar beter dan je TF-IDF-vectors!
Lineaire modellen testen
Er zijn veel goede stukken geschreven over hoe lineaire modellen goed werken met TF-IDF-vectorizers (bekijk word2vec voor classificatie, SVM-referentie in scikit-learn-tekstanalyse, en meer).
Dus je zou een SVM moeten gebruiken, toch?
Nou, ik keek onlangs Victor Lavrenko’s college over tekstclassificatie en hij vergelijkt Passive Aggressive-classifiers met lineaire SVM’s voor tekstclassificatie. We testen deze aanpak (die aanzienlijke snelheidsvoordelen en blijvende leer-nadelen heeft) met de nepnieuwsdataset.
In [26]:
linear_clf = PassiveAggressiveClassifier(n_iter=50)In [27]:
linear_clf.fit(tfidf_train, y_train)pred = linear_clf.predict(tfidf_test)score = metrics.accuracy_score(y_test, pred)print("accuracy: %0.3f" % score)cm = metrics.confusion_matrix(y_test, pred, labels=['FAKE', 'REAL'])plot_confusion_matrix(cm, classes=['FAKE', 'REAL'])accuracy: 0.936Confusion matrix, without normalization
Wauw!
Ik ben onder de indruk. De confusion matrix ziet er anders uit en het model classificeert ons nepnieuws wat beter. We kunnen testen of het afstemmen van de alpha-waarde voor een MultinomialNB vergelijkbare resultaten oplevert. Je kunt ook parametertuning met grid search gebruiken voor een meer uitputtende zoektocht.
In [28]:
clf = MultinomialNB(alpha=0.1)In [29]:
last_score = 0for alpha in np.arange(0,1,.1): nb_classifier = MultinomialNB(alpha=alpha) nb_classifier.fit(tfidf_train, y_train) pred = nb_classifier.predict(tfidf_test) score = metrics.accuracy_score(y_test, pred) if score > last_score: clf = nb_classifier print("Alpha: {:.2f} Score: {:.5f}".format(alpha, score))Net niet... Op dit punt is het interessant om parametertuning uit te voeren over alle classifiers, of te kijken naar andere Bayesiaanse classifiers in scikit-learn. Je kunt ook een Support Vector Machine (SVM) testen om te zien of die beter presteert dan de Passive Aggressive-classifier.
Maar ik ben nog iets benieuwder naar wat het Passive Aggressive-model eigenlijk heeft geleerd. Dus door naar introspectie.
Modellen introspecteren
Dus nepnieuws is opgelost, toch? We haalden 93% nauwkeurigheid op mijn dataset, dus we kunnen inpakken en naar huis.
Natuurlijk niet. Ik ben op zijn best voorzichtig met deze resultaten, gezien de hoeveelheid ruis die we in de features zagen. Er is een prima uitleg op StackOverflow met een ontzettend handige functie om vectors te vinden die labels het meest beïnvloeden. Hij werkt alleen voor binaire classificatie (classifiers met 2 klassen), maar dat is goed nieuws voor jou, want je hebt alleen FAKE- of REAL-labels.
Gebruik je best presterende classifier met je TF-IDF-vectordataset (tfidf_vectorizer) en Passive Aggressive-classifier (linear_clf) en bekijk de top 30 vectors voor nep en echt nieuws:
In [30]:
Je kunt dit ook op een vrij voor de hand liggende manier doen met maar een paar regels Python, door je coëfficiënten te zippen met je features en naar de boven- en onderkant van je lijst te kijken.
In [31]:
feature_names = tfidf_vectorizer.get_feature_names()In [32]:
### Most realsorted(zip(clf.coef_[0], feature_names), reverse=True)[:20]Out[32]:
In [33]:
### Most fakesorted(zip(clf.coef_[0], feature_names))[:20]Out[33]:
Er zijn dus duidelijk bepaalde woorden die politieke intentie en bron kunnen aangeven in de top-nepfeatures (zoals de woorden corporate en establishment).
Ook gebruikt echte nieuwsdata vaker vormen van het werkwoord “to say”, waarschijnlijk omdat in kranten en de meeste journalistieke publicaties bronnen direct worden geciteerd (“De Duitse bondskanselier Angela Merkel zei...” ).
Om de volledige lijst uit je huidige classifier te halen en elk token te bekijken (of tokens eenvoudig van classifier tot classifier te vergelijken), kun je die zo exporteren.
In [34]:
tokens_with_weights = sorted(list(zip(feature_names, clf.coef_[0])))Intermezzo: HashingVectorizer
Een andere vectorizer die soms wordt gebruikt voor tekstclassificatie is een HashingVectorizer. HashingVectorizers hebben minder geheugen nodig en zijn sneller (omdat ze schaars zijn en hashes gebruiken in plaats van tokens) maar zijn lastiger te introspecteren. Je kunt wat meer lezen over de voor- en nadelen van het gebruik van HashingVectorizer in de scikit-learn-documentatie als je geïnteresseerd bent.
Je kunt ‘m proberen en de resultaten vergelijken met de andere vectorizers. Hij presteert behoorlijk, met betere resultaten dan de TF-IDF-vectorizer met MultinomialNB (dat is enigszins te verwachten om dezelfde redenen waarom CountVectorizers beter presteren), maar niet zo goed als de TF-IDF-vectorizer met het Passive Aggressive-lineaire algoritme.
In [35]:
hash_vectorizer = HashingVectorizer(stop_words='english', non_negative=True)hash_train = hash_vectorizer.fit_transform(X_train)hash_test = hash_vectorizer.transform(X_test)In [36]:
clf = MultinomialNB(alpha=.01)In [37]:
clf.fit(hash_train, y_train)pred = clf.predict(hash_test)score = metrics.accuracy_score(y_test, pred)print("accuracy: %0.3f" % score)cm = metrics.confusion_matrix(y_test, pred, labels=['FAKE', 'REAL'])plot_confusion_matrix(cm, classes=['FAKE', 'REAL'])accuracy: 0.902Confusion matrix, without normalization
In [38]:
clf = PassiveAggressiveClassifier(n_iter=50)In [39]:
clf.fit(hash_train, y_train)pred = clf.predict(hash_test)score = metrics.accuracy_score(y_test, pred)print("accuracy: %0.3f" % score)cm = metrics.confusion_matrix(y_test, pred, labels=['FAKE', 'REAL'])plot_confusion_matrix(cm, classes=['FAKE', 'REAL'])accuracy: 0.921Confusion matrix, without normalization
Conclusie
Was je experiment met een nepnieuwsklasseerder een succes? Zeker niet.
Maar heb je kunnen spelen met een nieuwe dataset, een paar NLP-classificatiemodellen getest en onderzocht hoe succesvol ze waren? Ja.
Zoals vanaf het begin verwacht, is nepnieuws definiëren met simpele bag-of-words- of TF-IDF-vectors een te simplistische aanpak. Zeker met een meertalige dataset vol ruisige tokens. Als je niet had gekeken naar wat je model daadwerkelijk had geleerd, had je misschien gedacht dat het model iets betekenisvols had geleerd. Dus onthoud: introspecteer je modellen altijd (zover je kunt!).
Ik ben benieuwd of jij andere trends in de data vindt die ik gemist heb. Ik kom hierop terug met een post over hoe verschillende classifiers zich verhouden qua belangrijke features op mijn blog. Als je tijd steekt in onderzoek en iets interessants vindt, deel je bevindingen en notities dan gerust in de comments of neem contact op via Twitter (ik ben @kjam).
Ik hoop dat je plezier had in het verkennen van een nieuwe NLP-dataset!
Bekijk ook DataCamp’s Python Machine Learning: Scikit-Learn Tutorial.
Onderwerpen
