microsoftml.rx_logistic_regression: Regressione logistica

Utilizzo

microsoftml.rx_logistic_regression(formula: str,
    data: [revoscalepy.datasource.RxDataSource.RxDataSource,
    pandas.core.frame.DataFrame], method: ['binary',
    'multiClass'] = 'binary', l2_weight: float = 1,
    l1_weight: float = 1, opt_tol: float = 1e-07,
    memory_size: int = 20, init_wts_diameter: float = 0,
    max_iterations: int = 2147483647,
    show_training_stats: bool = False, sgd_init_tol: float = 0,
    train_threads: int = None, dense_optimizer: bool = False,
    normalize: ['No', 'Warn', 'Auto', 'Yes'] = 'Auto',
    ml_transforms: list = None, ml_transform_vars: list = None,
    row_selection: str = None, transforms: dict = None,
    transform_objects: dict = None, transform_function: str = None,
    transform_variables: list = None,
    transform_packages: list = None,
    transform_environment: dict = None, blocks_per_read: int = None,
    report_progress: int = None, verbose: int = 1,
    ensemble: microsoftml.modules.ensemble.EnsembleControl = None,
    compute_context: revoscalepy.computecontext.RxComputeContext.RxComputeContext = None)

Descrizione

Regressione logistica di Machine Learning

Dettagli

La regressione logistica è un metodo di classificazione usato per stimare il valore di una variabile dipendente categorica dalla relazione a una o più variabili indipendenti presupponendo una distribuzione logistica. Se la variabile dipendente ha solo due valori possibili (esito positivo/negativo), la regressione logistica è binaria. Se la variabile dipendente ha più di due valori possibili (tipo di sangue dato i risultati del test diagnostico), la regressione logistica è multinomiale.

La tecnica di ottimizzazione usata per rx_logistic_regression è la memoria limitata Broyden-Fletcher-Goldfarb-Shanno (L-BFGS). Gli algoritmi L-BFGS e BFGS regolari usano metodi quasi newtoniani per stimare la matrice hessiana a elevato utilizzo di calcolo nell'equazione utilizzata dal metodo di Newton per calcolare i passaggi. Tuttavia, l'approssimazione L-BFGS usa solo una quantità limitata di memoria per calcolare la direzione del passaggio successivo, in modo che sia particolarmente adatta per problemi con un numero elevato di variabili. Il memory_size parametro specifica il numero di posizioni e sfumature passate da archiviare per l'uso nel calcolo del passaggio successivo.

Questo strumento di apprendimento può usare la regolarizzazione rete elastica: una combinazione lineare di regolarizzazioni L1 (lazo) e L2 (ridge). La regolarizzazione è un metodo che può rendere più trattabile un problema non corretto imponendo vincoli che forniscono informazioni per integrare i dati e che impedisce l'overfitting penalizzando i modelli con valori di coefficiente estremi. Ciò può migliorare la generalizzazione del modello appreso selezionando la complessità ottimale nel compromesso della varianza di distorsione. La regolarizzazione funziona aggiungendo la penalità associata ai valori di coefficiente all'errore dell'ipotesi. Un modello accurato con valori di coefficiente estremi verrebbe penalizzato di più, ma un modello meno accurato con valori più conservativi verrebbe penalizzato meno. La regolarizzazione L1 e L2 hanno effetti e usi diversi che sono complementari in determinati aspetti.

  • l1_weight: può essere applicato a modelli di tipo sparse, quando si utilizzano dati ad alta dimensione. Tira piccoli pesi associati che sono relativamente poco importanti verso 0.

  • l2_weight: è preferibile per i dati non di tipo sparse. Tira grandi pesi verso zero.

L'aggiunta della penalità della cresta alla regolarizzazione supera alcune delle limitazioni del lazo. Può migliorare la precisione predittiva, ad esempio, quando il numero di predictor è maggiore della dimensione del campione. Se x = l1_weight e y = l2_weight, ax + by = c definisce l'intervallo lineare dei termini di regolarizzazione. I valori predefiniti di x e y sono entrambi 1. Una regolarizzazione aggressiva può danneggiare la capacità predittiva escludendo variabili importanti fuori dal modello. La scelta dei valori ottimali per i parametri di regolarizzazione è quindi importante per le prestazioni del modello di regressione logistica.

Argomenti

formula

La formula come descritto in revoscalepy.rx_formula Termini di interazione e F() non è attualmente supportata in microsoftml.

data

Oggetto origine dati o stringa di caratteri che specifica un file con estensione xdf o un oggetto frame di dati.

method

Stringa di caratteri che specifica il tipo di regressione logistica: "binary" per la regressione logistica di classificazione binaria predefinita o "multiClass" per la regressione logistica multinomiale.

l2_weight

Peso di regolarizzazione L2. Il valore deve essere maggiore o uguale a 0 e il valore predefinito è impostato su 1.

l1_weight

Peso di regolarizzazione L1. Il valore deve essere maggiore o uguale a 0 e il valore predefinito è impostato su 1.

opt_tol

Valore soglia per la convergenza dell'utilità di ottimizzazione. Se il miglioramento tra le iterazioni è inferiore alla soglia, l'algoritmo si interrompe e restituisce il modello corrente. I valori più piccoli sono più lenti, ma più accurati. Il valore predefinito è 1e-07.

memory_size

Dimensioni della memoria per L-BFGS, specificando il numero di posizioni e sfumature passate da archiviare per il calcolo del passaggio successivo. Questo parametro di ottimizzazione limita la quantità di memoria usata per calcolare la grandezza e la direzione del passaggio successivo. Quando si specifica una quantità di memoria inferiore, il training è più veloce ma meno accurato. Deve essere maggiore o uguale a 1 e il valore predefinito è 20.

max_iterations

Imposta il numero massimo di iterazioni. Dopo questo numero di passaggi, l'algoritmo viene arrestato anche se non ha soddisfatto i criteri di convergenza.

show_training_stats

Specificare per visualizzare True le statistiche dei dati di training e del modello sottoposto a training; in caso contrario, False. Il valore predefinito è False. Per altre informazioni sulle statistiche del modello, vedere summary.ml_model().

sgd_init_tol

Impostare su un numero maggiore di 0 per usare Stochastic Gradient Descent (SGD) per trovare i parametri iniziali. Un set di valori diverso da zero specifica l'utilizzo del valore SGD di tolleranza per determinare la convergenza. Il valore 0 predefinito specifica che SGD non viene usato.

init_wts_diameter

Imposta il diametro iniziale dei pesi che specifica l'intervallo da cui vengono disegnati i valori per i pesi iniziali. Questi pesi vengono inizializzati in modo casuale dall'interno di questo intervallo. Ad esempio, se il diametro viene specificato come d, i pesi vengono distribuiti in modo uniforme tra -d/2 e d/2. Il valore predefinito è 0, che specifica che tutti i pesi vengono inizializzati su 0.

train_threads

Numero di thread da usare per il training del modello. Deve essere impostato sul numero di core nel computer. Si noti che L-BFGS multithreading tenta di caricare il set di dati in memoria. In caso di problemi di memoria insufficiente, impostare su per train_threads1 disattivare il multithreading. Se Nessuno il numero di thread da usare viene determinato internamente. Il valore predefinito è None.

dense_optimizer

Se True, forza la densificazione dei vettori di ottimizzazione interni. Se False, abilita l'utilità di ottimizzazione per la regressione logistica usa stati interni di tipo sparse o densi in base alle esigenze. L'impostazione di denseOptimizer su True richiede che l'ottimizzatore interno usi uno stato interno denso, che può contribuire ad alleviare il carico nel Garbage Collector per alcune varietà di problemi più grandi.

normalizzare

Specifica il tipo di normalizzazione automatica utilizzata:

  • "Auto": se è necessaria la normalizzazione, viene eseguita automaticamente. Questa è la scelta predefinita.

  • "No": non viene eseguita alcuna normalizzazione.

  • "Yes": viene eseguita la normalizzazione.

  • "Warn": se è necessaria la normalizzazione, viene visualizzato un messaggio di avviso, ma la normalizzazione non viene eseguita.

La normalizzazione ridimensiona intervalli di dati diversi in una scala standard. Il ridimensionamento delle funzionalità assicura che le distanze tra i punti dati siano proporzionali e consentano a vari metodi di ottimizzazione, ad esempio la discesa del gradiente, di convergere molto più velocemente. Se viene eseguita la normalizzazione, viene utilizzato un MaxMin normalizzatore. Normalizza i valori in un intervallo [a, b] dove -1 <= a <= 0 e 0 <= b <= 1 .b - a = 1 Questo normalizzatore mantiene la spaziatura eseguendo il mapping da zero a zero.

ml_transforms

Specifica un elenco di trasformazioni MicrosoftML da eseguire sui dati prima del training o Nessuna se non devono essere eseguite trasformazioni. Per le trasformazioni supportate, vedere featurize_text, categoricale categorical_hash. Queste trasformazioni vengono eseguite dopo le trasformazioni Python specificate. Il valore predefinito è None.

ml_transform_vars

Specifica un vettore di caratteri di nomi di variabile da utilizzare in ml_transforms o Nessuno se non deve essere utilizzato nessuno. Il valore predefinito è None.

row_selection

NON SUPPORTATO. Specifica le righe (osservazioni) del set di dati che devono essere usate dal modello con il nome di una variabile logica dal set di dati (tra virgolette) o con un'espressione logica usando variabili nel set di dati. Ad esempio:

  • row_selection = "old" userà solo osservazioni in cui il valore della variabile old è True.

  • row_selection = (age > 20) & (age < 65) & (log(income) > 10) usa solo osservazioni in cui il valore della age variabile è compreso tra 20 e 65 e il valore della logincome variabile è maggiore di 10.

La selezione delle righe viene eseguita dopo l'elaborazione di qualsiasi trasformazione dei dati (vedere gli argomenti transforms o transform_function). Come per tutte le espressioni, row_selection può essere definito all'esterno della chiamata di funzione usando la expression funzione .

trasformazioni

NON SUPPORTATO. Espressione del form che rappresenta il primo round delle trasformazioni delle variabili. Come per tutte le espressioni, transforms (o row_selection) può essere definito all'esterno della chiamata di funzione usando la expression funzione .

transform_objects

NON SUPPORTATO. Elenco denominato che contiene oggetti a cui è possibile fare riferimento da transforms, transform_functione row_selection.

transform_function

Funzione di trasformazione della variabile.

transform_variables

Vettore di caratteri delle variabili del set di dati di input necessarie per la funzione di trasformazione.

transform_packages

NON SUPPORTATO. Vettore di caratteri che specifica pacchetti Python aggiuntivi (al di fuori di quelli specificati in RxOptions.get_option("transform_packages")) da rendere disponibili e precaricate per l'uso nelle funzioni di trasformazione delle variabili. Ad esempio, quelli definiti in modo esplicito nelle funzioni revoscalepy tramite i relativi transforms argomenti e transform_function o quelli definiti in modo implicito tramite formula gli argomenti o row_selection . L'argomento transform_packages può anche essere Nessuno, a indicare che nessun pacchetto esterno RxOptions.get_option("transform_packages") viene precaricato.

transform_environment

NON SUPPORTATO. Ambiente definito dall'utente da usare come elemento padre di tutti gli ambienti sviluppati internamente e usati per la trasformazione dei dati variabili. Se transform_environment = None, viene usato un nuovo ambiente "hash" con revoscalepy.baseenv padre.

blocks_per_read

Specifica il numero di blocchi da leggere per ogni blocco di dati letto dall'origine dati.

report_progress

Valore intero che specifica il livello di creazione di report sullo stato di elaborazione delle righe:

  • 0: non viene segnalato alcun avanzamento.

  • 1: il numero di righe elaborate viene stampato e aggiornato.

  • 2: vengono segnalate le righe elaborate e le tempistiche.

  • 3: vengono segnalate le righe elaborate e tutte le tempistiche.

verbose

Valore intero che specifica la quantità di output desiderata. Se 0, non viene stampato alcun output dettagliato durante i calcoli. Valori interi da 1 per 4 fornire quantità crescenti di informazioni.

compute_context

Imposta il contesto in cui vengono eseguiti i calcoli, specificati con un revoscalepy valido. RxComputeContext. Attualmente locale e revoscalepy. Sono supportati i contesti di calcolo RxInSqlServer.

insieme

Parametri di controllo per l'ensembling.

Restituisce

Oggetto LogisticRegression con il modello sottoposto a training.

Nota

Questo algoritmo tenterà di caricare l'intero set di dati in memoria quando train_threads > 1 (multithreading).

Vedi anche

rx_predict

Riferimenti

Wikipedia: L-BFGS

Wikipedia: Regressione logistica

Training scalabile dei modelli di L1-Regularized Log-Linear

Esecuzione di test - Regolarizzazione L1 e L2 per Machine Learning

Esempio di classificazione binaria

'''
Binary Classification.
'''
import numpy
import pandas
from microsoftml import rx_logistic_regression, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

infert = get_dataset("infert")


import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

infertdf = infert.as_df()
infertdf["isCase"] = infertdf.case == 1
data_train, data_test, y_train, y_test = train_test_split(infertdf, infertdf.isCase)

model = rx_logistic_regression(
    formula=" isCase ~ age + parity + education + spontaneous + induced ",
    data=data_train)

print(model.coef_)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(model, data=data_test,
                     extra_vars_to_write=["isCase", "Score"])
                     
# Print the first five rows
print(rx_data_step(score_ds, number_rows_read=5))

Output:

Automatically adding a MinMax normalization transform, use 'norm=Warn' or 'norm=No' to turn this behavior off.
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 186, Read Time: 0.001, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 186, Read Time: 0, Transform Time: 0
Beginning processing data.
LBFGS multi-threading will attempt to load dataset into memory. In case of out-of-memory issues, turn off multi-threading by setting trainThreads to 1.
Beginning optimization
num vars: 6
improvement criterion: Mean Improvement
L1 regularization selected 5 of 6 weights.
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.0646405
Elapsed time: 00:00:00.0083991
OrderedDict([('(Bias)', -1.2366217374801636), ('spontaneous', 1.9391206502914429), ('induced', 0.7497404217720032), ('parity', -0.31517016887664795), ('age', -3.162723260174971e-06)])
Beginning processing data.
Rows Read: 62, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0287290
Finished writing 62 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: 0.001 seconds 
  isCase PredictedLabel     Score  Probability
0  False          False -1.341681     0.207234
1   True           True  0.597440     0.645070
2  False           True  0.544912     0.632954
3  False          False -1.289152     0.215996
4  False          False -1.019339     0.265156

Esempio di classificazione multiclasse

'''
MultiClass Classification
'''
import numpy
import pandas
from microsoftml import rx_logistic_regression, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

iris = get_dataset("iris")

import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

irisdf = iris.as_df()
irisdf["Species"] = irisdf["Species"].astype("category")
data_train, data_test, y_train, y_test = train_test_split(irisdf, irisdf.Species)

model = rx_logistic_regression(
    formula="  Species ~ Sepal_Length + Sepal_Width + Petal_Length + Petal_Width ",
    method="multiClass",
    data=data_train)

print(model.coef_)
    
# RuntimeError: The type (RxTextData) for file is not supported.
score_ds = rx_predict(model, data=data_test,
                     extra_vars_to_write=["Species", "Score"])
                     
# Print the first five rows
print(rx_data_step(score_ds, number_rows_read=5))

Output:

Automatically adding a MinMax normalization transform, use 'norm=Warn' or 'norm=No' to turn this behavior off.
Beginning processing data.
Rows Read: 112, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 112, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 112, Read Time: 0, Transform Time: 0
Beginning processing data.
LBFGS multi-threading will attempt to load dataset into memory. In case of out-of-memory issues, turn off multi-threading by setting trainThreads to 1.
Beginning optimization
num vars: 15
improvement criterion: Mean Improvement
L1 regularization selected 9 of 15 weights.
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.0493224
Elapsed time: 00:00:00.0080558
OrderedDict([('setosa+(Bias)', 2.074636697769165), ('versicolor+(Bias)', 0.4899507164955139), ('virginica+(Bias)', -2.564580202102661), ('setosa+Petal_Width', -2.8389241695404053), ('setosa+Petal_Length', -2.4824044704437256), ('setosa+Sepal_Width', 0.274869441986084), ('versicolor+Sepal_Width', -0.2645561397075653), ('virginica+Petal_Width', 2.6924400329589844), ('virginica+Petal_Length', 1.5976412296295166)])
Beginning processing data.
Rows Read: 38, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0331861
Finished writing 38 rows.
Writing completed.
Rows Read: 5, Total Rows Processed: 5, Total Chunk Time: 0.001 seconds 
      Species   Score.0   Score.1   Score.2
0   virginica  0.044230  0.364927  0.590843
1      setosa  0.767412  0.210586  0.022002
2      setosa  0.756523  0.221933  0.021543
3      setosa  0.767652  0.211191  0.021157
4  versicolor  0.116369  0.498615  0.385016