Stato casuale (numero pseudo-casuale) in Scikit Learn

Voglio implementare un algoritmo di machine learning in scikit learn, ma non capisco cosa fa questo parametro random_state? Perché dovrei usarlo?

Inoltre non riuscivo a capire cosa fosse un numero pseudo-casuale.

train_test_splitdivide matrici o matrici in treni casuali e sottoinsiemi di test. Ciò significa che ogni volta che lo esegui senza specificare random_state, otterrai un risultato diverso, questo è il comportamento previsto. Per esempio:

Esegui 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]]

Esegui 2

>>> train_test_split(a, b)
[array([[8, 9],
        [4, 5],
        [0, 1]]),
 array([[6, 7],
        [2, 3]]), [4, 2, 0], [3, 1]]

Cambia. D'altra parte, se lo usi random_state=some_number, allora puoi garantire che l'output della Run 1 sarà uguale all'output della Run 2 , cioè il tuo split sarà sempre lo stesso. Non importa quale sia il random_statenumero effettivo di 42, 0, 21, ... L'importante è che ogni volta che usi 42, otterrai sempre lo stesso output la prima volta che effettui la divisione. Ciò è utile se si desidera risultati riproducibili, ad esempio nella documentazione, in modo che tutti possano vedere costantemente gli stessi numeri quando eseguono gli esempi. In pratica, direi che dovresti impostare random_stateun numero fisso mentre collaudi roba, ma poi rimuoverlo in produzione se hai davvero bisogno di una divisione casuale (e non fissa).

Per quanto riguarda la tua seconda domanda, un generatore di numeri pseudo-casuale è un generatore di numeri che genera numeri quasi casuali. Perché non sono veramente casuali non rientra nell'ambito di questa domanda e probabilmente non avrà importanza nel tuo caso, puoi dare un'occhiata qui per maggiori dettagli.

Se non specifichi il random_statecodice nel tuo codice, ogni volta che esegui (esegui) il tuo codice viene generato un nuovo valore casuale e il set di dati del treno e del test avrà valori diversi ogni volta.

Tuttavia, se viene assegnato un valore fisso come random_state = 42allora, non importa quante volte si esegue il codice, il risultato sarebbe lo stesso .ie, stessi valori nei set di dati di treni e test.

Se non si menziona random_state nel codice, ogni volta che si esegue il codice viene generato un nuovo valore casuale e il set di dati del treno e del test avrà valori diversi ogni volta.

Tuttavia, se si utilizza un valore particolare per random_state (random_state = 1 o qualsiasi altro valore) ogni volta che il risultato sarà lo stesso, ovvero gli stessi valori nei set di dati di treni e test. Fare riferimento al codice seguente:

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))

Non importa quante volte esegui il codice, l'output sarà 70.

70

Prova a rimuovere random_state ed esegui il codice.

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))

Ora qui l'output sarà diverso ogni volta che si esegue il codice.

random_state number divide i set di dati di test e training in modo casuale. Oltre a quanto spiegato qui, è importante ricordare che il valore random_state può avere un effetto significativo sulla qualità del modello (per qualità intendo essenzialmente l'accuratezza da prevedere). Ad esempio, se si prende un determinato set di dati e si addestra un modello di regressione con esso, senza specificare il valore random_state, c'è il potenziale che ogni volta, si otterrà un risultato di precisione diverso per il modello addestrato sui dati del test. Quindi è importante trovare il miglior valore random_state per fornirti il ​​modello più accurato. E poi, quel numero verrà usato per riprodurre il tuo modello in un'altra occasione come un altro esperimento di ricerca. Fare così,

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)`

Se non è presente uno stato casuale, il sistema utilizzerà uno stato casuale generato internamente. Pertanto, quando si esegue il programma più volte, è possibile che vengano visualizzati diversi punti dati treno / test e il comportamento sarà imprevedibile. Nel caso in cui tu abbia un problema con il tuo modello, non sarai in grado di ricrearlo perché non conosci il numero casuale che è stato generato quando hai eseguito il programma.

Se vedi i Classificatori ad albero - DT o RF, provano a creare un tentativo usando un piano ottimale. Sebbene la maggior parte delle volte questo piano possa essere lo stesso, potrebbero esserci casi in cui l'albero potrebbe essere diverso e quindi le previsioni. Quando si tenta di eseguire il debug del modello, potrebbe non essere possibile ricreare la stessa istanza per cui è stato creato un albero. Quindi, per evitare tutto questo fastidio, usiamo random_state durante la creazione di DecisionTreeClassifier o RandomForestClassifier.

PS: puoi approfondire il modo in cui l'albero è costruito in DecisionTree per capirlo meglio.

randomstate viene sostanzialmente utilizzato per riprodurre lo stesso problema ogni volta che viene eseguito. Se non utilizzi uno stato casuale in traintestsplit, ogni volta che effettui la divisione potresti ottenere un diverso set di punti treno e test e non ti aiuterà nel debug in caso di problemi.

Da Doc:

Se int, randomstate è il seme utilizzato dal generatore di numeri casuali; Se l'istanza di RandomState, randomstate è il generatore di numeri casuali; Se Nessuno, il generatore di numeri casuali è l'istanza di RandomState utilizzata da np.random.

sklearn.model_selection.train_test_split(*arrays, **options)[source]

Dividi array o matrici in treno casuale e sottoinsiemi di test

Parameters: ... 
    random_state : int, RandomState instance or None, optional (default=None)

Se int, random_state è il seme utilizzato dal generatore di numeri casuali; Se l'istanza di RandomState, random_state è il generatore di numeri casuali; Se Nessuno, il generatore di numeri casuali è l'istanza di RandomState utilizzata da np.random. fonte: http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html

'' Per quanto riguarda lo stato casuale, viene utilizzato in molti algoritmi randomizzati in sklearn per determinare il seme casuale passato al generatore di numeri pseudo-casuali. Pertanto, non regola alcun aspetto del comportamento dell'algoritmo. Di conseguenza, i valori di stato casuali che hanno funzionato bene nel set di validazione non corrispondono a quelli che si comporterebbero bene in un nuovo set di test non visto. In effetti, a seconda dell'algoritmo, potresti vedere risultati completamente diversi semplicemente cambiando l'ordine dei campioni di addestramento. '' 'Fonte: /stats/263999/is-random-state-a-parameter -sintonizzare