1.Tout d'abord

En tant que tutoriel sur l'apprentissage de l'apprentissage automatique, j'enregistrerai pour rappel comment j'ai fait pour prédire les survivants du Titanic, ce qui est une voie sûre.

La dernière fois, la prédiction du survivant du Titanic a été faite par une forêt aléatoire. Nous avons évalué l'effet de la modification des paramètres utilisés à ce moment-là sur le taux de précision.

Voir ci-dessous pour l'ensemble du programme. 　https://qiita.com/Fumio-eisan/items/77339fc737a3d8cfe179

2 Évaluation aléatoire de l'impact des paramètres forestiers

Random forest est un algorithme qui prépare plusieurs arbres de décision et prend une décision majoritaire pour niveler le surentraînement des arbres de décision.

Comme sa caractéristique

1. Il est peu probable qu'un surapprentissage se produise en raison de l'apprentissage d'ensemble par décision majoritaire
Pas besoin de standardisation des fonctionnalités ou de traitement de normalisation
1. Il y a peu d'hyper paramètres (sur le nombre d'échantillons et le nombre de caractéristiques de l'arbre déterminé)
Vous pouvez savoir quelle fonctionnalité est importante

Etc.

Il semble qu'on l'appelle parfois une technologie robuste et fanée, par opposition aux technologies scintillantes telles que la course en profondeur comme les réseaux de neurones. En tant que débutant en apprentissage automatique, j'aimerais réellement bouger mes mains et vérifier la sensation.

La page que j'ai utilisée comme référence http://aiweeklynews.com/archives/50653819.html

2-1 À propos de l'influence des n_estimators


x=[]
y=[]
for i in [1,2,3,4,5,6,7,8,9,10,15,20,25,30,40,50]:
    clf = RandomForestClassifier(
        n_estimators = i ,
        max_depth=5,
        random_state = 0)
    clf = clf.fit(train_X , train_y)
    pred = clf.predict(test_X)
    fpr, tpr , thresholds = roc_curve(test_y,pred,pos_label = 1)
    auc(fpr,tpr)
    accuracy_score(pred,test_y)
    y.append(accuracy_score(pred,test_y))
    x.append(i)
    
plt.scatter(x, y)
plt.xlabel('n_estimators')
plt.ylabel('accuracy')
plt.show()

n_estimators est le nombre d'arbres de décision. Vous pouvez voir que n_estimators saturent à environ 10. Si vous l'augmentez encore à 50, la valeur a diminué si elle sera en surapprentissage. https://amalog.hateblo.jp/entry/hyper-parameter-search

2-2 À propos de l'influence du critère


x=[]
y=[]
z=[]
for i in [1,2,3,4,5,6,7,8,9,10,15,20,25,30,40,50,100]:
    clf = RandomForestClassifier(
        criterion='gini',
        n_estimators = i ,
        max_depth=5,
        random_state = 0)
    clf = clf.fit(train_X , train_y)
    pred = clf.predict(test_X)
    fpr, tpr , thresholds = roc_curve(test_y,pred,pos_label = 1)
    auc(fpr,tpr)
    accuracy_score(pred,test_y)
    y.append(accuracy_score(pred,test_y))
    
    clf_e = RandomForestClassifier(
        criterion='entropy',
        n_estimators = i ,
        max_depth=5,
        random_state = 0)
    clf_e = clf_e.fit(train_X , train_y)
    pred_e = clf_e.predict(test_X)
    fpr, tpr , thresholds = roc_curve(test_y,pred_e,pos_label = 1)
    auc(fpr,tpr)
    accuracy_score(pred_e,test_y)
    z.append(accuracy_score(pred_e,test_y))

    x.append(i)
    
plt.xlabel('n_estimators')
plt.ylabel('accuracy')
plt.plot(x,y,label="gini")
plt.plot(x,z,label="entropy")
plt.legend(bbox_to_anchor=(1, 1), loc='center right', borderaxespad=0, fontsize=18)

Nous avons évalué l'effet de la différence dans la gestion de la fonction de Gini et de l'entropie de l'information. Comme je l'ai présenté la dernière fois, il semble que la fonction de Gini soit bonne pour la régression et que l'entropie de l'information soit bonne pour les données de catégorie. Lorsque le nombre d'arbres déterminés est inférieur à 10, la valeur est presque la même, et après cela, la fonction Gini passe de 10 à 40. Cependant, après cela, il s'est avéré que l'entropie de l'information avait un avantage. Il y a quelque chose que je ne comprends pas à propos de ce facteur, alors je vais le faire comme mes devoirs. .. ..

http://data-analysis-stats.jp/2019/01/14/%E6%B1%BA%E5%AE%9A%E6%9C%A8%E5%88%86%E6%9E%90%E3%81%AE%E3%83%91%E3%83%A9%E3%83%A1%E3%83%BC%E3%82%BF%E8%A7%A3%E8%AA%AC/

2-3 À propos de l'influence de ramdom_state


from sklearn.ensemble import RandomForestClassifier
x=[]
y=[]
z=[]
for i in [1,2,3,4,5,6,7,8,9,10,15,20,25,30,40,50,60,70,80,90,100]:
    clf = RandomForestClassifier(
        criterion='gini',
        n_estimators = 10 ,
        max_depth=5,
        random_state = i)
    clf = clf.fit(train_X , train_y)
    pred = clf.predict(test_X)
    fpr, tpr , thresholds = roc_curve(test_y,pred,pos_label = 1)
    auc(fpr,tpr)
    accuracy_score(pred,test_y)
    y.append(accuracy_score(pred,test_y))
    
    clf_e = RandomForestClassifier(
        criterion='entropy',
        n_estimators = 10 ,
        max_depth=5,
        random_state = i)
    clf_e = clf_e.fit(train_X , train_y)
    pred_e = clf_e.predict(test_X)
    fpr, tpr , thresholds = roc_curve(test_y,pred_e,pos_label = 1)
    auc(fpr,tpr)
    accuracy_score(pred_e,test_y)
    z.append(accuracy_score(pred_e,test_y))

    x.append(i)
    
    

plt.xlabel('ramdom_state')
plt.ylabel('accuracy')
plt.plot(x,y,label="gini")
plt.plot(x,z,label="entropy")
plt.legend(bbox_to_anchor=(1, 1), loc='center right', borderaxespad=0, fontsize=18)

Ensuite, j'ai changé random_state. Vous pouvez voir que ce n'est pas tout à fait stable. Il semble que cela sature également dans environ 10 fois. En premier lieu, la signification de cette valeur est d'assurer la reproductibilité.

https://teratail.com/questions/99054

Le même nombre aléatoire peut être généré en spécifiant> random_state. Le but est d'assurer la reproductibilité. La raison pour laquelle des nombres aléatoires sont nécessaires est que certaines des données doivent être sélectionnées au hasard pour créer des prédicteurs faibles.

3 Résumé

A partir de cette confirmation, il a été constaté que ce sont n_estimators: le nombre d'arbres déterminés qui affecte grandement le taux de précision. Il a été confirmé qu'en entrant une valeur élevée dans une certaine mesure, il sera saturé. Si cela prend beaucoup de temps de calcul, il faut ajouter un travail qui s'arrêtera lorsqu'il sature automatiquement.