Regressione lineare utilizzando il metodo della discesa graduale [spiegato con un esempio di codifica]

L'apprendimento automatico sta ancora facendo il giro, indipendentemente dal fatto che tu aspiri a diventare uno sviluppatore di software, uno scienziato di dati o un analista di dati. Per fare seri sforzi nella regressione lineare, devi essere esperto di Python. Iniziare una fase iniziale potrebbe essere un compito noioso, questo articolo ti aiuterà a comprendere più a fondo la regressione.

Il metodo di discesa del gradiente viene scelto in varie iterazioni a causa delle tecniche di ottimizzazione che ha da offrire. Con l'algoritmo, è possibile ridurre le dimensioni, ad esempio la regressione logistica e la rete neurale. Prima di iniziare con il gradiente, diamo un'occhiata alla regressione lineare.

Leggi: Algoritmi di apprendimento automatico per la scienza dei dati

Che cos'è la regressione lineare?

È l'approccio lineare che viene adottato per la modellizzazione della relazione tra una variabile dipendente e una o più variabili indipendenti. La relazione lineare tra tali variabili sarebbe espressa nel formato dell'equazione ay= mx+b.

È un algoritmo di apprendimento automatico monitorato che migliorerà la sua curva di apprendimento da una data variabile dipendente x e y come l'altra responsabile della causa di un effetto. Questa natura aiuta a prevedere i valori e i fattori di certezza per xey.

Cos'è la discesa graduale?

L'uso della regressione del gradiente comporta l'ottimizzazione dell'algoritmo utilizzato per trovare i valori dei parametri richiesti di una funzione che consente di minimizzare direttamente il costo di una funzione.

Cerchiamo di capire il concetto con uno scenario, immagina di voler discendere un forte in un ambiente buio pesto. Durante questo, assumiamo che tu sia completamente handicappato e che sia necessario trovare la distanza più breve e più facile per tornare giù. La discesa del gradiente sarà la risorsa utilizzata per scoprire il modo ottimizzato per raggiungere la tua destinazione. Con un input direzionale di base, l'algoritmo sarebbe in grado di tracciare e suggerire il percorso migliore.

Il gradiente è uno degli algoritmi più utilizzati e ampiamente accettati nell'apprendimento automatico, inoltre si ritiene che getti le basi per padroneggiare l'apprendimento automatico nelle fasi precedenti.

Per una migliore approssimazione del gradiente proviamo ad implementarlo con un codice in un esempio, lavorando su python con l'aiuto di NumPy.

dall'importazione NumPy *

# y = mx + b

# m è la pendenza, b è l'intercetta y

def compute_error_for_line_given_points(b, m, points):

errore totale = 0

for i in range(0, len(punti)):

x = punti[i, 0]

y = punti[i, 1]

totalError += (y – (m * x + b)) ** 2

return totalError / float(len(punti))

def step_gradient(b_current, m_current, points, learningRate):

b_gradiente = 0

m_gradiente = 0

N = float(len(punti))

for i in range(0, len(punti)):

x = punti[i, 0]

y = punti[i, 1]

b_gradiente += -(2/N) * (y – ((m_corrente * x) + b_corrente))

m_gradiente += -(2/N) * x * (y – ((m_corrente * x) + b_corrente))

new_b = b_current – ​​(learningRate * b_gradient)

new_m = m_current – ​​(learningRate * m_gradient)

ritorno [nuovo_b, nuovo_m]

def gradient_descent_runner(punti, partenza_b, partenza_m, learning_rate, num_iterazioni):

b = inizio_b

m = inizio_m

for i in range(num_iterazioni):

b, m = step_gradient(b, m, array(punti), learning_rate)

ritorno [b, m]

def run():

punti = genfromtxt(“data.csv”, delimitatore=”,”)

learning_rate = 0,0001

initial_b = 0 # ipotesi di intercetta y iniziale

initial_m = 0 # ipotesi di pendenza iniziale

num_iterazioni = 1000

print "Inizio discesa pendenza a b = {0}, m = {1}, errore = {2}".format(initial_b, initial_m, compute_error_for_line_given_points(initial_b, initial_m, points))

stampa "In esecuzione..."

[b, m] = gradient_descent_runner(punti, initial_b, initial_m, learning_rate, num_iterations)

print "Dopo {0} iterazioni b = {1}, m = {2}, errore = {3}".format(num_iterations, b, m, compute_error_for_line_given_points(b, m, points))

if __name__ == '__main__':

correre()

Riferimento codice

Questa è una rappresentazione visiva del programma di ricerca del gradiente in cui i problemi vengono risolti nella regressione lineare tracciando i punti su un'unica linea. Il codice è una dimostrazione di come funziona e aiuta a impostare più punti lungo una linea. La discesa del gradiente tenta di trovare i valori migliori per questi parametri relativi a una funzione di errore.

Il codice contiene una funzione particolare denominata 'run'. Aiuta a definire una serie di parametri utilizzati nell'algoritmo per fare una serie iniziale di previsioni basate sul comportamento delle variabili e sulla pendenza della linea. Gli altri fattori riguardano il numero di iterazioni necessarie per ottenere la discesa del gradiente nel formato mostrato di seguito:

initial_b = 0 # ipotesi di intercetta y iniziale

initial_m = 0 # ipotesi di pendenza iniziale

num_iterazioni = 1000

Puoi facilmente capire che il metodo Gradient è abbastanza semplice e diretto. Una volta comprese le sue capacità di funzionamento, l'unica parte su cui devi concentrarti è il costo della funzione che sei interessato a ottimizzare.

L'obiettivo è fare sforzi continui per fare diverse iterazioni per ciascuno dei valori delle variabili, per valutarne i costi e per creare nuove variabili che avviino un costo migliore e basso nel programma.

Da leggere: Domande sull'intervista sull'apprendimento automatico

Suggerimenti per la discesa graduale

1. Tasso di apprendimento

Il protocollo di ottimizzazione aiuta a ridurre il valore della velocità di apprendimento anche con decimali più piccoli, provare a mescolare diversi valori adatti alla piattaforma e quindi optare per il miglior valore di lavoro. L'apprendimento può essere molto più veloce e fruttuoso, per farlo assicurati di limitare il numero di passaggi attraverso ciascun set di dati. Il numero ideale sarebbe compreso tra 1 e 10.

2. Costo medio della trama

Il tempo di addestramento per ciascuna istanza del set di dati può causare un ritardo a causa del tempo aggiuntivo impiegato durante l'esecuzione dell'algoritmo. Per risultati migliori, scegli la media su 100 o 1000 per maggiori probabilità di trovare una migliore tendenza di apprendimento per l'algoritmo.

Sommario

In questo articolo hai imparato a conoscere il gradiente e come creare un tale algoritmo, questo aiuta a fare previsioni precise e più efficaci con un modello di regressione appreso. Per comprendere a un livello molto completo e più approfondito gli scenari di casi reali, iscriviti a upGrad. Offriamo corsi curati appositamente strutturati per aspiranti Data Scientist e candidati di Machine Learning.