Rete neurale nell'esempio di codice Python. Impara le reti neurali in quattro passaggi

Programmazione

• Traduzione

Di cosa parla l'articolo

Personalmente, imparo meglio con un piccolo codice funzionante con cui posso giocare. In questo tutorial impareremo l'algoritmo di backpropagation usando una piccola rete neurale implementata in Python come esempio.

Dammi il codice!

X = np.array([ ,,, ]) y = np.array([]).T syn0 = 2*np.random.random((3,4)) - 1 syn1 = 2*np.random.random ((4,1)) - 1 per j in xrange(60000): l1 = 1/(1+np.exp(-(np.dot(X,syn0))))) l2 = 1/(1+np. exp(-(np.dot(l1,syn1)))) l2_delta = (y - l2)*(l2*(1-l2)) l1_delta = l2_delta.dot(syn1.T) * (l1 * (1-l1 )) syn1 += l1.T.dot(l2_delta) syn0 += X.T.dot(l1_delta)

Troppo conciso? Dividiamolo in parti più semplici.

Parte 1: una piccola rete neurale giocattolo

Una rete neurale addestrata tramite backpropagation tenta di utilizzare l'input per prevedere l'output.

Supponiamo di dover prevedere come apparirà la colonna "output" in base ai dati di input. Questo problema potrebbe essere risolto calcolando la corrispondenza statistica tra di loro. E vedremmo che la colonna di sinistra è correlata al 100% con l'output.

La backpropagation, nella sua forma più semplice, calcola statistiche simili per creare un modello. Proviamo.

Rete neurale a due strati

import numpy as np # Sigmoid def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x )) # set di dati di input X = np.array([ , , , ]) # dati di output y = np.array([]).T # rende i numeri casuali più specifici np.random.seed(1) # inizializza i pesi su media casuale 0 syn0 = 2*np.random.random((3,1)) - 1 per iter in xrange(10000): # propagazione in avanti l0 = X l1 = nonlin(np.dot(l0,syn0)) # come abbiamo sbagliato? l1_error = y - l1 # moltiplicalo per la pendenza sigmoidea # in base ai valori in l1 l1_delta = l1_error * nonlin(l1,True) # !!! # aggiorna i pesi syn0 += np.dot(l0.T,l1_delta) # !!! print "Risultato dopo l'allenamento:" print l1

Output post-formazione: [[ 0.00966449] [ 0.00786506] [ 0.99358898] [ 0.99211957]]

Variabili e loro descrizioni.

"*" - moltiplicazione per elemento - due vettori della stessa dimensione moltiplicano i valori corrispondenti e l'output è un vettore della stessa dimensione
"-" – sottrazione elemento per elemento dei vettori
x.dot(y) - se xey sono vettori, l'output sarà un prodotto scalare. Se queste sono matrici, otteniamo la moltiplicazione di matrici. Se la matrice è solo una di queste, questa è la moltiplicazione di un vettore e di una matrice.

• confronta l1 dopo la prima iterazione e dopo l'ultima
• guarda la funzione nonlin.
• guarda come cambia l1_error
• parse line 36 - i principali ingredienti segreti sono raccolti qui (contrassegnati!!!)
• parse line 39 - l'intera rete si sta preparando per questa particolare operazione (contrassegnata !!!)

Analizziamo il codice riga per riga

importa numpy come np

Importa numpy, una libreria di algebra lineare. La nostra unica dipendenza.

Def nonlin(x,deriv=False):

La nostra non linearità. Questa particolare funzione crea un "sigmoide". Mappa qualsiasi numero su un valore compreso tra 0 e 1 e converte i numeri in probabilità e ha molte altre proprietà utili per addestrare le reti neurali.

Se(deriv==Vero):

Questa funzione può anche restituire la derivata del sigmoide (deriv=True). Questa è una delle sue proprietà utili. Se l'output della funzione è la variabile out, la derivata sarà out * (1-out). Efficace.

X = np.array([ , ...

Inizializzazione dell'array di dati di input come matrice numpy. Ogni riga è un esempio di formazione. Le colonne sono i nodi di input. Otteniamo 3 nodi di input nella rete e 4 esempi di addestramento.

Y = np.array([]).T

Inizializza l'output. ".T" – funzione di trasferimento. Dopo la traduzione, la matrice y ha 4 righe con una colonna. Come per i dati di input, ogni riga è un esempio di addestramento e ogni colonna (una nel nostro caso) è un nodo di output. La rete, si scopre, ha 3 ingressi e 1 uscita.

np.seme.casuale(1)

Per questo motivo, la distribuzione casuale sarà sempre la stessa. Questo ci consentirà di monitorare più facilmente le prestazioni della rete dopo aver apportato modifiche al codice.

Syn0 = 2*np.random.random((3,1)) - 1

Matrice del peso della rete. syn0 significa "sinapsi zero". Poiché abbiamo solo due livelli, input e output, abbiamo bisogno di una matrice di peso che li colleghi. La sua dimensione è (3, 1) poiché abbiamo 3 input e 1 output. In altre parole, l0 ha dimensione 3 e l1 ha dimensione 1. Poiché stiamo collegando tutti i nodi in l0 a tutti i nodi in l1, abbiamo bisogno di una matrice di dimensione (3, 1).

Si noti che viene inizializzato in modo casuale e la media è zero. C'è una teoria piuttosto complessa dietro questo. Per ora, lo prenderemo solo come una raccomandazione. Nota anche che la nostra rete neurale è proprio questa matrice. Abbiamo "strati" l0 e l1, ma sono valori temporanei basati sul set di dati. Non li conserviamo. Tutto l'allenamento è memorizzato in syn0.

Per iter in xrange(10000):

È qui che inizia il codice di formazione della rete principale. Il ciclo con il codice viene ripetuto più volte e ottimizza la rete per il set di dati.

Il primo livello, l0, è solo di dati. X contiene 4 esempi di addestramento. Li elaboreremo tutti in una volta - questo si chiama allenamento di gruppo. In totale, abbiamo 4 diverse stringhe l0, ma possono essere considerate come un esempio di addestramento - in questa fase non importa (era possibile caricarne 1000 o 10000 senza alcuna modifica nel codice).

L1 = nonlin(np.dot(l0,syn0))

Questo è il passo predittivo. Lasciamo che la rete provi a prevedere l'output in base all'input. Quindi vedremo come lo fa in modo da poterlo modificare nella direzione del miglioramento.

La linea contiene due passaggi. Il primo esegue la moltiplicazione di matrici di l0 e syn0. Il secondo fa passare l'output attraverso il sigmoide. Le loro dimensioni sono le seguenti:

(4 x 3) punto (3 x 1) = (4 x 1)

Le moltiplicazioni di matrici richiedono che le dimensioni corrispondano a metà dell'equazione. La matrice risultante ha lo stesso numero di righe della prima e lo stesso numero di colonne della seconda.

Abbiamo caricato 4 esempi di allenamento e ottenuto 4 ipotesi (matrice 4x1). Ogni output corrisponde all'ipotesi della rete per l'input specificato.

Errore_L1 = y - l1

Poiché l1 contiene ipotesi, possiamo confrontare la loro differenza con la realtà sottraendo l1 dalla risposta corretta y. l1_error è un vettore di numeri positivi e negativi che caratterizza la “miss” della rete.

Ed ecco l'ingrediente segreto. Questa riga deve essere analizzata in parti.

Prima parte: derivata

Non linea(l1,Vero)

L1 rappresenta questi tre punti e il codice restituisce la pendenza delle linee mostrate di seguito. Si noti che a valori grandi come x=2.0 (punto verde) e valori molto piccoli come x=-1.0 (viola) le linee hanno una leggera pendenza. L'angolo più grande è nel punto x=0 (blu). Questo è di grande importanza. Si noti inoltre che tutte le derivate sono comprese tra 0 e 1.

Espressione completa: derivata ponderata per l'errore

L1_delta = l1_error * nonlin(l1,True)

Matematicamente, ci sono modi più accurati, ma nel nostro caso è adatto anche questo. l1_error è una matrice (4,1). nonlin(l1,True) restituisce la matrice (4,1). Qui li moltiplichiamo elemento per elemento e in output otteniamo anche la matrice (4,1), l1_delta.

Moltiplicando le derivate per gli errori, riduciamo gli errori delle previsioni fatte con alta confidenza. Se la pendenza della linea era piccola, la rete contiene un valore molto grande o molto piccolo. Se l'ipotesi nella rete è vicina a zero (x=0, y=0,5), non è particolarmente sicura. Aggiorniamo queste previsioni incerte e lasciamo da sole le previsioni ad alta confidenza moltiplicandole per valori vicini allo zero.

Syn0 += np.punto(l0.T,l1_delta)

Siamo pronti per aggiornare la rete. Consideriamo un esempio di formazione. In esso, aggiorneremo i pesi. Aggiorna il peso più a sinistra (9.5)

aggiornamento_peso = valore_input * l1_delta

Per il peso più a sinistra, questo sarebbe 1,0 * l1_delta. Presumibilmente questo aumenterà solo marginalmente 9,5. Come mai? Perché la previsione era già abbastanza sicura e le previsioni erano praticamente corrette. Un piccolo errore e una leggera pendenza della linea significano un aggiornamento molto piccolo.

Ma poiché stiamo facendo un allenamento di gruppo, ripetiamo il passaggio precedente per tutti e quattro gli esempi di allenamento. Quindi sembra molto simile all'immagine sopra. Allora cosa fa la nostra linea? Conta gli aggiornamenti di peso per ogni peso, per ogni esempio di allenamento, li riassume e aggiorna tutti i pesi, tutto su una riga.

Dopo aver osservato l'aggiornamento della rete, torniamo ai nostri dati di allenamento. Quando sia l'input che l'output sono 1, aumentiamo il peso tra di loro. Quando l'input è 1 e l'output è 0, riduciamo il peso.

Ingresso Uscita 0 0 1 0 1 1 1 1 1 0 1 1 0 1 1 0

Pertanto, nei nostri quattro esempi di addestramento di seguito, il peso del primo input relativo all'output aumenterà costantemente o rimarrà costante e gli altri due pesi aumenteranno e diminuiranno a seconda degli esempi. Questo effetto contribuisce all'apprendimento della rete basato sulle correlazioni dei dati di input e output.

Parte 2: il compito è più difficile

Ingresso Uscita 0 0 1 0 0 1 1 1 1 0 1 1 1 1 1 0

Proviamo a prevedere i dati di output in base a tre colonne di dati di input. Nessuna delle colonne di input è correlata al 100% con l'output. La terza colonna non è correlata a nulla, poiché ne contiene fino in fondo. Tuttavia, qui puoi anche vedere lo schema: se una delle prime due colonne (ma non entrambe contemporaneamente) contiene 1, anche il risultato sarà 1.

Questo è uno schema non lineare perché non c'è corrispondenza uno-a-uno diretta tra le colonne. La corrispondenza si basa su una combinazione di dati di input, colonne 1 e 2.

È interessante notare che il riconoscimento del modello è un compito molto simile. Se disponi di 100 immagini di biciclette e pipe di dimensioni uguali, la presenza di determinati pixel in determinati punti non è direttamente correlata alla presenza di una bicicletta o di una pipa nell'immagine. Statisticamente, il loro colore può sembrare casuale. Ma alcune combinazioni di pixel non sono casuali, quelle che formano l'immagine di una bicicletta (o tubo).

Strategia

Per combinare i pixel in qualcosa che può avere una corrispondenza uno a uno con l'output, è necessario aggiungere un altro livello. Il primo livello combina l'input, il secondo assegna una corrispondenza all'output utilizzando l'output del primo livello come input. Presta attenzione alla tavola.

Ingresso (l0) Pesi nascosti (l1) Uscita (l2) 0 0 1 0.1 0.2 0.5 0.2 0 0 1 1 0.2 0.6 0.7 0.1 1 1 0 1 0.3 0.2 0.3 0.9 1 1 1 1 0.2 0.1 0.3 0.8 0

Assegnando casualmente i pesi, otteniamo valori nascosti per il livello n. 1. È interessante notare che la seconda colonna dei pesi nascosti ha già una piccola correlazione con l'output. Non è l'ideale, ma c'è. E questa è anche una parte importante del processo di formazione della rete. La formazione rafforzerà solo questa correlazione. Aggiornerà syn1 per farlo corrispondere all'output e syn0 per ottenere meglio l'input.

Rete neurale a tre strati

import numpy as np def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x)) X = np.array([, , , ]) y = np.array([, , , ]) np.random.seed(1) # randomizza pesi, media 0 syn0 = 2*np.random.random ((3 ,4)) - 1 syn1 = 2*np.random.random((4,1)) - 1 for j in xrange(60000): # vai avanti attraverso i livelli 0, 1 e 2 l0 = X l1 = nonlin(np .dot(l0,syn0)) l2 = nonlin(np.dot(l1,syn1)) # quanto ci sbagliamo sul valore desiderato? l2_error = y - l2 if (j% 10000) == 0: print "Error:" + str(np.mean(np.abs(l2_error))) # da che parte dobbiamo muoverci? # se fossimo fiduciosi nella previsione, allora non abbiamo bisogno di cambiarla molto l2_delta = l2_error*nonlin(l2,deriv=True) # quanto i valori di l1 influiscono sugli errori in l2? l1_error = l2_delta.dot(syn1.T) # in quale direzione dobbiamo muoverci per arrivare a l1? # se fossimo fiduciosi nella previsione, non è necessario cambiarla molto l1_delta = l1_error * nonlin(l1,deriv=True) syn1 += l1.T.dot(l2_delta) syn0 += l0.T.dot( l1_delta)

Errore:0.496410031903 Errore:0.00858452565325 Errore:0.00578945986251 Errore:0.00462917677677

Variabili e loro descrizioni

X è la matrice del set di dati di input; stringhe - esempi di formazione
y è la matrice del dataset di output; stringhe - esempi di formazione
l0 è il primo livello della rete definito dai dati di input
l1 - il secondo livello della rete, o livello nascosto
l2 è lo strato finale, questa è la nostra ipotesi. Mentre ti eserciti, dovresti avvicinarti alla risposta corretta.
syn0 - il primo livello di pesi, Synapse 0, combina l0 con l1.
syn1 - il secondo livello di pesi, Synapse 1, combina l1 con l2.
l2_error - mancanza di rete in termini quantitativi
l2_delta è l'errore di rete, a seconda della certezza della previsione. Quasi identico all'errore, fatta eccezione per forti previsioni
l1_error - ponderando l2_delta con i pesi di syn1, calcoliamo l'errore nel livello intermedio/nascosto
l1_delta - errori di rete da l1, scalati in base alla confidenza della previsione. Quasi uguale a l1_error, a parte certe previsioni

Il codice dovrebbe essere abbastanza autoesplicativo: è solo l'implementazione precedente della rete, impilata in due strati, uno sopra l'altro. L'output del primo strato l1 è l'input del secondo strato. C'è qualcosa di nuovo solo nella riga successiva.

Errore_L1 = l2_delta.dot(syn1.T)

Utilizza gli errori ponderati per la confidenza delle previsioni da l2 per calcolare l'errore per l1. Otteniamo, si potrebbe dire, un errore ponderato per i contributi: calcoliamo quale contributo agli errori in l2 è dato dai valori ai nodi l1. Questo passaggio è chiamato backpropagation. Quindi aggiorniamo syn0 usando lo stesso algoritmo della rete neurale a due strati.

Stiamo vivendo un vero boom delle reti neurali. Sono utilizzati per il riconoscimento, la localizzazione e l'elaborazione delle immagini. Le reti neurali sono già in grado di fare molte cose che non sono disponibili per gli esseri umani. Dobbiamo metterci in questo business! Considera una rete di neutroni che riconoscerà i numeri in un'immagine di input. Tutto è molto semplice: solo un livello e una funzione di attivazione. Questo non ci consentirà di riconoscere assolutamente tutte le immagini di prova, ma possiamo gestirne la stragrande maggioranza. Come dati, utilizzeremo la famosa raccolta di dati MNIST nel mondo del riconoscimento dei numeri.

Per lavorarci, Python ha la libreria python-mnist. Installare:

Pip installa python-mnist

Ora possiamo caricare i dati

From mnist import MNIST mndata = MNIST("/path_to_mnist_data_folder/") tr_images, tr_labels = mndata.load_training() test_images, test_labels = mndata.load_testing()

È necessario caricare gli archivi con i dati da soli e specificare il percorso della directory con essi nel programma. Ora le variabili tr_images e test_images contengono immagini rispettivamente per l'addestramento e il test di rete. E le variabili tr_labels e test_labels sono etichette con la classificazione corretta (cioè i numeri dalle immagini). Tutte le immagini sono di dimensioni 28x28. Impostiamo una variabile con la dimensione.

img_shape = (28, 28)

Convertiamo tutti i dati in array numpy e normalizziamoli (portandoli a una dimensione da -1 a 1). Ciò aumenterà la precisione dei calcoli.

Importa numpy come np per i in range(0, len(test_images)): test_images[i] = np.array(test_images[i]) / 255 per i in range(0, len(tr_images)): tr_images[i] = np.array(tr_images[i]) / 255

Noto che sebbene sia consuetudine rappresentare le immagini come un array bidimensionale, ne useremo uno unidimensionale, è più facile per i calcoli. Ora devi capire "cos'è una rete neurale"! E questa è solo un'equazione con molti coefficienti. Abbiamo in input un array di 28*28=784 elementi e altri 784 pesi per determinare ogni cifra. Durante il funzionamento della rete neurale, è necessario moltiplicare i valori degli input per i pesi. Somma i dati ricevuti e aggiungi un offset. Invia il risultato alla funzione di attivazione. Nel nostro caso sarà Relu. Questa funzione è zero per tutti gli argomenti negativi e un argomento per tutti quelli positivi.

Ci sono molte altre funzioni di attivazione! Ma questa è la rete neurale più semplice! Definisci questa funzione con numpy

Def relu(x): return np.maximum(x, 0)

Ora, per calcolare l'immagine nell'immagine, devi calcolare il risultato per 10 serie di coefficienti.

Def nn_calculate(img): resp = list(range(0, 10)) for i in range(0,10): r = w[:, i] * img r = relu(np.sum(r) + b[ i]) resp[i] = r return np.argmax(resp)

Per ogni set, otterremo un risultato di output. L'uscita con il risultato più alto è molto probabilmente il nostro numero.

In questo caso, 7. Questo è tutto! Ma no ... Dopotutto, devi prendere questi stessi coefficienti da qualche parte. Dobbiamo addestrare la nostra rete neurale. Per questo, viene utilizzato il metodo di backpropagation. La sua essenza è calcolare le uscite della rete, confrontarle con quelle corrette e quindi sottrarre dai coefficienti i numeri necessari affinché il risultato sia corretto. Si ricorda che per calcolare questi valori è necessaria la derivata della funzione di attivazione. Nel nostro caso è uguale a zero per tutti i numeri negativi e 1 per tutti quelli positivi. Determiniamo i coefficienti in modo casuale.

W = (2*np.random.rand(10, 784) - 1) / 10 b = (2*np.random.rand(10) - 1) / 10 per n nell'intervallo(len(tr_images)): img = tr_images[n] cls = tr_labels[n] #propagazione in avanti resp = np.zeros(10, dtype=np.float32) for i in range(0,10): r = w[i] * img r = relu( np.sum(r) + b[i]) resp[i] = r resp_cls = np.argmax(resp) resp = np.zeros(10, dtype=np.float32) resp = 1.0 #back propagation true_resp = np. zeros(10, dtype=np.float32) true_resp = 1.0 errore = resp - true_resp delta = errore * ((resp >= 0) * np.ones(10)) for i in range(0,10): w[i ] -= np.dot(img, delta[i]) b[i] -= delta[i]

Nel processo di apprendimento, i coefficienti diventeranno leggermente simili ai numeri:

Verifichiamo la precisione del lavoro:

Def nn_calculate(img): resp = list(range(0, 10)) for i in range(0,10): r = w[i] * img r = np.maximum(np.sum(r) + b[ i], 0) #relu resp[i] = r return np.argmax(resp) total = len(test_images) valido = 0 non valido = for i in range(0, total): img = test_images[i] previsto = nn_calculate (img) true = test_labels[i] se previsto == true: valid = valido + 1 else: invalid.append(("image":img, "predicted":predicted, "true":true)) print("accuratezza ()".format(valido/totale))

Ho ottenuto l'88%. Non così bello, ma molto interessante!

Cherasè una popolare libreria di deep learning che ha dato un grande contributo alla commercializzazione del deep learning. La libreria Keras è facile da usare e permette di creare reti neurali con poche righe di codice Python.

In questo articolo imparerai come utilizzare Keras per creare una rete neurale che prevede le valutazioni degli utenti di un prodotto in base alle loro recensioni, classificandolo in due categorie: positiva o negativa. Questo compito è chiamato analisi del sentimento (analisi del sentimento) e lo risolveremo con il sito di recensioni di film IMDb. Il modello che costruiamo può essere applicato anche ad altri problemi con piccole modifiche.

Tieni presente che non entreremo nei dettagli di Keras e del deep learning. Questo post ha lo scopo di fornire uno schema in Keras e introdurti alla sua implementazione.

• Cos'è Keras?
• Che cos'è l'analisi del sentimento?
• set di dati IMDB
• Esplorazione dei dati
• Preparazione dei dati
• Costruire e addestrare il modello

Cos'è Keras?

Keras è una libreria Python open source che semplifica la creazione di reti neurali. La libreria è compatibile con Microsoft Cognitive Toolkit, Theano e MXNet. Tensorflow e Theano sono i framework numerici Python più comunemente usati per lo sviluppo di algoritmi di deep learning, ma sono piuttosto difficili da usare.

Valuta la popolarità dei framework di apprendimento automatico in 7 categorie

Keras, d'altra parte, fornisce un modo semplice e conveniente per costruire modelli di deep learning. Il suo creatore, François Chollet, lo ha progettato per rendere il processo di costruzione delle reti neurali il più semplice e veloce possibile. Si è concentrato su estensibilità, modularità, minimalismo e supporto Python. Keras può essere utilizzato con GPU e CPU; supporta sia Python 2 che Python 3. Keras di Google ha dato un grande contributo alla commercializzazione del deep learning e perché contiene algoritmi di deep learning all'avanguardia che in precedenza non solo erano non solo disponibili ma anche inutilizzabili.

Che cos'è l'analisi del sentimento (analisi del sentimento)?

Con l'aiuto dell'analisi del sentimento, è possibile determinare l'atteggiamento (ad esempio, l'umore) di una persona nei confronti di un testo, un'interazione o un evento. Pertanto, l'analisi del sentimento appartiene al campo dell'elaborazione del linguaggio naturale, in cui il significato di un testo deve essere decifrato per estrarne sentimento e sentimento.

Esempio di scala di analisi del sentimento

Lo spettro degli stati d'animo è solitamente suddiviso in positivo, negativo e neutro categorie. Utilizzando l'analisi del sentiment, puoi, ad esempio, prevedere le opinioni e gli atteggiamenti dei clienti su un prodotto in base alle loro recensioni. Pertanto, l'analisi del sentimento è ampiamente applicata a sondaggi, sondaggi, testi e altro ancora.

set di dati IMDb

Recensioni su IMDb

Il set di dati IMDb è composto da 50.000 recensioni degli utenti di film, contrassegnati come positivi (1) e negativi (0).

• Le recensioni sono pre-elaborate e ognuna è codificata da una sequenza di indici di parole come numeri interi.
• Le parole nelle recensioni sono indicizzate in base alla loro frequenza complessiva di occorrenza nel set di dati. Ad esempio, l'intero "2" codifica la seconda parola più utilizzata.
• Le 50.000 revisioni sono divise in due set: 25.000 per la formazione e 25.000 per i test.

Il set di dati è stato creato dai ricercatori della Stanford University e presentato in un documento del 2011, in cui l'accuratezza della previsione raggiunta era dell'88,89%. Il set di dati è stato utilizzato anche come parte del Keggle Community Contest "Il sacco di parole incontra i sacchetti di popcorn" nel 2011.

Importa dipendenze e ottieni dati

Iniziamo importando le dipendenze necessarie per la preelaborazione dei dati e la costruzione del modello.

%matplotlib inline import matplotlib import matplotlib.pyplot come plt import numpy come np da keras.utils import to_categorical da keras import modelli da keras import layer

Scarichiamo il set di dati IMDb, che è già integrato in Keras. Dal momento che non vogliamo avere dati di addestramento e test in un rapporto 50/50, uniremo immediatamente questi dati dopo il caricamento per una successiva suddivisione. in proporzione 80/20:

Da keras.datasets import imdb (training_data, training_targets), (testing_data, testing_targets) = imdb.load_data(num_words=10000) data = np.concatenate((training_data, testing_data), axis=0) target = np.concatenate((training_targets , test_obiettivi), asse=0)

Esplorazione dei dati

Esaminiamo il nostro set di dati:

Print("Categorie:", np.unique(obiettivi)) print("Numero di parole univoche:", len(np.unique(np.hstack(data)))) Categorie: Numero di parole univoche: 9998 length = print ("Lunghezza media revisione:", np.mean(lunghezza)) print("Deviazione standard:", round(np.std(lunghezza))) Lunghezza media revisione: 234,75892 Deviazione standard: 173,0

Si può notare che tutti i dati appartengono a due categorie: 0 o 1, che rappresenta il mood della recensione. L'intero set di dati contiene 9998 parole univoche, la dimensione media della recensione è di 234 parole con una deviazione standard di 173.

Considera un modo semplice per imparare:

Print("Etichetta:", obiettivi) Etichetta: 1 print(dati)

Qui puoi vedere la prima recensione del set di dati, che è contrassegnata come positiva (1). Il codice seguente converte gli indici in parole in modo che possiamo leggerli. In esso, ogni parola sconosciuta è sostituita da "#". Questo viene fatto usando la funzione get_word_index().

Index = imdb.get_word_index() reverse_index = dict([(valore, chiave) for (chiave, valore) in index.items()]) decodificato = " ".join() print(decodificato) # questo film è stato semplicemente un casting eccezionale location scenario regia della storia tutti sono davvero adatti alla parte che hanno interpretato e puoi semplicemente immaginare di essere lì robert # è un attore straordinario e ora lo stesso essere il regista # padre proveniva dalla mia stessa isola scozzese, quindi ho adorato il fatto che ci fosse un collegamento reale con questo film le osservazioni spiritose durante il film sono state fantastiche è stato semplicemente fantastico così tanto che ho comprato il film non appena è uscito per # e lo consiglierei a tutti di guardarlo e la pesca a mosca è stata incredibile ho davvero pianto al alla fine è stato così triste e sai cosa si dice se piangi per un film deve essere stato bello e questo sicuramente era anche # per i due ragazzini che interpretavano il # di Norman e Paul erano solo bambini brillanti sono spesso lasciato fuori dalla lista # penso perché le stelle che li interpretano sono tutte gro wn up sono un profilo così grande per l'intero film, ma questi bambini sono fantastici e dovrebbero essere elogiati per quello che hanno fatto non pensi che l'intera storia fosse così bella perché era vera ed era la vita di qualcuno dopo tutto ciò con cui è stata condivisa tutti noi

Preparazione dei dati

È il momento di preparare i dati. Dobbiamo vettorializzare ogni recensione e riempirla di zeri in modo che il vettore contenga esattamente 10.000 numeri. Ciò significa che ogni recensione inferiore a 10.000 parole viene riempita con zeri. Questo perché la vista più grande ha quasi le stesse dimensioni e ogni elemento dell'input della nostra rete neurale deve avere le stesse dimensioni. Devi anche convertire le variabili per digitare galleggiante.

Def vectorize(sequences, dimension = 10000): results = np.zeros((len(sequences), dimension)) per i, sequenza in enumerate(sequences): results = 1 restituisce risultati data = vectorize(data) target = np. array(target).astype("float32")

Dividiamo il set di dati in set di training e test. Il set di formazione sarà composto da 40.000 revisioni e il set di test sarà composto da 10.000.

test_x = dati[:10000] test_y = obiettivi[:10000] treno_x = dati treno_y = obiettivi

Costruire e addestrare il modello

Ora puoi creare una semplice rete neurale. Iniziamo definendo il tipo di modello che vogliamo creare. Ci sono due tipi di modelli disponibili in Keras: sequenziale e con API funzionale.

Quindi è necessario aggiungere livelli di input, nascosti e di output. Per evitare l'overfitting, utilizzeremo un'eccezione tra di loro ( buttare fuori). Tieni presente che dovresti sempre utilizzare un tasso di esclusione compreso tra il 20% e il 50%. Ogni livello ha una funzione "denso" per collegare completamente gli strati tra loro. Nei livelli nascosti useremo "relu", quindi porta quasi sempre a risultati soddisfacenti. Sentiti libero di sperimentare altre funzioni di attivazione. Sul livello di output, utilizziamo una funzione sigmoide che rinormalizza i valori nell'intervallo da 0 a 1. Si noti che impostiamo la dimensione degli elementi di input del set di dati su 10.000 perché le nostre viste hanno una dimensione massima di 10.000 interi. Il livello di input accetta elementi con una dimensione di 10.000 e output con una dimensione di 50.

Infine, lascia che Keras produca una breve descrizione del modello che abbiamo appena creato.

# Input - Layer model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Nascosto - Layers model.add(layers.Dropout(0.3, noise_shape=None, seed=None) ) model.add(layers.Dense(50, activation = "relu") model.add(layers.Dropout(0.2, noise_shape=Nessuno, seed=None)) model.add(layers.Dense(50, activation = "relu ")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid"))model.summary() model.summary() ________________________________________________________________________________ Layer (tipo) Output Shape Param # ======= =========================================================================== 0 0 ________________________________________________________________ denso_3 (denso ) (nessuno, 50) 2550 _________________________________________________________________ denso_4 (denso) (nessuno, 1) 51 ================================== ================================== Parametri totali: 505.201 Parametri addestrabili: 505.201 Parametri non addestrabili: 0

Ora dobbiamo compilare il nostro modello, cioè, in sostanza, impostarlo per l'allenamento. Noi useremo ottimizzatore "adamo".. Un ottimizzatore è un algoritmo che modifica i pesi e le distorsioni durante l'allenamento. Come funzioni di perdita usiamo l'entropia incrociata binaria (dal momento che stiamo lavorando con la classificazione binaria), l'accuratezza viene utilizzata come metrica di valutazione.

Model.compile(optimizer = "adam", loss = "binary_crossentropy", metriche = ["accuratezza"])

Ora possiamo addestrare il nostro modello. Lo faremo con una dimensione batch di 500 e solo due epoche come l'ho scoperto il modello inizia a riqualificarsi se lo alleni più a lungo. La dimensione del batch determina il numero di elementi che verranno distribuiti sulla rete e l'epoca è un passaggio di tutti gli elementi del set di dati. Generalmente una dimensione batch maggiore porta a un apprendimento più rapido, ma non sempre a una convergenza rapida. Un batch di dimensioni inferiori si allena più lentamente, ma può convergere più velocemente. La scelta dell'una o dell'altra opzione dipende sicuramente dal tipo di problema da risolvere, ed è meglio provare ognuna di esse. Se sei nuovo in questa materia, ti consiglierei di utilizzare per la prima volta dimensione del lotto 32, che è una specie di standard.

Risultati = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) Addestramento su 40000 campioni, convalida su 10000 campioni Epoca 1/2 40000/40000 [======= ========================] - 5s 129us/step - loss: 0.4051 - acc: 0.8212 - val_loss: 0.2635 - val_acc: 0.8945 Epoch 2/2 40000 /40000 [==============================] - 4s 90us/passo - perdita: 0,2122 - acc: 0,9190 - val_loss: 0,2598 - val_acc: 0,8950

Valutiamo le prestazioni del modello:

Print(np.mean(results.history["val_acc"])) 0.894750000536

Bene! Il nostro semplice modello ha già battuto il record di precisione in un documento del 2011. menzionato all'inizio del post. Sentiti libero di sperimentare con i parametri di rete e il numero di livelli.

Il codice modello completo è mostrato di seguito:

Importa numpy come np da keras.utils import to_categorical da keras importa modelli da keras importa livelli da keras.datasets import imdb (training_data, training_targets), (testing_data, testing_targets) = imdb.load_data(num_words=10000) data = np.concatenate( (training_data, testing_data), asse=0) target = np.concatenate((training_targets, testing_targets), asse=0) def vectorize(sequences, dimension = 10000): results = np.zeros((len(sequences), dimension) ) per i, sequenza in enumerate(sequences): results = 1 restituisce risultati data = vectorize(data) target = np.array(targets).astype("float32") test_x = data[:10000] test_y = target[:10000 ] train_x = data train_y = target model = models.Sequential() # Input - Layer model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Nascosto - Layers model.add( layers.Dropout(0.3, noise_shape=Nessuno, seed=None)) model.add(layers.Dense(50, activation = "relu")) model.add(layers.Dropout(0.2, noise_shape=None, seed=None) ) modello. add(layers.Dense(50, activation = "relu")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid")) model.summary() # compilazione del modello model.compile(optimizer = "adam", loss = "binary_crossentropy", metriche = ["accuratezza"]) results = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) print("Test- Precisione:", np.mean(results.history["val_acc"]))

Risultati

Hai imparato cos'è la sentiment analysis e perché Keras è una delle librerie di deep learning più popolari.

Abbiamo creato una semplice rete neurale con sei livelli in grado di calcolare l'umore dei revisori di film con una precisione dell'89%. Ora puoi utilizzare questo modello per analizzare i sentimenti binari in altre fonti, ma per questo dovrai impostare la loro dimensione su 10.000 o modificare i parametri del livello di input.

Questo modello (con piccole modifiche) può essere applicato anche ad altri problemi di apprendimento automatico.

Le reti neurali vengono create e addestrate principalmente in Python. Pertanto, è molto importante avere una conoscenza di base di come scrivere programmi su di esso. In questo articolo parlerò brevemente e chiaramente dei concetti base di questo linguaggio: variabili, funzioni, classi e moduli.

Il materiale è destinato a persone che non hanno familiarità con i linguaggi di programmazione.

Per prima cosa devi installare Python. Quindi è necessario configurare un ambiente conveniente per la scrittura di programmi in Python. Questi due passaggi sono dedicati al portale.

Se tutto è installato e configurato, puoi iniziare.

Variabili

Variabile- un concetto chiave in qualsiasi linguaggio di programmazione (e non solo). È più facile pensare a una variabile come a una casella con un'etichetta. Questa casella contiene qualcosa (un numero, una matrice, un oggetto, ...) che ha valore per noi.

Ad esempio, supponiamo di voler creare una variabile x che dovrebbe memorizzare il valore 10. In Python, il codice per creare questa variabile sarebbe simile a questo:

A sinistra noi annunciare una variabile denominata x . Ciò equivale al fatto che abbiamo incollato un'etichetta personale sulla scatola. Poi viene il segno di uguale e il numero 10. Il segno di uguale gioca un ruolo insolito qui. Non significa "x è 10". L'uguaglianza in questo caso mette il numero 10 nella casella. Più correttamente, noi assegnare variabile x numero 10.

Ora, nel codice seguente, possiamo accedere a questa variabile ed eseguire varie azioni con essa.

Puoi semplicemente visualizzare il valore di questa variabile sullo schermo:

X=10 stampa(x)

La scritta print(x) è una chiamata di funzione. Li considereremo ulteriormente. Ora l'importante è che questa funzione stampi sulla console ciò che si trova tra le parentesi. Abbiamo x tra parentesi. In precedenza, abbiamo assegnato a x il valore 10. Questo è esattamente 10 che viene visualizzato nella console se esegui il programma sopra.

Con le variabili che memorizzano numeri, puoi eseguire varie semplici operazioni: somma, sottrazione, moltiplicazione, divisione e aumento a potenza.

X = 2 y = 3 # Aggiungi z = x + y print(z) # 5 # Differenza z = x - y print(z) # -1 # Prodotto z = x * y print(z) # 6 # Dividi z = x / y print(z) # 0.66666... ​​​​# Esponenziale z = x ** y print(z) # 8

Nel codice sopra, creiamo prima due variabili contenenti 2 e 3. Quindi creiamo una variabile z che memorizza il risultato dell'operazione su xey e stampa i risultati sulla console. Questo esempio mostra chiaramente che una variabile può cambiare il suo valore durante l'esecuzione del programma. Quindi, la nostra variabile z cambia il suo valore fino a 5 volte.

Funzioni

A volte diventa necessario eseguire più volte le stesse azioni. Ad esempio, nel nostro progetto, abbiamo spesso bisogno di visualizzare 5 righe di testo.

"Questo è un testo molto importante!"
"Questo testo non può essere letto"
"L'errore nella riga superiore è stato fatto apposta"
"Ciao e arrivederci"
"Fine"

Il nostro codice sarà simile a questo:

X = 10 y = x + 8 - 2 print("Questo è un testo molto importante!") print("Questo testo non deve essere letto") print("Apposta c'è stato un errore nella riga superiore") print( "Ciao") print ("Fine") z = x + y print("Questo è un testo molto importante!") print("Questo testo non può essere letto") print("Si è verificato un errore nella riga superiore apposta") print("Ciao") print ("Fine") test = z print("Questo è un testo molto importante!") print("Questo testo non può essere letto") print("L'errore nel la riga superiore è stata creata apposta") print("Ciao") print("Fine")

Sembra tutto molto ridondante e scomodo. Inoltre, c'è un errore nella seconda riga. Può essere riparato, ma dovrà essere riparato in tre punti contemporaneamente. E se nel nostro progetto queste cinque righe si chiamano 1000 volte? E tutto in luoghi e file diversi?

Soprattutto nei casi in cui è necessario eseguire spesso gli stessi comandi, i linguaggi di programmazione possono creare funzioni.

Funzione- un blocco di codice separato che può essere chiamato per nome.

Una funzione viene definita utilizzando la parola chiave def. Questo è seguito dal nome della funzione, seguito da parentesi e due punti. Successivamente, rientrato, è necessario elencare le azioni che verranno eseguite quando viene chiamata la funzione.

Def print_5_lines(): print("Questo è un testo molto importante!") print("Questo testo non può essere letto") print("La prima riga era sbagliata di proposito") print("Ciao e ciao") print(" Fine")

Abbiamo ora definito la funzione print_5_lines(). Ora, se nel nostro progetto dobbiamo inserire ancora una volta cinque righe, allora chiamiamo semplicemente la nostra funzione. Eseguirà automaticamente tutte le azioni.

# Definisci la funzione def print_5_lines(): print("Questo è un testo molto importante!") print("Questo testo non può essere letto") print("L'errore nella riga superiore è stato fatto apposta") print("Ciao and bye") print(" End") # Il nostro codice del progetto x = 10 y = x + 8 - 2 print_5_lines() z = x + y print_5_lines() test = z print_5_lines()

Comodo, vero? Abbiamo notevolmente migliorato la leggibilità del codice. Inoltre, le funzioni sono anche buone perché se vuoi modificare alcune azioni, è sufficiente modificare la funzione stessa. Questa modifica funzionerà in tutti i punti in cui viene chiamata la tua funzione. Cioè, possiamo correggere l'errore nella seconda riga del testo di output ("non consentito" > "non consentito") nel corpo della funzione. La variante corretta verrà automaticamente chiamata in tutti i punti del nostro progetto.

Funzioni con parametri

Ovviamente è conveniente ripetere solo alcuni passaggi. Ma questo non è tutto. A volte vogliamo passare alcune variabili alla nostra funzione. Pertanto, la funzione può ricevere dati e utilizzarli nel processo di esecuzione dei comandi.

Vengono chiamate le variabili che passiamo alla funzione argomenti.

Scriviamo una semplice funzione che somma due numeri dati e restituisce il risultato.

Def sum(a, b): risultato = a + b restituisce il risultato

La prima riga sembra quasi la stessa delle normali funzioni. Ma tra le parentesi ora ci sono due variabili. Questo è opzioni funzioni. La nostra funzione ha due parametri (cioè prende due variabili).

I parametri possono essere utilizzati all'interno di una funzione proprio come le normali variabili. Nella seconda riga creiamo una variabile result , che è uguale alla somma dei parametri aeb . Sulla terza riga, restituiamo il valore della variabile risultato.

Ora, in ulteriore codice, possiamo scrivere qualcosa come:

Nuovo = somma(2, 3) print(nuovo)

Chiamiamo la funzione somma e le passiamo due argomenti a turno: 2 e 3. 2 diventa il valore della variabile a e 3 diventa il valore della variabile b . La nostra funzione restituisce un valore (la somma di 2 e 3) e lo usiamo per creare una nuova variabile new .

Ricordare. Nel codice sopra, i numeri 2 e 3 sono gli argomenti della funzione somma. E nella funzione somma stessa, le variabili aeb sono parametri. In altre parole, le variabili che passiamo a una funzione quando viene chiamata sono chiamate argomenti. Ma all'interno della funzione, queste variabili passate sono chiamate parametri. In effetti, questi sono due nomi per la stessa cosa, ma non dovresti confonderli.

Consideriamo un altro esempio. Creiamo una funzione quadrato(a) che prenda un singolo numero e lo quadra:

Def quadrato(a): restituisce a * a

La nostra funzione consiste in una sola riga. Restituisce immediatamente il risultato della moltiplicazione del parametro a per a .

Penso che tu abbia già intuito che produciamo anche l'output dei dati sulla console usando una funzione. Questa funzione si chiama print() e stampa l'argomento passato alla console: un numero, una stringa, una variabile.

Matrici

Se una variabile può essere pensata come una scatola che contiene qualcosa (non necessariamente un numero), gli array possono essere pensati come scaffali. Contengono più variabili contemporaneamente. Ecco un esempio di una matrice di tre numeri e una stringa:

matrice=

Ecco un esempio, quando la variabile non contiene un numero, a qualche altro oggetto. In questo caso, la nostra variabile contiene un array. Ogni elemento dell'array è numerato. Proviamo a visualizzare alcuni elementi dell'array:

Matrice = stampa(matrice)

Nella console vedrai il numero 89. Ma perché 89 e non 1? Il fatto è che in Python, come in molti altri linguaggi di programmazione, la numerazione degli array inizia da 0. Pertanto, array ci dà secondo elemento array, non il primo. Per chiamare il primo, si doveva scrivere array .

Dimensione della matrice

A volte è molto utile ottenere il numero di elementi in un array. Puoi usare la funzione len() per questo. Conterà automaticamente il numero di elementi e restituirà il loro numero.

Matrice = print(len(matrice))

Il numero 4 verrà visualizzato nella console.

Condizioni e cicli

Per impostazione predefinita, qualsiasi programma esegue semplicemente tutti i comandi dall'alto verso il basso in una riga. Ma ci sono situazioni in cui è necessario verificare alcune condizioni e, a seconda che siano vere o meno, eseguire azioni diverse.

Inoltre, diventa spesso necessario ripetere quasi più volte la stessa sequenza di comandi.

Le condizioni aiutano nella prima situazione e i cicli aiutano nella seconda.

Condizioni

Le condizioni sono necessarie per eseguire due diversi insiemi di azioni a seconda che l'asserzione da verificare sia vera o falsa.

In Python, le condizioni possono essere scritte usando il costrutto if: ... else: .... Diciamo di avere una variabile x = 10 . Se x è minore di 10, allora vogliamo dividere x per 2. Se x è maggiore o uguale a 10, allora vogliamo creare un'altra variabile new , che è uguale alla somma di x e il numero 100. Il codice sarebbe simile a questo:

X = 10 se(x< 10): x = x / 2 print(x) else: new = x + 100 print(new)

Dopo aver creato la variabile x, iniziamo a scrivere la nostra condizione.

Tutto inizia con la parola chiave if (tradotta dall'inglese "if"). Tra parentesi indichiamo l'espressione da controllare. In questo caso, stiamo controllando se la nostra variabile x è davvero minore di 10. Se è davvero minore di 10, la dividiamo per 2 e stampiamo il risultato sulla console.

Quindi arriva la parola chiave else , dopo di che inizia il blocco di azioni che verranno eseguite se l'espressione tra parentesi dopo l'if è falsa.

Se è maggiore o uguale a 10, creiamo una nuova variabile new , che è uguale a x + 100 e la stampiamo anche sulla console.

Cicli

I loop vengono utilizzati per ripetere le azioni più e più volte. Supponiamo di voler visualizzare una tabella di quadrati dei primi 10 numeri naturali. Si può fare così.

Print("Il quadrato 1 è " + str(1**2)) print("Il quadrato 2 è " + str(2**2)) print("Il quadrato 3 è " + str(3**2)) print( "Il quadrato 4 è " + str(4**2)) print("Il quadrato 5 è " + str(5**2)) print("Il quadrato 6 è " + str(6**2)) print("Il quadrato 7 è " + str(7**2)) print("Il quadrato 8 è " + str(8**2)) print("Il quadrato 9 è " + str(9**2)) print("Il quadrato 10 è " + str(10**2))

Non essere sorpreso dal fatto che aggiungiamo stringhe. "inizio della stringa" + "fine" in Python significa semplicemente concatenazione di stringhe: "inizio della stringa". Allo stesso modo sopra, aggiungiamo la stringa "Quadrato x è uguale a" e il risultato dell'aumento del numero alla 2a potenza convertita utilizzando la funzione str (x ** 2).

Il codice sopra sembra molto ridondante. Ma cosa succede se dobbiamo stampare i quadrati dei primi 100 numeri? Siamo tormentati a ritirarci...

Ecco a cosa servono i cicli. Ci sono 2 tipi di loop in Python: while e for . Affrontiamoli a turno.

Il ciclo while ripete i comandi necessari finché la condizione rimane vera.

X = 1 mentre x<= 100: print("Квадрат числа " + str(x) + " равен " + str(x**2)) x = x + 1

Per prima cosa creiamo una variabile e le assegniamo il numero 1. Quindi creiamo un ciclo while e controlliamo se la nostra x è minore (o uguale a) 100. Se inferiore a (o uguale a), eseguiamo due azioni:

1. Ricaviamo il quadrato x
2. Aumenta x di 1

Dopo il secondo comando, il programma torna alla condizione. Se la condizione è di nuovo vera, eseguiamo nuovamente queste due azioni. E così via fino a quando x diventa uguale a 101. Quindi la condizione restituirà false e il ciclo non verrà più eseguito.

Il ciclo for è progettato per scorrere sugli array. Scriviamo lo stesso esempio con i quadrati dei primi cento numeri naturali, ma attraverso il ciclo for.

Per x in range(1,101): print("Il quadrato di " + str(x) + " è " + str(x**2))

Analizziamo la prima riga. Usiamo la parola chiave for per creare un ciclo. Successivamente, indichiamo che vogliamo ripetere determinate azioni per tutte le x nell'intervallo da 1 a 100. La funzione range(1,101) crea una matrice di 100 numeri, che iniziano con 1 e terminano con 100.

Ecco un altro esempio di iterazione su un array usando un ciclo for:

Per i in : print(i * 2)

Il codice sopra emette 4 cifre: 2, 20, 200 e 2000. Qui puoi vedere chiaramente come prende ogni elemento dell'array ed esegue una serie di azioni. Quindi prende l'elemento successivo e ripete lo stesso insieme di azioni. E così via fino a quando gli elementi nell'array non si esauriscono.

Classi e oggetti

Nella vita reale, operiamo non con variabili o funzioni, ma con oggetti. Penna, macchina, uomo, gatto, cane, aereo - oggetti. Ora iniziamo a guardare il gatto in dettaglio.

Ha alcune opzioni. Questi includono il colore del mantello, il colore degli occhi, il suo soprannome. Ma questo non è tutto. Oltre ai parametri, il gatto può eseguire varie azioni: fare le fusa, sibilare e graffiare.

Abbiamo appena descritto schematicamente tutti i gatti in generale. Simile descrizione di proprietà e azioni qualche oggetto (ad esempio un gatto) nel linguaggio Python ed è chiamato classe. Una classe è semplicemente una raccolta di variabili e funzioni che descrivono un tipo di oggetto.

È importante capire la differenza tra una classe e un oggetto. Classe - schema A che descrive l'oggetto. L'oggetto è lei realizzazione materiale. Una classe cat è una descrizione delle sue proprietà e azioni. L'oggetto gatto è il gatto stesso. Ci possono essere molti gatti reali diversi - molti oggetti per gatti. Ma c'è solo una classe di gatto. L'immagine qui sotto è una buona dimostrazione:

Classi

Per creare una classe (lo schema del nostro gatto), dobbiamo scrivere la parola chiave class e poi specificare il nome di questa classe:

Gatto di classe:

Successivamente, dobbiamo elencare le azioni di questa classe (le azioni del gatto). Le azioni, come avrai intuito, sono funzioni definite all'interno di una classe. Tali funzioni all'interno di una classe sono chiamate metodi.

Metodo- una funzione definita all'interno di una classe.

Verbalmente, abbiamo già descritto i metodi del gatto sopra: fare le fusa, sibilare, graffiare. Facciamolo in Python ora.

# Cat class class Cat: # Purr def purr(self): print("Purrr!") # Hiss def hiss(self): print("Kshh!") # Scratch def scrabble(self): print("Scratch-scratch !")

È così semplice! Abbiamo preso e definito tre funzioni regolari, ma solo all'interno della classe.

Per affrontare l'incomprensibile parametro self, aggiungiamo un altro metodo al nostro gatto. Questo metodo chiamerà tutti e tre i metodi già creati contemporaneamente.

# Cat class class Cat: # Purr def purr(self): print("Purrr!") # Hiss def hiss(self): print("Kshh!") # Scratch def scrabble(self): print("Scratch-scratch !") # Tutti insieme def all_in_one(self): self.purr() self.hiss() self.scrabble()

Come puoi vedere, il parametro self, che è obbligatorio per qualsiasi metodo, ci permette di accedere ai metodi e alle variabili della classe stessa! Senza questo argomento, non saremmo in grado di eseguire tali azioni.

Impostiamo ora le proprietà del nostro gatto (colore dei capelli, colore degli occhi, soprannome). Come farlo? In qualsiasi classe, puoi definire la funzione __init__(). Questa funzione viene sempre chiamata quando creiamo l'oggetto reale della nostra classe.

Nel metodo __init__() evidenziato sopra, impostiamo le variabili del nostro gatto. Come lo facciamo? Innanzitutto, passiamo 3 argomenti a questo metodo, che sono responsabili del colore del mantello, del colore degli occhi e del soprannome. Quindi, utilizziamo il parametro self per impostare immediatamente il nostro gatto con i 3 attributi sopra descritti durante la creazione di un oggetto.

Cosa significa questa linea?

Self.wool_color = wool_color

Sul lato sinistro, creiamo un attributo per il nostro gatto chiamato wool_color , quindi impostiamo quell'attributo sul valore contenuto nel parametro wool_color che abbiamo passato alla funzione __init__(). Come puoi vedere, la riga sopra non è diversa dalla solita creazione di una variabile. Solo il prefisso self indica che questa variabile appartiene alla classe Cat.

Attributo- una variabile che appartiene a qualche classe.

Quindi, abbiamo creato una classe di gatti già pronta. Ecco il suo codice:

# Cat class class Cat: # Azioni da intraprendere durante la creazione di un oggetto Cat def __init__(self, wool_color, eyes_color, name): self.wool_color = wool_color self.eyes_color = eyes_color self.name = name # Purr def purr( self): print("Purrr!") # Scrabble def hiss(self): print("Shh!") # Scrabble def scrabble(self): print("Scratch-scratch!") # Tutti insieme def all_in_one(self) : self. purr() self.hiss() self.scrabble()

Oggetti

Abbiamo creato uno schema per gatti. Ora creiamo un vero oggetto gatto secondo questo schema:

Mio_gatto = Gatto("nero", "verde", "Zosya")

Nella riga sopra, creiamo la variabile my_cat e quindi gli assegniamo un oggetto di classe Cat. Tutto questo sembra una chiamata a qualche funzione Cat(...) . In effetti, lo è. Con questa voce, chiamiamo il metodo __init__() della classe Cat. La funzione __init__() nella nostra classe accetta 4 argomenti: l'oggetto stesso della classe self, che non ha bisogno di essere specificato, così come altri 3 argomenti diversi, che poi diventano attributi del nostro gatto.

Quindi, con l'aiuto della riga sopra, abbiamo creato un vero oggetto gatto. Il nostro gatto ha i seguenti attributi: capelli neri, occhi verdi e il soprannome Zosya. Stampiamo questi attributi sulla console:

Print(my_cat.wool_color) print(my_cat.eyes_color) print(my_cat.name)

Cioè, possiamo fare riferimento agli attributi di un oggetto scrivendo il nome dell'oggetto, mettendo un punto e specificando il nome dell'attributo desiderato.

Gli attributi del gatto possono essere modificati. Ad esempio, cambiamo il nome del nostro gatto:

My_cat.name = "Nyusha"

Ora, se stampi di nuovo il nome del gatto sulla console, al posto di Zosia vedrai Nyusha.

Vi ricordo che la classe del nostro gatto gli permette di compiere alcune azioni. Se accarezziamo la nostra Zosya / Nyusha, inizierà a fare le fusa:

Il mio_gatto.purr()

L'esecuzione di questo comando visualizzerà il testo "Murrr!" sulla console. Come puoi vedere, accedere ai metodi di un oggetto è facile come accedere ai suoi attributi.

Moduli

Qualsiasi file con estensione .py è un modulo. Anche quello in cui stai lavorando a questo articolo. A cosa servono? Per comodità. Molte persone creano file con funzioni e classi utili. Altri programmatori includono questi moduli di terze parti e possono utilizzare tutte le funzioni e le classi in essi definite, semplificando così il loro lavoro.

Ad esempio, non è necessario perdere tempo a scrivere le proprie funzioni per lavorare con le matrici. È sufficiente includere il modulo numpy e utilizzare le sue funzioni e classi.

Finora, altri programmatori Python hanno scritto oltre 110.000 moduli diversi. Il modulo numpy sopra menzionato ti consente di lavorare in modo rapido e conveniente con matrici e array multidimensionali. Il modulo di matematica fornisce molti metodi per lavorare con i numeri: seno, coseno, conversione di gradi in radianti e così via...

Installazione del modulo

Python viene installato insieme a un set standard di moduli. Questo set include un numero molto elevato di moduli che ti consentono di lavorare con la matematica, le query web, leggere e scrivere file ed eseguire altre azioni necessarie.

Se si desidera utilizzare un modulo che non è incluso nel set standard, sarà necessario installarlo. Per installare il modulo, apri la riga di comando (Win + R, quindi inserisci "cmd" nel campo che appare) e inserisci il comando al suo interno:

Installazione Pip [nome_modulo]

Verrà avviato il processo di installazione del modulo. Al termine, puoi tranquillamente utilizzare il modulo installato nel tuo programma.

Collegamento e utilizzo del modulo

Un modulo di terze parti viene collegato in modo molto semplice. Devi solo scrivere una breve riga di codice:

Importa [nome_modulo]

Ad esempio, per importare un modulo che ti permetta di lavorare con funzioni matematiche, devi scrivere quanto segue:

importa la matematica

Come accedere a una funzione del modulo? Devi scrivere il nome del modulo, quindi inserire un punto e scrivere il nome della funzione/classe. Ad esempio, il fattoriale di 10 si trova in questo modo:

Fattoriale matematico(10)

Cioè, siamo passati alla funzione fattoriale(a), che è definita all'interno del modulo matematico. Questo è conveniente, perché non è necessario perdere tempo e creare manualmente una funzione che calcola il fattoriale di un numero. È possibile collegare il modulo ed eseguire immediatamente l'azione necessaria.

Originale: creazione di una rete neurale in Python
Autore: Giovanni Serrano
Data di pubblicazione: 26 maggio 2016
Traduzione: A.Panin
Data del trasferimento: 6 dicembre 2016

Le reti neurali sono programmi estremamente complessi, comprensibili solo da accademici e geni, che per definizione non possono essere gestiti da normali sviluppatori, per non parlare di me. Credi?

Beh, in realtà non è affatto così. Dopo un'ottima presentazione di Louis Monier e Greg Renard all'Holberton College, mi sono reso conto che le reti neurali sono abbastanza semplici da comprendere e implementare per qualsiasi sviluppatore di software. Certo, le reti più complesse sono progetti su larga scala con architetture eleganti e intricate, ma anche i concetti alla base sono più o meno ovvi. Progettare qualsiasi rete neurale da zero può essere una vera sfida, ma fortunatamente ci sono alcune ottime librerie là fuori che possono fare tutto il lavoro di basso livello per te.

In questo contesto, un neurone è un'entità abbastanza semplice. Accetta diversi valori di input e se la somma di questi valori supera il limite specificato, viene attivato. In questo caso, ogni valore di input viene moltiplicato per il suo peso. Il processo di apprendimento è essenzialmente il processo di impostazione dei pesi dei valori per generare i valori di output richiesti. Le reti che verranno discusse in questo articolo sono chiamate reti di "propagazione in avanti", il che significa che i neuroni in esse sono organizzati in livelli, con i loro input provenienti dal livello precedente e le loro uscite inviate al livello successivo.

Esistono altri tipi di reti neurali, come le reti neurali ricorrenti, che sono organizzate in modo diverso, ma questo è un argomento per un altro articolo.

Un neurone che funziona secondo il principio sopra descritto è chiamato perceptron e si basa sul modello originale dei neuroni artificiali, che oggi è usato raramente. Il problema con i percettroni è che una piccola variazione dei valori di input può portare a una grande variazione del valore di uscita a causa della funzione del passo di attivazione. In questo caso, una leggera diminuzione del valore di input può portare al fatto che il valore interno non supererà il limite impostato e il neurone non verrà attivato, il che comporterà cambiamenti ancora più significativi nello stato dei neuroni che lo seguono . Fortunatamente, questo problema è facilmente risolvibile con la funzione di attivazione più fluida utilizzata oggi nella maggior parte delle reti.

Tuttavia, la nostra rete neurale sarà così semplice che i percettron sono abbastanza adatti per la sua creazione. Creeremo una rete che esegue un'operazione logica "AND". Ciò significa che avremo bisogno di due neuroni di input e un neurone di output, oltre a diversi neuroni nello strato "nascosto" nel mezzo. L'illustrazione seguente mostra l'architettura di questa rete, che dovrebbe essere abbastanza autoesplicativa.

Monier e Renard hanno utilizzato lo script convnet.js per creare reti demo per i loro discorsi. Convnet.js può essere utilizzato per creare reti neurali direttamente nel tuo browser web, consentendoti di esplorarle e modificarle su quasi tutte le piattaforme. Naturalmente, questa implementazione di JavaScript presenta anche notevoli svantaggi, uno dei quali è la bassa velocità. Bene, in questo articolo useremo la libreria FANN (Fast Artifical Neural Networks). In questo caso, a livello del linguaggio di programmazione Python, verrà utilizzato il modulo pyfann, che contiene i binding per la libreria FANN. Dovresti installare subito il pacchetto software con questo modulo.

L'importazione di un modulo per lavorare con la libreria FANN avviene come segue:

>>> da pyfann import libfann

Ora possiamo iniziare! La prima operazione che dovremo eseguire è la creazione di una rete neurale vuota.

>>> rete_neurale = libfann.rete_neurale()

L'oggetto neural_net creato non contiene attualmente neuroni, quindi proviamo a crearli. Useremo la funzione libfann.create_standard_array() per questo scopo. La funzione create_standard_array() crea una rete neurale in cui tutti i neuroni sono collegati ai neuroni dei livelli vicini, quindi può essere definita una rete "completamente connessa". Come parametro, la funzione create_standard_array() prende un array con valori numerici corrispondenti al numero di neuroni ad ogni livello. Nel nostro caso, questo è un array.

>>> neural_net.create_standard((2, 4, 1))

Successivamente, dovremo impostare il valore del tasso di apprendimento. Questo valore corrisponde al numero di modifiche di peso all'interno di un'iterazione. Imposteremo un tasso di apprendimento abbastanza alto di 0,7 poiché risolveremo un problema abbastanza semplice con la nostra rete.

>>> neural_net.set_learning_rate(0.7)

Ora è il momento di installare la funzione di attivazione, il cui scopo è stato discusso sopra. Utilizzeremo la modalità di attivazione SIGMOID_SYMMETRIC_STEPWISE , che corrisponde alla funzione di approssimazione graduale della tangente iperbolica. È meno preciso e più veloce della solita funzione tangente iperbolica ed è ottimo per il nostro compito.

>>> neural_net.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE)

Infine, dobbiamo eseguire l'algoritmo di apprendimento della rete e archiviare i dati di rete in un file. La funzione di apprendimento della rete accetta quattro argomenti: il nome del file di dati su cui eseguire il training, il numero massimo di tentativi per eseguire l'algoritmo di apprendimento, il numero di operazioni di training prima di emettere i dati sullo stato della rete e il tasso di errore.

>>> neural_network.train_on_file("and.data", 10000, 1000, .00001) >>> neural_network.save("and.net")

Il file "and.data" deve contenere i seguenti dati:

4 2 1 -1 -1 -1 -1 1 -1 1 -1 -1 1 1 1

La prima riga contiene tre valori: il numero di esempi nel file, il numero di valori di input e il numero di valori di output. Di seguito sono riportate le righe di esempio, dove le due righe di valore sono i valori di input e le righe di valore singolo sono i valori di output.

Hai completato con successo la formazione sulla rete e ora vuoi testarla in produzione, vero? Ma prima, dovremo caricare i dati di rete dal file in cui sono stati salvati in precedenza.

>>> neural_net = libfann.neural_net() >>> neural_net.create_from_file("and.net")

Dopodiché, possiamo semplicemente attivarlo allo stesso modo:

>>> stampa neural_net.run()

L'output dovrebbe essere [-1.0] o simile, a seconda dei dati di rete generati durante l'addestramento della rete.

Congratulazioni! Hai appena insegnato a un computer a eseguire semplici operazioni logiche!