Je souhaite implémenter un algorithme d'apprentissage automatique dans scikit learn, mais je ne comprends pas ce que fait ce paramètre random_state? Pourquoi devrais-je l'utiliser?
Je ne pouvais pas non plus comprendre ce qu'est un nombre pseudo-aléatoire.
Réponses:
train_test_splitdivise les tableaux ou les matrices en sous-ensembles aléatoires de train et de test. Cela signifie que chaque fois que vous l'exécutez sans le spécifier random_state, vous obtiendrez un résultat différent, c'est le comportement attendu. Par exemple:
Exécution 1:
>>> a, b = np.arange(10).reshape((5, 2)), range(5)
>>> train_test_split(a, b)
[array([[6, 7],
[8, 9],
[4, 5]]),
array([[2, 3],
[0, 1]]), [3, 4, 2], [1, 0]]
Exécutez 2
>>> train_test_split(a, b)
[array([[8, 9],
[4, 5],
[0, 1]]),
array([[6, 7],
[2, 3]]), [4, 2, 0], [3, 1]]
Ça change. D'un autre côté, si vous utilisez random_state=some_number, vous pouvez garantir que la sortie de Run 1 sera égale à la sortie de Run 2 , c'est-à-dire que votre partage sera toujours le même. Peu importe le random_statenombre réel de 42, 0, 21, ... L'important est que chaque fois que vous utilisez 42, vous obtiendrez toujours la même sortie la première fois que vous effectuez le fractionnement. Ceci est utile si vous voulez des résultats reproductibles, par exemple dans la documentation, afin que tout le monde puisse voir systématiquement les mêmes nombres quand ils exécutent les exemples. En pratique, je dirais que vous devriez définir random_stateun nombre fixe pendant que vous testez des éléments, mais supprimez-le en production si vous avez vraiment besoin d'un fractionnement aléatoire (et non fixe).
En ce qui concerne votre deuxième question, un générateur de nombres pseudo-aléatoires est un générateur de nombres qui génère des nombres presque vraiment aléatoires. Pourquoi ils ne sont pas vraiment aléatoires est hors du champ de cette question et n'aura probablement pas d'importance dans votre cas, vous pouvez jeter un œil ici pour plus de détails.
Si vous ne spécifiez pas le random_statedans votre code, chaque fois que vous exécutez (exécutez) votre code, une nouvelle valeur aléatoire est générée et les ensembles de données de train et de test auront des valeurs différentes à chaque fois.
Cependant, si une valeur fixe est affectée comme random_state = 42alors, quel que soit le nombre de fois que vous exécutez votre code, le résultat serait le même .ie, les mêmes valeurs dans les ensembles de données de train et de test.
Si vous ne mentionnez pas random_state dans le code, chaque fois que vous exécutez votre code, une nouvelle valeur aléatoire est générée et les ensembles de données de train et de test auront des valeurs différentes à chaque fois.
Cependant, si vous utilisez une valeur particulière pour random_state (random_state = 1 ou toute autre valeur) à chaque fois, le résultat sera le même, c'est-à-dire les mêmes valeurs dans les ensembles de données de train et de test. Référez-vous au code ci-dessous:
import pandas as pd
from sklearn.model_selection import train_test_split
test_series = pd.Series(range(100))
size30split = train_test_split(test_series,random_state = 1,test_size = .3)
size25split = train_test_split(test_series,random_state = 1,test_size = .25)
common = [element for element in size25split[0] if element in size30split[0]]
print(len(common))
Peu importe le nombre de fois que vous exécutez le code, la sortie sera 70.
70Essayez de supprimer random_state et exécutez le code.
import pandas as pd
from sklearn.model_selection import train_test_split
test_series = pd.Series(range(100))
size30split = train_test_split(test_series,test_size = .3)
size25split = train_test_split(test_series,test_size = .25)
common = [element for element in size25split[0] if element in size30split[0]]
print(len(common))
Maintenant, ici, la sortie sera différente chaque fois que vous exécutez le code.
random_state number divise les ensembles de données de test et de formation de manière aléatoire. En plus de ce qui est expliqué ici, il est important de se rappeler que la valeur random_state peut avoir un effet significatif sur la qualité de votre modèle (par qualité, j'entends essentiellement la précision à prédire). Par exemple, si vous prenez un certain ensemble de données et entraînez un modèle de régression avec lui, sans spécifier la valeur random_state, il est possible qu'à chaque fois, vous obtiendrez un résultat de précision différent pour votre modèle entraîné sur les données de test. Il est donc important de trouver la meilleure valeur random_state pour vous fournir le modèle le plus précis. Et puis, ce numéro sera utilisé pour reproduire votre modèle dans une autre occasion telle qu'une autre expérience de recherche. Faire cela,
for j in range(1000):
X_train, X_test, y_train, y_test = train_test_split(X, y , random_state =j, test_size=0.35)
lr = LarsCV().fit(X_train, y_train)
tr_score.append(lr.score(X_train, y_train))
ts_score.append(lr.score(X_test, y_test))
J = ts_score.index(np.max(ts_score))
X_train, X_test, y_train, y_test = train_test_split(X, y , random_state =J, test_size=0.35)
M = LarsCV().fit(X_train, y_train)
y_pred = M.predict(X_test)`
Si aucun état aléatoire n'est fourni, le système utilisera un état aléatoire généré en interne. Ainsi, lorsque vous exécutez le programme plusieurs fois, vous pouvez voir différents points de données de train / test et le comportement sera imprévisible. Si vous rencontrez un problème avec votre modèle, vous ne pourrez pas le recréer car vous ne connaissez pas le nombre aléatoire généré lors de l'exécution du programme.
Si vous voyez les classificateurs d'arbres - DT ou RF, ils essaient de créer un essai en utilisant un plan optimal. Bien que la plupart du temps ce plan soit le même, il peut y avoir des cas où l'arbre peut être différent et donc les prédictions. Lorsque vous essayez de déboguer votre modèle, vous ne pourrez peut-être pas recréer la même instance pour laquelle un arbre a été créé. Donc, pour éviter tous ces tracas, nous utilisons un random_state lors de la construction d'un DecisionTreeClassifier ou RandomForestClassifier.
PS: Vous pouvez aller un peu en profondeur sur la façon dont l'arbre est construit dans DecisionTree pour mieux comprendre cela.
randomstate est essentiellement utilisé pour reproduire votre problème de la même manière à chaque fois qu'il est exécuté. Si vous n'utilisez pas un état aléatoire dans traintestsplit, chaque fois que vous effectuez le fractionnement, vous pouvez obtenir un ensemble différent de points de données de train et de test et ne vous aidera pas à déboguer en cas de problème.
De Doc:
Si int, randomstate est la graine utilisée par le générateur de nombres aléatoires; Si une instance de RandomState, randomstate est le générateur de nombres aléatoires; Si None, le générateur de nombres aléatoires est l'instance RandomState utilisée par np.random.
sklearn.model_selection.train_test_split(*arrays, **options)[source]Diviser des tableaux ou des matrices en sous-ensembles aléatoires de train et de test
Parameters: ...
random_state : int, RandomState instance or None, optional (default=None)
Si int, random_state est la graine utilisée par le générateur de nombres aléatoires; Si une instance de RandomState, random_state est le générateur de nombres aléatoires; Si None, le générateur de nombres aléatoires est l'instance RandomState utilisée par np.random. source: http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html
'' 'En ce qui concerne l'état aléatoire, il est utilisé dans de nombreux algorithmes aléatoires de sklearn pour déterminer la graine aléatoire passée au générateur de nombres pseudo-aléatoires. Par conséquent, il ne régit aucun aspect du comportement de l'algorithme. En conséquence, les valeurs d'état aléatoires qui ont bien fonctionné dans l'ensemble de validation ne correspondent pas à celles qui fonctionneraient bien dans un nouvel ensemble de test invisible. En effet, selon l'algorithme, vous pourriez voir des résultats complètement différents en changeant simplement l'ordre des échantillons d'entraînement. '' 'Source: /stats/263999/is-random-state-a-parameter -pour syntoniser