Essayez d'estimer le nombre de likes sur Twitter

introduction

L'origine de cela était d'essayer d'apprendre le grattage pour la production d'IA de courses de chevaux, et je cherchais la tâche d'apprentissage. Quoi qu'il en soit, je pense que ce serait bien d'avoir une séquence d'acquisition de données → prétraitement → apprentissage → inférence. ** Estimez le nombre de likes à partir du contenu du tweet de mes hommes préférés Hana Oba ** J'ai décidé d'en faire une tâche d'apprentissage. Cette fois, l'objectif est de commencer à bouger avec un flux simple, et je travaillerai sur la précision dans le futur.

• Veuillez signaler toute erreur.

Collecte de données

La collecte de données utilise l'API Twitter. Pour la méthode d'inscription, je me suis référé à l'article ci-dessous. Conseils pour réussir l'inscription à l'API Twitter en 30 minutes (avec traduction en japonais) Eh bien, c'est difficile à écrire compte tenu de la raison, alors soyez prêt. J'ai été écrasé ici pendant un jour. (Le japonais n'est pas pratique ...)

Après l'inscription, vous pouvez obtenir un Tweet, donc j'écrirai le programme d'acquisition. Normalement, l'API Twitter semble ne pouvoir recevoir que 200 Tweets, et vous pouvez également réaliser "Obtenez tous les tweets de @hana_oba" en vous référant à l'article suivant. J'écrirai le code. La plupart d'entre eux sont des copies du programme d'article de référence, donc je ne listerai que les parties que j'ai écrites ici. Recevez beaucoup de tweets avec TwitterAPI. Tenez compte des erreurs côté serveur (en python)

get_twitter.py

    #Obtenir en spécifiant l'utilisateur (écran_name）
    getter = TweetsGetter.byUser('hana_oba')
    df = pd.DataFrame(columns = ['week_day','have_photo','have_video','tweet_time','text_len','favorite_count','retweet_count'])
 
    cnt = 0
    for tweet in getter.collect(total = 10000):
        cnt += 1

        week_day = tweet['created_at'].split()[0]
        tweet_time = tweet['created_at'].split()[3][:2]

        #Spécifiez la colonne que vous souhaitez Eoncode dans la liste. Bien sûr, vous pouvez en spécifier plusieurs.
        list_cols = ['week_day']
        #Spécifiez la colonne que vous souhaitez utiliser OneHotEncode. Spécifiez également la méthode d'achèvement en cas de Null ou inconnu.
        ce_ohe = ce.OneHotEncoder(cols=list_cols,handle_unknown='impute')

        photo = 0
        video = 0
        if 'media' in tweet['entities']:

            if 'photo' in tweet['entities']['media'][0]['expanded_url']:
                photo = 1
            else:
                video = 1
        
        df = df.append(pd.Series([week_day, photo, video, int(tweet_time), len(tweet['text']),tweet['favorite_count'],tweet['retweet_count']], index=df.columns),ignore_index=True)
        df_session_ce_onehot = ce_ohe.fit_transform(df)

    df_session_ce_onehot.to_csv('oba_hana_data.csv',index=False)

Je n'ai rien inventé en particulier, mais il est difficile de bien gérer les données sans comprendre les spécifications de l'API Twitter, alors obtenons les données que vous voulez par google ou par essais et erreurs. Cet ensemble de données est --Journée

• Présence ou absence d'image --Présence ou absence de vidéo
• Temps doux --Nombre de caractères dans le tweet Seulement. Les jours sont divisés en sept jours à l'aide de l'encodage à chaud. Nous étudierons cette fois uniquement ces informations.

Prétraitement, apprentissage

Jusqu'à présent, j'exécutais le programme sur mon propre PC, mais bien que ce ne soit pas un gros problème, les spécifications de la machine ne sont pas suffisantes en fonction des développements futurs, donc à partir de là, je vais l'exécuter sur Google Colaboratory.

Tout d'abord, lisez les données produites par le programme précédent.

import pandas as pd

datapath = '/content/drive/My Drive/data_science/'
df = pd.read_csv(datapath + 'oba_hana_data.csv')

Le nombre total de données est

df.shape

Il y a eu 2992 cas.

(2992, 13)

J'utiliserai 70% du total comme données d'entraînement et les 30% restants comme données de vérification. Les données sont classées par ordre chronologique, et s'il s'agit simplement de 70% du front, les conditions telles que le nombre d'adeptes à ce moment-là seront différentes, donc je voudrais acquérir au hasard 70%. Bien qu'il contienne des éléments analogiques, nous utiliserons cette fois 2400 cas, soit environ 70% du total, comme données d'entraînement et le reste comme données de vérification.

df_train = df.sample(n=2400)
df_test = df.drop(df_train.index)

x_train = df_train.iloc[:,:11]
t_train = df_train['favorite_count']

x_test = df_test.iloc[:,:11]
t_test = df_test['favorite_count']

Apprenons avec ces données une fois dans une forêt aléatoire.

#Modèle de déclaration
from sklearn.ensemble import RandomForestRegressor

model = RandomForestRegressor(n_estimators=2000, max_depth=10,
                                min_samples_leaf=4, max_features=0.2, random_state=0)

#Apprentissage de modèle
model.fit(x_train, t_train)

Voyons le score

#Validation du modèle
print(model.score(x_train, t_train))
print(model.score(x_test, t_test))

0.5032870524389081
0.3102920436689621

Ce que le score représente est le facteur de décision car il s'agit d'un problème de régression. En prenant une valeur de 0 à 1, plus elle est proche de 1, plus la précision est élevée.

En regardant le score cette fois, la précision n'est pas bonne. Maintenant, effectuons un prétraitement pour améliorer la précision. Regardons d'abord la contribution de chaque paramètre.

#Stockage variable par ordre décroissant de contribution de la quantité de caractéristiques
feat_names = x_train.columns.values
importances = model.feature_importances_
indices = np.argsort(importances)[::-1]

plt.figure(figsize=(10, 10))
plt.title('Feature importances')
plt.barh(range(len(indices)), importances[indices])
plt.yticks(range(len(indices)), feat_names[indices], rotation='horizontal')
plt.show();

J'aimerais que vous réfléchissiez à ce qui est important pour faire une estimation. Il semble que have_photo a la contribution la plus élevée, c'est-à-dire que la présence ou l'absence de photos est importante. Les vidéos ne semblent pas si importantes, mais les vidéos ne représentent probablement pas 3% du total. Il semble que les jours ne soient presque pas pertinents. Cela peut être supprimé des données.

Nous examinerons également les valeurs aberrantes.

#Visualisez avec un graphique
plt.figure(figsize=(8, 6))
plt.scatter(range(x_train.shape[0]), np.sort(t_train.values))
plt.xlabel('index', fontsize=12)
plt.ylabel('y', fontsize=12)
plt.show()

Vous pouvez voir que certaines des données d'entraînement sont clairement désynchronisées. Je vais supprimer ces données parce que je peux être traîné par celles-ci et apprendre.

#C'est l'inverse de l'ordre d'explication, mais si vous ne le faites pas dans cet ordre, vous ne pouvez pas fractionner avec les valeurs aberrantes supprimées
#Suppression des valeurs aberrantes
df_train = df_train[df_train['favorite_count'] < 4500]
df_train.shape

#Supprimer le jour
x_train = df_train.iloc[:,7:11]
t_train = df_train['favorite_count']
x_test = df_test.iloc[:,7:11]
t_test = df_test['favorite_count']

Maintenant, apprenons à nouveau et voyons le score.

#Validation du modèle
print(model.score(x_train, t_train))
print(model.score(x_test, t_test))

0.5175871090277164
0.34112337762190204

C'est mieux qu'avant. Enfin, regardons la distribution du nombre réel de likes et le nombre estimé de likes dans un histogramme.

Le bleu est le nombre estimé et l'orange le nombre réel de likes. Il y a certainement un écart, mais je ne peux rien dire car je n'ai pas vu chacun d'eux.

L'amélioration de la précision sera également la prochaine.

référence

• Comment enregistrer l'API Twitter

Conseils pour réussir l'inscription à l'API Twitter en 30 minutes (avec traduction en japonais)

• Acquisition de données à l'aide de l'API Twitter

Recevez beaucoup de tweets avec TwitterAPI. Tenez compte des erreurs côté serveur (en python)