Pular para o conteúdo principal

Detectando fake news com scikit-learn

Este tutorial de scikit-learn vai guiar você na construção de um classificador de fake news com a ajuda de modelos bayesianos.
· 15 min leer

Explore com IA

datacamp graphic

Detectar as chamadas “fake news” não é tarefa simples. Primeiro, é preciso definir o que é fake news — algo que ganhou conotação política. Se você conseguir definir ou concordar com um conceito, então precisa coletar e rotular corretamente notícias reais e falsas (de preferência sobre temas semelhantes para evidenciar melhor as diferenças). Depois de coletar, é preciso encontrar boas features para distinguir notícias falsas de reais.

Para um mergulho mais profundo nesse tema, recomendo o post do Miguel Martinez-Alvarez: “How can Machine Learning and AI Help Solve the Fake News Problem”.

Na mesma época em que li o post do Miguel, encontrei um artigo no Open Data Science sobre como construir um detector de fake news com modelos bayesianos. O autor ainda criou um repositório com o dataset rotulado de exemplos reais e falsos. Fiquei curioso para saber se eu conseguiria reproduzir os resultados com facilidade e, em seguida, entender o que o modelo havia aprendido.

Neste tutorial, você vai acompanhar parte da minha exploração inicial e ver se consegue construir um detector de fake news que funcione!

Dica: se você quer aprender mais sobre fundamentos de Processamento de Linguagem Natural (NLP), vale conferir o curso Natural Language Processing Fundamentals in Python.

Exploração de dados

Para começar, sempre dê uma olhada rápida nos dados para sentir o conteúdo. Para isso, use um DataFrame do Pandas e verifique o shape, o head e aplique as transformações necessárias.

# Import `fake_or_real_news.csv` 
df = __.________("https://s3.amazonaws.com/assets.datacamp.com/blog_assets/fake_or_real_news.csv")
    
# Inspect shape of `df` 
df._____

# Print first lines of `df`
df.______
# Set index
df = df.set_index("Unnamed: 0") 

# Print first lines of `df` 
df.______

Extraindo os dados de treino

Agora que o DataFrame está mais próximo do que você precisa, separe os rótulos e monte os conjuntos de treino e teste.

Neste notebook, decidi focar no texto mais longo do artigo. Como eu sabia que usaria bag-of-words e TF-IDF (Term Frequency–Inverse Document Frequency) para extrair features, essa parecia uma boa escolha. Textos mais longos tendem a trazer palavras e características distintas para diferenciar as notícias reais das falsas.

#Set `y` 
y = df._____ 
 
# Drop the `label` column 
df.____("label", axis=1) 
 
# Make training and test sets 
X_train, X_test, y_train, y_test = ________________(df['text'], y, test_size=0.33, random_state=53)

Construindo classificadores com vetorizadores

Agora que você tem os dados de treino e teste, pode construir os classificadores. Para avaliar se as palavras e tokens dos artigos impactam a classificação entre notícia real e falsa, começamos usando CountVectorizer e TfidfVectorizer.

No exemplo, há um limite máximo .7 definido no TF-IDF tfidf_vectorizer com o argumento max_df. Isso remove palavras que aparecem em mais de 70% dos artigos. Além disso, o parâmetro stop_words embutido remove stop words em inglês dos dados antes de vetorizá-los.

Existem muitos outros parâmetros — você pode conferir todos na documentação do scikit-learn para TfidfVectorizer e CountVectorizer.

# Initialize the `count_vectorizer` 
count_vectorizer = _______________(stop_words='english') 

# Fit and transform the training data 
count_train = count_vectorizer._____________(X_train) 

# Transform the test set
count_test = count_vectorizer._________(X_test)
# Initialize the `tfidf_vectorizer`
tfidf_vectorizer = _______________(stop_words='english', max_df=0.7) 

# Fit and transform the training data 
tfidf_train = tfidf_vectorizer._____________(X_train) 

# Transform the test set 
tfidf_test = tfidf_vectorizer._________(X_test)

Com os vetores prontos, você pode inspecionar as features geradas, armazenadas em count_vectorizer e tfidf_vectorizer.

Há algum problema visível? (Sim!)

Claramente existem comentários, medidas ou outras palavras sem sentido, além de artigos em vários idiomas no dataset. Normalmente, você deveria investir mais tempo no pré-processamento e na remoção de ruído, mas como este tutorial é apenas uma prova de conceito rápida, vamos ver se o modelo consegue superar o ruído e classificar corretamente apesar desses problemas.

# Get the feature names of `tfidf_vectorizer` 
print(tfidf_vectorizer.___________()[-10:])

# Get the feature names of `count_vectorizer` 
print(count_vectorizer.___________()[:10])

Intermezzo: contagem vs. TF-IDF

Fiquei curioso para saber se os vetorizadores de contagem e de TF-IDF extraíram tokens diferentes. Para comparar as features, você pode trazer as informações de volta para um DataFrame e fazer comparações em Python com facilidade.

Rodando as células abaixo, dá para ver que ambos extraíram os mesmos tokens, mas com pesos diferentes. Alterar max_df e min_df do TF-IDF provavelmente mudaria o resultado e levaria a features diferentes em cada um.

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)difference
Out[17]:
set()
In [18]:
print(count_df.equals(tfidf_df))
False
In [19]:
count_df.head()
Out[19]:
 000000000000000310000350000600010001pt000ft000km...حلبعربيعنلممامحاولاتمنهذاوالمرضىยงade
00000000000...0000000000
10000000000...0000000000
20000000000...0000000000
30000000000...0000000000
40000000000...0000000000

5 rows × 56922 columns

In [20]:
tfidf_df.head()
Out[20]:
 000000000000000310000350000600010001pt000ft000km...حلبعربيعنلممامحاولاتمنهذاوالمرضىยงade
00.00.00.00.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.00.00.0
10.00.00.00.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.00.00.0
20.00.00.00.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.00.00.0
30.00.00.00.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.00.00.0
40.00.00.00.00.00.00.00.00.00.0...0.00.00.00.00.00.00.00.00.00.0

5 rows × 56922 columns

Comparando modelos

Hora de treinar e testar os modelos.

Vamos começar com um favorito do NLP, o MultinomialNB. Você pode usá-lo para comparar TF-IDF com bag-of-words. Minha intuição era que bag-of-words (ou CountVectorizer) funcionaria melhor com esse modelo. (Para entender a distribuição multinomial e por que ela funciona melhor com inteiros, confira esta explicação sucinta de um curso de estatística da UPenn.)

Pessoalmente, acho Matrizes de Confusão mais fáceis de ler e comparar, então usei a documentação do scikit-learn para construir versões legíveis (valeu, open source!). A matriz de confusão mostra os rótulos corretos na diagonal principal (do canto superior esquerdo ao inferior direito). As outras células mostram rótulos incorretos, os famosos falsos positivos e falsos negativos. Dependendo do problema, um deles pode ser mais crítico. Por exemplo, em fake news, é mais importante não rotular notícias reais como falsas? Se sim, talvez valha ponderar a métrica de acurácia para refletir essa preocupação.

Além de Matrizes de Confusão, o scikit-learn oferece várias formas de visualizar e comparar modelos. Uma bem popular é usar a curva ROC. Há muitos outros recursos de avaliação disponíveis no módulo metrics.

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
 
confusion matrix 1
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
 
confusion matrix 2
 

E de fato, sem nenhum ajuste de parâmetro, o conjunto vetorizado por contagem count_train teve desempenho visivelmente melhor que os vetores TF-IDF!

Testando modelos lineares

Há muitos materiais mostrando que modelos lineares funcionam muito bem com vetorizadores TF-IDF (veja word2vec para classificação, a referência de SVM na análise de texto do scikit-learn e outros).

Então é só usar SVM, certo?

Recentemente, assisti à aula do Victor Lavrenko sobre classificação de texto, em que ele compara classificadores Passive Aggressive com SVMs lineares para texto. Vamos testar essa abordagem (que tem ganhos de velocidade relevantes, mas desvantagens de aprendizado “permanente”) com o dataset de 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
confusion matrix 3

Uau!

Impressiona. A matriz de confusão ficou diferente e o modelo classificou um pouco melhor as fake news. Podemos testar se ajustar o alpha do MultinomialNB gera resultados comparáveis. Você também pode usar ajuste de parâmetros com grid search para uma busca mais ampla.

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))
Alpha: 0.00 Score: 0.61502Alpha: 0.10 Score: 0.89766Alpha: 0.20 Score: 0.89383Alpha: 0.30 Score: 0.89000Alpha: 0.40 Score: 0.88570Alpha: 0.50 Score: 0.88427Alpha: 0.60 Score: 0.87470Alpha: 0.70 Score: 0.87040Alpha: 0.80 Score: 0.86609Alpha: 0.90 Score: 0.85892

Nem tanto… Neste ponto, pode ser interessante ajustar parâmetros em todos os classificadores, ou explorar outros classificadores bayesianos do scikit-learn. Você também pode testar uma Support Vector Machine (SVM) para ver se supera o Passive Aggressive.

Mas estou mais curioso para saber o que o modelo Passive Aggressive realmente aprendeu. Vamos à introspecção.

Fazendo introspecção dos modelos

Então, fake news resolvida, certo? Conseguimos 93% de acurácia — missão cumprida.

Claro que não. Eu, no mínimo, fico cauteloso com esses resultados, dado o quanto de ruído vimos nas features. Há uma ótima resposta no StackOverflow com uma função muito útil para encontrar os vetores que mais afetam os rótulos. Ela só funciona para classificação binária (2 classes), o que é perfeito aqui, já que temos apenas FAKE e REAL.

Usando o classificador de melhor desempenho com o dataset TF-IDF (tfidf_vectorizer) e o Passive Aggressive (linear_clf), inspecione os 30 principais vetores para fake e real:

In [30]:
FAKE -4.86382369883 2016FAKE -4.13847157932 hillaryFAKE -3.98994974843 octoberFAKE -3.10552662226 shareFAKE -2.99713810694 novemberFAKE -2.9150746075 articleFAKE -2.54532100449 printFAKE -2.47115243995 advertisementFAKE -2.35915304509 sourceFAKE -2.31585837413 emailFAKE -2.27985826579 electionFAKE -2.2736680857 octFAKE -2.25253568246 warFAKE -2.19663276969 mosulFAKE -2.17921304122 podestaFAKE -1.99361009573 novFAKE -1.98662624907 comFAKE -1.9452527887 establishmentFAKE -1.86869495684 corporateFAKE -1.84166664376 wikileaksFAKE -1.7936566878 26FAKE -1.75686475396 donaldFAKE -1.74951154055 snipFAKE -1.73298170472 mainstreamFAKE -1.71365596627 ukFAKE -1.70917804969 ayotteFAKE -1.70781651904 entireFAKE -1.68272667818 jewishFAKE -1.65334397724 youtubeFAKE -1.6241703128 pipelineREAL 4.78064061698 saidREAL 2.68703967567 tuesdayREAL 2.48309800829 gopREAL 2.45710670245 islamicREAL 2.44326123901 saysREAL 2.29424417889 cruzREAL 2.29144842597 marriageREAL 2.20500735471 candidatesREAL 2.19136552672 conservativeREAL 2.18030834903 mondayREAL 2.05688105375 attacksREAL 2.03476457362 rushREAL 1.9954523319 continueREAL 1.97002430576 fridayREAL 1.95034103105 conventionREAL 1.94620720989 senREAL 1.91185661202 jobsREAL 1.87501303774 debateREAL 1.84059602241 presumptiveREAL 1.80111133252 sayREAL 1.80027216061 sundayREAL 1.79650823765 marchREAL 1.79229792108 parisREAL 1.74587899553 securityREAL 1.69585506276 conservativesREAL 1.68860503431 recountsREAL 1.67424302821 dealREAL 1.67343398121 campaignREAL 1.66148582079 foxREAL 1.61425630518 attack

Você também pode fazer isso de forma bem direta com poucas linhas de Python, juntando os coeficientes às features e olhando o topo e a base da 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]:
[(-6.2573612147015822, 'trump'), (-6.4944530943126777, 'said'), (-6.6539784739838845, 'clinton'), (-7.0379446628670728, 'obama'), (-7.1465399833812278, 'sanders'), (-7.2153760086475112, 'president'), (-7.2665628057416169, 'campaign'), (-7.2875931446681514, 'republican'), (-7.3411184585990643, 'state'), (-7.3413571102479054, 'cruz'), (-7.3783124419854254, 'party'), (-7.4468806724578904, 'new'), (-7.4762888011545883, 'people'), (-7.547225599514773, 'percent'), (-7.5553074094582335, 'bush'), (-7.5801506339098932, 'republicans'), (-7.5855405012652435, 'house'), (-7.6344781725203141, 'voters'), (-7.6484824436952987, 'rubio'), (-7.6734836186463795, 'states')]
In [33]:
### Most fakesorted(zip(clf.coef_[0], feature_names))[:20]
Out[33]:
[(-11.349866225220305, '0000'), (-11.349866225220305, '000035'), (-11.349866225220305, '0001'), (-11.349866225220305, '0001pt'), (-11.349866225220305, '000km'), (-11.349866225220305, '0011'), (-11.349866225220305, '006s'), (-11.349866225220305, '007'), (-11.349866225220305, '007s'), (-11.349866225220305, '008s'), (-11.349866225220305, '0099'), (-11.349866225220305, '00am'), (-11.349866225220305, '00p'), (-11.349866225220305, '00pm'), (-11.349866225220305, '014'), (-11.349866225220305, '015'), (-11.349866225220305, '018'), (-11.349866225220305, '01am'), (-11.349866225220305, '020'), (-11.349866225220305, '023')]

Fica claro que há certas palavras que indicam intenção política e fonte entre as principais features de fake (como corporate e establishment).

Também dá para ver que as notícias reais usam mais formas do verbo “say”, provavelmente porque em jornais e publicações jornalísticas as fontes são citadas diretamente (“A chanceler alemã Angela Merkel said…”).

Para extrair a lista completa do classificador atual e analisar cada token (ou comparar facilmente entre classificadores), você pode exportar assim:

In [34]:
tokens_with_weights = sorted(list(zip(feature_names, clf.coef_[0])))

Intermezzo: HashingVectorizer

Outro vetorizador usado às vezes para classificação de texto é o HashingVectorizer. Ele consome menos memória e é mais rápido (por ser esparso e usar hashes em vez de tokens), mas é mais difícil de inspecionar. Você pode ler mais sobre prós e contras do HashingVectorizer na documentação do scikit-learn.

Vale testar e comparar seus resultados com os outros vetorizadores. Ele vai bem — melhor que o TF-IDF com MultinomialNB (o que já era esperado pelos mesmos motivos de CountVectorizer) —, mas não supera o TF-IDF com o algoritmo linear 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
 
confusion matrix 4
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
confusion matrix 5

Conclusão

Será que o seu experimento de classificador de fake news foi um sucesso? Definitivamente não.

Mas você pôde explorar um dataset novo, testar alguns modelos de classificação em NLP e inspecionar o quão bem eles funcionaram? Sim.

Como esperado desde o início, definir fake news com bag-of-words ou TF-IDF é uma abordagem simplista — ainda mais com um dataset multilíngue cheio de ruído. Se você não tivesse olhado o que o modelo realmente aprendeu, poderia achar que ele capturou algo significativo. Então, lembre-se: sempre faça introspecção dos seus modelos (na medida do possível!).

Fico curioso para saber se você encontra outras tendências nos dados que eu possa ter deixado passar. Vou publicar um post comparando como diferentes classificadores se comportam em relação às features mais importantes no meu blog. Se você pesquisar e achar algo interessante, compartilhe nos comentários ou fale comigo no Twitter (sou @kjam).

Espero que você tenha se divertido explorando um novo dataset de NLP comigo!

Dê uma olhada no Python Machine Learning: Scikit-Learn Tutorial da DataCamp.

Temas

PythonCiência de dadosAprendizado de máquina

Relacionado

Tutorial

Tutorial de análise de sentimentos com NLTK para iniciantes

Ver mais →