Monday , June 24 2019
Home / Uncategorized / Come creare una semplice rete neurale in Python

Come creare una semplice rete neurale in Python



Dal Dr. Michael J. Garbade

Le reti neurali (NN), chiamate anche reti neurali artificiali (ANN) sono un sottoinsieme di algoritmi di apprendimento all'interno del campo di apprendimento automatico che sono liberamente basati sul concetto di reti neurali biologiche.

Andrey Bulezyuk, che è uno specialista di apprendimento automatico basato sulla Germania con più di cinque anni di esperienza, afferma che "le reti neurali stanno rivoluzionando l'apprendimento automatico perché sono in grado di modellare in modo efficiente astrazioni sofisticate in una vasta gamma di discipline e industrie".

Fondamentalmente, una ANN comprende i seguenti componenti:

  • Un livello di input che riceve i dati e li trasmette
  • Uno strato nascosto
  • Un livello di output
  • Pesi tra gli strati
  • Una funzione di attivazione deliberata per ogni livello nascosto. In questa semplice esercitazione su Python della rete neurale, impiegheremo la funzione di attivazione Sigmoid.

Esistono diversi tipi di reti neurali. In questo progetto, creeremo le reti neurali feed-forward o perception. Questo tipo di RNA invia i dati direttamente dalla parte anteriore a quella posteriore.

La formazione dei neuroni feed-forward spesso ha bisogno di back-propagation, che fornisce alla rete il corrispondente set di input e output. Quando i dati di input vengono trasmessi al neurone, vengono elaborati e viene generata un'uscita.

Ecco un diagramma che mostra la struttura di una semplice rete neurale:

Semplice rete neurale

E, il modo migliore per capire come funzionano le reti neurali è imparare come costruirne uno da zero (senza usare alcuna libreria).

In questo articolo, dimostreremo come usare il linguaggio di programmazione Python per creare una semplice rete neurale.

Il problema

Ecco una tabella che mostra il problema.

IngressoProduzione
Dati di allenamento 10010
Dati di allenamento 21111
Dati di allenamento 31011
Dati di allenamento 40110
Nuova situazione100?

Stiamo addestrando la rete neurale in modo che possa prevedere il valore di uscita corretto quando viene fornito un nuovo set di dati.

Come puoi vedere sulla tabella, il valore dell'output è sempre uguale al primo valore nella sezione di input. Pertanto, ci aspettiamo che il valore dell'output (?) per essere 1.

Vediamo se possiamo usare del codice Python per dare lo stesso risultato (puoi leggere il codice per questo progetto alla fine di questo articolo prima di continuare con la lettura).

Creazione di una classe NeuralNetwork

Creeremo un Rete neurale classe in Python per addestrare il neurone a dare una previsione accurata. La classe avrà anche altre funzioni di supporto.

Anche se non useremo una libreria di rete neurale per questo semplice esempio di rete neurale, importeremo il numpy libreria per aiutare con i calcoli.

La libreria viene fornita con i seguenti quattro metodi importanti:

  1. exp-Per generare l'esponenziale naturale
  2. schieramento-Per generare una matrice
  3. punto-Per moltiplicare le matrici
  4. casuale-Per generare numeri casuali. Si noti che semineremo i numeri casuali per garantire la loro efficiente distribuzione.
  • Applicazione della funzione Sigmoid

Useremo la funzione Sigmoid, che disegna una curva caratteristica a forma di "S", come funzione di attivazione della rete neurale.

Funzione sigmoide

Questa funzione può mappare qualsiasi valore su un valore compreso tra 0 e 1. Ci aiuterà a normalizzare la somma ponderata degli input.

Successivamente, creeremo la derivata della funzione Sigmoid per aiutare a calcolare le regolazioni essenziali dei pesi.

L'output di una funzione Sigmoid può essere utilizzato per generare la sua derivata. Ad esempio, se la variabile di uscita è "x", la sua derivata sarà x * (1-x).

Questo è lo stadio in cui insegneremo alla rete neurale a fare una previsione accurata. Ogni input avrà un peso – positivo o negativo.

Ciò implica che un ingresso con un numero elevato di peso positivo o un numero elevato di pesi negativi influenzerà maggiormente l'uscita risultante.

Ricorda che inizialmente abbiamo iniziato assegnando ogni peso a un numero casuale.

Ecco la procedura per il processo di allenamento che abbiamo usato in questo esempio di esempio di rete neurale:

  1. Abbiamo preso gli input dal set di dati di addestramento, eseguito alcune regolazioni in base ai loro pesi e li abbiamo sottrattati tramite un metodo che ha calcolato l'output di ANN.
  2. Abbiamo calcolato il tasso di errore propagato alla schiena. In questo caso, è la differenza tra l'output previsto del neurone e l'output atteso del set di dati di training.
  3. In base all'entità dell'errore, abbiamo eseguito alcune piccole correzioni del peso utilizzando la formula Derivata ponderata dell'errore.
  4. Abbiamo iterato questo processo un numero arbitrario di 15.000 volte. In ogni iterazione, l'intero set di allenamento viene elaborato contemporaneamente.

Abbiamo usato la funzione ".T" per trasporre la matrice dalla posizione orizzontale alla posizione verticale. Pertanto, i numeri verranno memorizzati in questo modo:

Funzione T

In definitiva, i pesi del neurone saranno ottimizzati per i dati di allenamento forniti. Di conseguenza, se il neurone è costretto a pensare a una nuova situazione, che è la stessa di quella precedente, potrebbe fare una previsione accurata. Questo è il modo in cui avviene la back-propagation.

Avvolgendo

Infine, inizializzammo la classe NeuralNetwork e lanciammo il codice.

Ecco l'intero codice per questo come creare una rete neurale nel progetto Python:

 
importare numpy come np

classe Rete neurale():
    
    DEF __dentro__(se stesso):
        # semina per generazione di numeri casuali
        np.random.seed (1)
        
        # convertendo i pesi in una matrice 3 per 1 con valori da -1 a 1 e media di 0
        se stesso.synaptic_weights = 2 * np.random.random ((3, 1)) - 1

    DEF sigma (se stesso, X):
        #applicare la funzione sigmoid
        ritorno 1 / (1 + np.exp (-x))

    DEF sigmoid_derivative (se stesso, X):
        #computing derivativo alla funzione Sigmoid
        ritorno X * (1 - X)

    DEF treno(se stesso, training_inputs, training_outputs, training_iterations):
        
        #training the model per fare previsioni accurate mentre si regolano i pesi continuamente
        per iterazione in Gamma (training_iterations):
            #siphona i dati di allenamento tramite il neurone
            uscita = se stesso.think (training_inputs)

            #computing error rate per back-propagation
            errore = training_outputs - output
            
            #sostituire le regolazioni del peso
            adjustments = np.dot (training_inputs.T, errore * se stesso.sigmoid_derivative (output))

            se stesso.synaptic_weights + = aggiustamenti

    DEF pensare(se stesso, input):
        #passando gli input tramite il neurone per ottenere output   
        # convertendo valori in float
        
        input = inputs.astype (galleggiante)
        uscita = se stesso.sigmoid (np.dot (ingressi, se stesso.synaptic_weights))
        ritorno produzione


Se __name__ == "__principale__":

    #inizializzando la classe dei neuroni
    neural_network = Rete neurale()

    stampare("Inizio dei pesi generati in modo casuale:")
    stampare(neural_network.synaptic_weights)

    # dati di formazione composti da 4 esempi - 3 valori di input e 1 output
    training_inputs = np.array ([[[[0,0,1],[
                                [1,1,1],[
                                [1,0,1],[
                                [0,1,1]])

    training_outputs = np.array ([[[[0,1,1,0]]) .T

    #training in corso
    neural_network.train (training_inputs, training_outputs, 15000)

    stampare("Pesi finali dopo l'allenamento:")
    stampare(neural_network.synaptic_weights)

    user_input_one = str (input ("User Input One:"))
    user_input_two = str (input ("User Input Two:"))
    user_input_three = str (input ("User Input Three:"))
    
    stampare("Considerando la nuova situazione:", user_input_one, user_input_two, user_input_three)
    stampare("Nuovi dati di output:")
    stampare(Neural_network.think (np.array ([user_input_one, user_input_two, user_input_three])))
    stampare("Wow, ce l'abbiamo fatta!")

Ecco l'output per l'esecuzione del codice:

Uscita del codice

Siamo riusciti a creare una semplice rete neurale.

Il neurone ha iniziato assegnando alcuni pesi casuali. Successivamente, si è allenato utilizzando gli esempi di addestramento.

Di conseguenza, se è stata presentata una nuova situazione [1,0,0], ha dato il valore di 0,9999,54.

Ti ricordi che la risposta corretta che volevamo era 1?

Quindi, è molto vicino, considerando che la funzione Sigmoid emette valori compresi tra 0 e 1.

Naturalmente, abbiamo usato solo una rete di neuroni per svolgere il compito semplice. E se collegassimo diverse migliaia di queste reti neurali artificiali insieme? Potremmo forse imitare come funziona la mente umana al 100%?

Avete domande o commenti?

Si prega di fornire loro di seguito.

Bio: Dr. Michael J. Garbade è il fondatore e CEO della società di formazione blockchain di Los Angeles, LiveEdu. È la piattaforma leader a livello mondiale che fornisce alle persone competenze pratiche nella creazione di prodotti completi in settori tecnologici futuri, tra cui l'apprendimento automatico.

Relazionato:


Source link

Leave a Reply

Your email address will not be published.