Corso
Apprendimento supervisionato con scikit-learn
4 ore
306K
- Esplorazione dei dati
- Estrazione dei dati di training
- Creazione dei classificatori con i vectorizer
- Intermezzo: feature Count vs TF-IDF
- Conclusione
Rilevare le cosiddette “fake news” non è un compito semplice. Innanzitutto, bisogna definire cosa si intende per fake news – dato che è ormai diventata un’espressione anche politica. Se riesci a trovare o concordare una definizione, allora devi raccogliere e etichettare correttamente notizie vere e false (auspicabilmente su argomenti simili per evidenziare al meglio le differenze). Una volta raccolte, devi poi trovare feature utili per distinguere le notizie false da quelle vere.
Per un approfondimento su questo problema, ti consiglio di dare un’occhiata al post di Miguel Martinez-Alvarez “How can Machine Learning and AI Help Solve the Fake News Problem”.
Più o meno nello stesso periodo in cui ho letto l’acuto post di Miguel, mi sono imbattuto in un post di open data science su come costruire un classificatore di fake news efficace con modelli bayesiani. L’autore ha persino creato un repository con il dataset di esempi di notizie vere e false etichettati. Ero curioso di vedere se riuscivo a riprodurre facilmente i risultati e, in tal caso, se potevo capire cosa avesse imparato il modello.
In questo tutorial, ripercorrerai insieme a me parte della mia esplorazione iniziale e vedrai se riesci a costruire un classificatore di fake news efficace!
Suggerimento: se vuoi saperne di più sulle basi dell’elaborazione del linguaggio naturale (NLP), prendi in considerazione il corso Natural Language Processing Fundamentals in Python.
Esplorazione dei dati
Per iniziare, conviene sempre dare una rapida occhiata ai dati per farsi un’idea del loro contenuto. Per farlo, usa un DataFrame di Pandas e controlla shape, head e applica eventuali trasformazioni necessarie.
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZCIsInNhbXBsZSI6IiMgSW1wb3J0IGBmYWtlX29yX3JlYWxfbmV3cy5jc3ZgIFxuZGYgPSBfXy5fX19fX19fXyhcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKVxuICAgIFxuIyBJbnNwZWN0IHNoYXBlIG9mIGBkZmAgXG5kZi5fX19fX1xuXG4jIFByaW50IGZpcnN0IGxpbmVzIG9mIGBkZmBcbmRmLl9fX19fXyIsInNvbHV0aW9uIjoiIyBJbXBvcnQgYGZha2Vfb3JfcmVhbF9uZXdzLmNzdmAgXG5kZiA9IHBkLnJlYWRfY3N2KFwiaHR0cHM6Ly9zMy5hbWF6b25hd3MuY29tL2Fzc2V0cy5kYXRhY2FtcC5jb20vYmxvZ19hc3NldHMvZmFrZV9vcl9yZWFsX25ld3MuY3N2XCIpXG4gICAgXG4jIEluc3BlY3Qgc2hhcGUgb2YgYGRmYCBcbmRmLnNoYXBlXG5cbiMgUHJpbnQgZmlyc3QgbGluZXMgb2YgYGRmYCBcbmRmLmhlYWQoKSIsInNjdCI6InRlc3Rfb2JqZWN0KFwiZGZcIiwgdW5kZWZpbmVkX21zZz1cIkRpZCB5b3UgaW1wb3J0IHRoZSBkYXRhIGNvcnJlY3RseT9cIixpbmNvcnJlY3RfbXNnPVwiTWFrZSBzdXJlIHRvIHVzZSB0aGUgUGFuZGFzIGByZWFkX2NzdigpYCBmdW5jdGlvbiB0byByZWFkIGluIHRoZSBkYXRhIVwiKVxudGVzdF9vYmplY3RfYWNjZXNzZWQoXCJkZi5zaGFwZVwiLCBub3RfYWNjZXNzZWRfbXNnPVwiRGlkIHlvdSB1c2UgYHNoYXBlYCB0byByZXRyaWV2ZSB0aGUgc2hhcGUgb2YgdGhlIGBkZmA/XCIpXG50ZXN0X2Z1bmN0aW9uKFwiZGYuaGVhZFwiKVxuc3VjY2Vzc19tc2coXCJOaWNlIG9uZSFcIikifQ==
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZGYgPSBwZC5yZWFkX2NzdihcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKSIsInNhbXBsZSI6IiMgU2V0IGluZGV4XG5kZiA9IGRmLnNldF9pbmRleChcIlVubmFtZWQ6IDBcIikgXG5cbiMgUHJpbnQgZmlyc3QgbGluZXMgb2YgYGRmYCBcbmRmLl9fX19fXyIsInNvbHV0aW9uIjoiIyBTZXQgaW5kZXggXG5kZiA9IGRmLnNldF9pbmRleChcIlVubmFtZWQ6IDBcIilcblxuIyBQcmludCBmaXJzdCBsaW5lcyBvZiBgZGZgIFxuZGYuaGVhZCgpIiwic2N0IjoidGVzdF9vYmplY3QoXCJkZlwiKVxudGVzdF9mdW5jdGlvbihcImRmLmhlYWRcIilcbnN1Y2Nlc3NfbXNnKFwiQXdlc29tZSBqb2IhXCIpIn0=
Estrazione dei dati di training
Ora che il DataFrame è più vicino a ciò che ti serve, vuoi separare le etichette e impostare i dataset di training e test.
Per questo notebook, ho deciso di concentrarmi sull’uso del testo degli articoli più lungo. Poiché sapevo che avrei usato bag-of-words e Term Frequency–Inverse Document Frequency (TF-IDF) per estrarre le feature, è sembrata una buona scelta. Usare testi più lunghi dovrebbe consentire parole e feature più distintive per i dati di notizie vere e false.
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdFxuaW1wb3J0IHBhbmRhcyBhcyBwZFxuZGYgPSBwZC5yZWFkX2NzdihcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKVxuZGYgPSBkZi5zZXRfaW5kZXgoXCJVbm5hbWVkOiAwXCIpICIsInNhbXBsZSI6IiNTZXQgYHlgIFxueSA9IGRmLl9fX19fIFxuIFxuIyBEcm9wIHRoZSBgbGFiZWxgIGNvbHVtbiBcbmRmLl9fX18oXCJsYWJlbFwiLCBheGlzPTEpIFxuIFxuIyBNYWtlIHRyYWluaW5nIGFuZCB0ZXN0IHNldHMgXG5YX3RyYWluLCBYX3Rlc3QsIHlfdHJhaW4sIHlfdGVzdCA9IF9fX19fX19fX19fX19fX18oZGZbJ3RleHQnXSwgeSwgdGVzdF9zaXplPTAuMzMsIHJhbmRvbV9zdGF0ZT01MykiLCJzb2x1dGlvbiI6IiMgU2V0IGB5YCBcbnkgPSBkZi5sYWJlbCBcblxuIyBEcm9wIHRoZSBgbGFiZWxgIGNvbHVtblxuZGYuZHJvcChcImxhYmVsXCIsIGF4aXM9MSlcblxuIyBNYWtlIHRyYWluaW5nIGFuZCB0ZXN0IHNldHMgXG5YX3RyYWluLCBYX3Rlc3QsIHlfdHJhaW4sIHlfdGVzdCA9IHRyYWluX3Rlc3Rfc3BsaXQoZGZbJ3RleHQnXSwgeSwgdGVzdF9zaXplPTAuMzMsIHJhbmRvbV9zdGF0ZT01MykiLCJzY3QiOiJ0ZXN0X29iamVjdChcInlcIilcbnRlc3Rfb2JqZWN0KFwiZGZcIilcbnRlc3Rfb2JqZWN0KFwiWF90ZXN0XCIsIGRvX2V2YWw9RmFsc2UsIHVuZGVmaW5lZF9tc2c9XCJEaWQgeW91IGRlZmluZSBgWF90ZXN0YD9cIilcbnRlc3Rfb2JqZWN0KFwiWF90cmFpblwiLCBkb19ldmFsPUZhbHNlLCB1bmRlZmluZWRfbXNnPVwiRGlkIHlvdSBkZWZpbmUgYFhfdHJhaW5gP1wiKVxudGVzdF9vYmplY3QoXCJ5X3RyYWluXCIsIGRvX2V2YWw9RmFsc2UsIHVuZGVmaW5lZF9tc2c9XCJEaWQgeW91IGRlZmluZSBgeV90cmFpbmA/XCIpXG50ZXN0X29iamVjdChcInlfdGVzdFwiLCBkb19ldmFsPUZhbHNlLCB1bmRlZmluZWRfbXNnPVwiRGlkIHlvdSBkZWZpbmUgYHlfdGVzdGA/XCIpXG5zdWNjZXNzX21zZyhcIkF3ZXNvbWUgam9iIVwiKSJ9
Creazione dei classificatori con i vectorizer
Ora che hai i tuoi dati di training e test, puoi costruire i classificatori. Per capire bene se le parole e i token negli articoli hanno avuto un impatto significativo nel determinare se una notizia fosse falsa o vera, cominci con CountVectorizer e TfidfVectorizer.
Vedrai che l’esempio ha una soglia massima impostata a .7 per il vectorizer TF-IDF tfidf_vectorizer usando l’argomento max_df. Questo rimuove le parole che compaiono in più del 70% degli articoli. Inoltre, il parametro integrato stop_words rimuove gli stop word inglesi dai dati prima della vettorizzazione.
Ci sono molti altri parametri disponibili e puoi leggerne tutti i dettagli nella documentazione di scikit-learn per TfidfVectorizer e CountVectorizer.
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdCBcbmZyb20gc2tsZWFybi5mZWF0dXJlX2V4dHJhY3Rpb24udGV4dCBpbXBvcnQgQ291bnRWZWN0b3JpemVyIFxuZGYgPSBwZC5yZWFkX2NzdihcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKVxuZGYgPSBkZi5zZXRfaW5kZXgoJ1VubmFtZWQ6IDAnKVxueSA9IGRmLmxhYmVsXG5kZiA9IGRmLmRyb3AoJ2xhYmVsJywgYXhpcz0xKVxuWF90cmFpbiwgWF90ZXN0LCB5X3RyYWluLCB5X3Rlc3QgPSB0cmFpbl90ZXN0X3NwbGl0KGRmWyd0ZXh0J10sIHksIHRlc3Rfc2l6ZT0wLjMzLCByYW5kb21fc3RhdGU9NTMpIiwic2FtcGxlIjoiIyBJbml0aWFsaXplIHRoZSBgY291bnRfdmVjdG9yaXplcmAgXG5jb3VudF92ZWN0b3JpemVyID0gX19fX19fX19fX19fX19fKHN0b3Bfd29yZHM9J2VuZ2xpc2gnKSBcblxuIyBGaXQgYW5kIHRyYW5zZm9ybSB0aGUgdHJhaW5pbmcgZGF0YSBcbmNvdW50X3RyYWluID0gY291bnRfdmVjdG9yaXplci5fX19fX19fX19fX19fKFhfdHJhaW4pIFxuXG4jIFRyYW5zZm9ybSB0aGUgdGVzdCBzZXRcbmNvdW50X3Rlc3QgPSBjb3VudF92ZWN0b3JpemVyLl9fX19fX19fXyhYX3Rlc3QpIiwic29sdXRpb24iOiIjIEluaXRpYWxpemUgdGhlIGBjb3VudF92ZWN0b3JpemVyYCBcbmNvdW50X3ZlY3Rvcml6ZXIgPSBDb3VudFZlY3Rvcml6ZXIoc3RvcF93b3Jkcz0nZW5nbGlzaCcpXG5cbiMgRml0IGFuZCB0cmFuc2Zvcm0gdGhlIHRyYWluaW5nIGRhdGEgXG5jb3VudF90cmFpbiA9IGNvdW50X3ZlY3Rvcml6ZXIuZml0X3RyYW5zZm9ybShYX3RyYWluKSBcblxuIyBUcmFuc2Zvcm0gdGhlIHRlc3Qgc2V0IFxuY291bnRfdGVzdCA9IGNvdW50X3ZlY3Rvcml6ZXIudHJhbnNmb3JtKFhfdGVzdCkiLCJzY3QiOiJ0ZXN0X29iamVjdChcImNvdW50X3ZlY3Rvcml6ZXJcIiwgZG9fZXZhbD1GYWxzZSlcbnRlc3Rfb2JqZWN0KFwiY291bnRfdHJhaW5cIiwgZG9fZXZhbD1GYWxzZSlcbnRlc3Rfb2JqZWN0KFwiY291bnRfdGVzdFwiLCBkb19ldmFsPUZhbHNlLCB1bmRlZmluZWRfbXNnPVwiRGlkIHlvdSBkZWZpbmUgYGNvdW50X3Rlc3RgP1wiKVxuc3VjY2Vzc19tc2coXCJHcmVhdCBqb2IhXCIpIn0=
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdCBcbmZyb20gc2tsZWFybi5mZWF0dXJlX2V4dHJhY3Rpb24udGV4dCBpbXBvcnQgVGZpZGZWZWN0b3JpemVyIFxuZGYgPSBwZC5yZWFkX2NzdihcImh0dHBzOi8vczMuYW1hem9uYXdzLmNvbS9hc3NldHMuZGF0YWNhbXAuY29tL2Jsb2dfYXNzZXRzL2Zha2Vfb3JfcmVhbF9uZXdzLmNzdlwiKVxuZGYgPSBkZi5zZXRfaW5kZXgoJ1VubmFtZWQ6IDAnKVxueSA9IGRmLmxhYmVsXG5kZiA9IGRmLmRyb3AoJ2xhYmVsJywgYXhpcz0xKVxuWF90cmFpbiwgWF90ZXN0LCB5X3RyYWluLCB5X3Rlc3QgPSB0cmFpbl90ZXN0X3NwbGl0KGRmWyd0ZXh0J10sIHksIHRlc3Rfc2l6ZT0wLjMzLCByYW5kb21fc3RhdGU9NTMpIiwic2FtcGxlIjoiIyBJbml0aWFsaXplIHRoZSBgdGZpZGZfdmVjdG9yaXplcmBcbnRmaWRmX3ZlY3Rvcml6ZXIgPSBfX19fX19fX19fX19fX18oc3RvcF93b3Jkcz0nZW5nbGlzaCcsIG1heF9kZj0wLjcpIFxuXG4jIEZpdCBhbmQgdHJhbnNmb3JtIHRoZSB0cmFpbmluZyBkYXRhIFxudGZpZGZfdHJhaW4gPSB0ZmlkZl92ZWN0b3JpemVyLl9fX19fX19fX19fX18oWF90cmFpbikgXG5cbiMgVHJhbnNmb3JtIHRoZSB0ZXN0IHNldCBcbnRmaWRmX3Rlc3QgPSB0ZmlkZl92ZWN0b3JpemVyLl9fX19fX19fXyhYX3Rlc3QpIiwic29sdXRpb24iOiIjIEluaXRpYWxpemUgdGhlIGB0ZmlkZl92ZWN0b3JpemVyYCBcbnRmaWRmX3ZlY3Rvcml6ZXIgPSBUZmlkZlZlY3Rvcml6ZXIoc3RvcF93b3Jkcz0nZW5nbGlzaCcsIG1heF9kZj0wLjcpIFxuXG4jIEZpdCBhbmQgdHJhbnNmb3JtIHRoZSB0cmFpbmluZyBkYXRhIFxudGZpZGZfdHJhaW4gPSB0ZmlkZl92ZWN0b3JpemVyLmZpdF90cmFuc2Zvcm0oWF90cmFpbikgXG5cbiMgVHJhbnNmb3JtIHRoZSB0ZXN0IHNldCBcbnRmaWRmX3Rlc3QgPSB0ZmlkZl92ZWN0b3JpemVyLnRyYW5zZm9ybShYX3Rlc3QpIiwic2N0IjoidGVzdF9vYmplY3QoXCJ0ZmlkZl92ZWN0b3JpemVyXCIsIGRvX2V2YWw9RmFsc2UpXG50ZXN0X29iamVjdChcInRmaWRmX3RyYWluXCIsIGRvX2V2YWw9RmFsc2UpXG50ZXN0X29iamVjdChcInRmaWRmX3Rlc3RcIiwgZG9fZXZhbD1GYWxzZSwgdW5kZWZpbmVkX21zZz1cIkRpZCB5b3UgZGVmaW5lIGBjb3VudF90ZXN0YD9cIilcbnN1Y2Nlc3NfbXNnKFwiV2VsbCBkb25lIVwiKSJ9
Ora che hai i vettori, puoi dare un’occhiata alle feature dei vettori, memorizzate in count_vectorizer e tfidf_vectorizer.
Ci sono problemi evidenti? (Sì!)
Nel dataset che stai usando ci sono chiaramente commenti, misurazioni o altre parole senza senso, oltre ad articoli multilingue. Normalmente, vorresti dedicare più tempo al preprocessing e alla rimozione del rumore, ma poiché questo tutorial mostra solo una piccola prova di concetto, vedrai se il modello riesce a superare il rumore e classificare correttamente nonostante questi problemi.
eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdFxuZnJvbSBza2xlYXJuLmZlYXR1cmVfZXh0cmFjdGlvbi50ZXh0IGltcG9ydCBUZmlkZlZlY3Rvcml6ZXIsIENvdW50VmVjdG9yaXplciBcbmRmID0gcGQucmVhZF9jc3YoXCJodHRwczovL3MzLmFtYXpvbmF3cy5jb20vYXNzZXRzLmRhdGFjYW1wLmNvbS9ibG9nX2Fzc2V0cy9mYWtlX29yX3JlYWxfbmV3cy5jc3ZcIilcbmRmID0gZGYuc2V0X2luZGV4KCdVbm5hbWVkOiAwJylcbnkgPSBkZi5sYWJlbFxuZGYgPSBkZi5kcm9wKCdsYWJlbCcsIGF4aXM9MSlcblhfdHJhaW4sIFhfdGVzdCwgeV90cmFpbiwgeV90ZXN0ID0gdHJhaW5fdGVzdF9zcGxpdChkZlsndGV4dCddLCB5LCB0ZXN0X3NpemU9MC4zMywgcmFuZG9tX3N0YXRlPTUzKVxudGZpZGZfdmVjdG9yaXplciA9IFRmaWRmVmVjdG9yaXplcihzdG9wX3dvcmRzPSdlbmdsaXNoJywgbWF4X2RmPTAuNylcbnRmaWRmX3RyYWluID0gdGZpZGZfdmVjdG9yaXplci5maXRfdHJhbnNmb3JtKFhfdHJhaW4pXG50ZmlkZl90ZXN0ID0gdGZpZGZfdmVjdG9yaXplci50cmFuc2Zvcm0oWF90ZXN0KVxuY291bnRfdmVjdG9yaXplciA9IENvdW50VmVjdG9yaXplcihzdG9wX3dvcmRzPSdlbmdsaXNoJylcbmNvdW50X3RyYWluID0gY291bnRfdmVjdG9yaXplci5maXRfdHJhbnNmb3JtKFhfdHJhaW4pIFxuY291bnRfdGVzdCA9IGNvdW50X3ZlY3Rvcml6ZXIudHJhbnNmb3JtKFhfdGVzdCkiLCJzYW1wbGUiOiIjIEdldCB0aGUgZmVhdHVyZSBuYW1lcyBvZiBgdGZpZGZfdmVjdG9yaXplcmAgXG5wcmludCh0ZmlkZl92ZWN0b3JpemVyLl9fX19fX19fX19fKClbLTEwOl0pXG5cbiMgR2V0IHRoZSBmZWF0dXJlIG5hbWVzIG9mIGBjb3VudF92ZWN0b3JpemVyYCBcbnByaW50KGNvdW50X3ZlY3Rvcml6ZXIuX19fX19fX19fX18oKVs6MTBdKSIsInNvbHV0aW9uIjoiIyBHZXQgdGhlIGZlYXR1cmUgbmFtZXMgb2YgYHRmaWRmX3ZlY3Rvcml6ZXJgIFxucHJpbnQodGZpZGZfdmVjdG9yaXplci5nZXRfZmVhdHVyZV9uYW1lcygpWy0xMDpdKVxuXG4jIEdldCB0aGUgZmVhdHVyZSBuYW1lcyBvZiBgY291bnRfdmVjdG9yaXplcmAgXG5wcmludChjb3VudF92ZWN0b3JpemVyLmdldF9mZWF0dXJlX25hbWVzKClbOjEwXSkiLCJzY3QiOiJ0ZXN0X2Z1bmN0aW9uKFwicHJpbnRcIiwgMSlcbnRlc3RfZnVuY3Rpb24oXCJwcmludFwiLCAyKVxuc3VjY2Vzc19tc2coXCJXZWxsIGRvbmUhXCIpIn0=
Intermezzo: feature Count vs TF-IDF
Ero curioso di sapere se i miei vectorizer count e TF-IDF avessero estratto token diversi. Per dare un’occhiata e confrontare le feature, puoi riportare le informazioni dei vettori in un DataFrame per fare confronti in Python in modo semplice.
Come puoi vedere eseguendo le celle qui sotto, entrambi i vectorizer hanno estratto gli stessi token, ma con pesi ovviamente diversi. Probabilmente, modificare max_df e min_df del vectorizer TF-IDF potrebbe cambiare il risultato e portare a feature differenti in ciascuno.
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]:
Confronto dei modelli
È il momento di addestrare e testare i modelli.
Qui, inizierai con un classico dell’NLP, MultinomialNB. Puoi usarlo per confrontare TF-IDF e bag-of-words. La mia intuizione era che bag-of-words (ovvero CountVectorizer) avrebbe funzionato meglio con questo modello. (Per approfondire la distribuzione multinomiale e perché funziona meglio con numeri interi, dai un’occhiata a questa spiegazione piuttosto sintetica da un corso di statistica di UPenn).
Personalmente trovo più facili da confrontare e leggere le confusion matrix, quindi ho usato la documentazione di scikit-learn per costruirne alcune facilmente leggibili (grazie open source!). Una confusion matrix mostra le etichette corrette sulla diagonale principale (dall’alto a sinistra al basso a destra). Le altre celle mostrano le etichette errate, spesso chiamate falsi positivi o falsi negativi. A seconda del problema, una delle due potrebbe essere più significativa. Per esempio, per il problema delle fake news, è più importante evitare di etichettare come false le notizie vere? Se sì, potremmo voler alla fine pesare la nostra metrica di accuratezza per riflettere meglio questa preoccupazione.
Oltre alle confusion matrix, scikit-learn offre molti modi per visualizzare e confrontare i modelli. Un modo popolare è usare una curva ROC. Ci sono molti altri modi per valutare il modello disponibili nel modulo metrics di scikit-learn.
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
E infatti, senza alcun tuning dei parametri, il tuo set di training vettorizzato con count count_train supera visibilmente i tuoi vettori TF-IDF!
Test dei modelli lineari
Ci sono molte ottime risorse su come i modelli lineari funzionino bene con i vectorizer TF-IDF (dai un’occhiata a word2vec per la classificazione, riferimenti SVM nell’analisi testuale di scikit-learn e molte altre).
Quindi dovresti usare una SVM, giusto?
Be’, ho guardato di recente la lezione di Victor Lavrenko sulla classificazione del testo in cui confronta i classificatori Passive Aggressive con le SVM lineari per la classificazione testuale. Metteremo alla prova questo approccio (che ha notevoli vantaggi in velocità e svantaggi nell’apprendimento permanente) con il dataset delle fake news.
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
Wow!
Sono colpito. La confusion matrix ha un aspetto diverso e il modello classifica un po’ meglio le nostre fake news. Possiamo testare se il tuning del valore di alpha per un MultinomialNB produce risultati comparabili. Puoi anche usare la ricerca a griglia per l’ottimizzazione dei parametri per una ricerca più esaustiva.
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))Non proprio... A questo punto, potrebbe essere interessante eseguire il tuning dei parametri su tutti i classificatori o dare un’occhiata ad altri classificatori bayesiani di scikit-learn. Potresti anche provare con una Support Vector Machine (SVM) per vedere se supera il classificatore Passive Aggressive.
Ma sono un po’ più curioso di capire cosa il modello Passive Aggressive abbia effettivamente imparato. Quindi passiamo all’introspezione.
Introspezione dei modelli
Quindi le fake news sono risolte, giusto? Abbiamo raggiunto il 93% di accuratezza sul mio dataset, quindi chiudiamo tutto e andiamo a casa.
Ovviamente no. Sono, nel migliore dei casi, diffidente verso questi risultati, visto quanto rumore abbiamo visto nelle feature. C’è un’ottima risposta su StackOverflow con una funzione utilissima per trovare i vettori che influenzano maggiormente le etichette. Funziona solo per la classificazione binaria (classificatori con 2 classi), ma per te è una buona notizia, dato che hai solo etichette FAKE o REAL.
Usando il tuo classificatore con prestazioni migliori con il dataset di vettori TF-IDF (tfidf_vectorizer) e il classificatore Passive Aggressive (linear_clf), ispeziona le 30 feature principali per le notizie false e vere:
In [30]:
Puoi farlo anche in modo piuttosto semplice con poche righe di Python, unendo (zip) i coefficienti alle feature e guardando l’inizio e la fine della lista.
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]:
Dunque, è chiaro che ci sono alcune parole che potrebbero indicare orientamento politico e fonte tra le feature top delle fake (come corporate ed establishment).
Inoltre, i dati delle notizie vere usano più spesso forme del verbo “to say”, probabilmente perché nei giornali e nella maggior parte delle pubblicazioni giornalistiche le fonti vengono citate direttamente (“La cancelliera tedesca Angela Merkel ha detto...”).
Per estrarre l’elenco completo dal classificatore attuale e dare un’occhiata a ogni token (o confrontare facilmente i token da un classificatore all’altro), puoi esportarlo facilmente così.
In [34]:
tokens_with_weights = sorted(list(zip(feature_names, clf.coef_[0])))Intermezzo: HashingVectorizer
Un altro vectorizer talvolta usato per la classificazione testuale è HashingVectorizer. Gli HashingVectorizer richiedono meno memoria e sono più veloci (perché sono sparsi e usano hash anziché token), ma sono più difficili da ispezionare. Puoi leggere qualcosa in più sui pro e i contro dell’uso di HashingVectorizer nella documentazione di scikit-learn, se ti interessa.
Puoi fare una prova e confrontarne i risultati con gli altri vectorizer. Si comporta piuttosto bene, con risultati migliori del vectorizer TF-IDF usando MultinomialNB (cosa in parte attesa per le stesse ragioni per cui i CountVectorizer funzionano meglio), ma non bene quanto il vectorizer TF-IDF con l’algoritmo lineare Passive Aggressive.
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
Conclusione
Quindi l’esperimento con il classificatore di fake news è stato un successo? Decisamente no.
Ma ti sei divertito a sperimentare con un nuovo dataset, provare alcuni modelli di classificazione NLP e ispezionare quanto fossero efficaci? Sì.
Come previsto fin dall’inizio, definire le fake news con semplici vettori bag-of-words o TF-IDF è un approccio troppo semplificato. Soprattutto con un dataset multilingue pieno di token rumorosi. Se non avessi guardato cosa aveva effettivamente imparato il tuo modello, avresti potuto pensare che avesse appreso qualcosa di significativo. Quindi, ricorda: ispeziona sempre i tuoi modelli (per quanto possibile!).
Sarei curioso di sapere se trovi altre tendenze nei dati che potrei essermi perso. Farò un follow-up con un post su come i diversi classificatori si confrontano in termini di feature importanti sul mio blog. Se dedichi un po’ di tempo alla ricerca e trovi qualcosa di interessante, condividi pure risultati e note nei commenti o contattami su Twitter (sono @kjam).
Spero ti sia divertito a esplorare con me un nuovo dataset NLP!
Dai un’occhiata al tutorial Python Machine Learning: Scikit-Learn di DataCamp.
Argomenti
