TensorFlow - Guida rapida

TensorFlow è una libreria o un framework software, progettato dal team di Google per implementare concetti di machine learning e deep learning nel modo più semplice. Combina l'algebra computazionale delle tecniche di ottimizzazione per un facile calcolo di molte espressioni matematiche.

Il sito web ufficiale di TensorFlow è menzionato di seguito:

www.tensorflow.org

Consideriamo ora le seguenti importanti caratteristiche di TensorFlow:

• Include una funzionalità che definisce, ottimizza e calcola facilmente espressioni matematiche con l'aiuto di array multidimensionali chiamati tensori.

• Include un supporto di programmazione di reti neurali profonde e tecniche di apprendimento automatico.

• Include una funzionalità di calcolo altamente scalabile con vari set di dati.

• TensorFlow utilizza il GPU computing, automatizzando la gestione. Include anche una caratteristica unica di ottimizzazione della stessa memoria e dei dati utilizzati.

Perché TensorFlow è così popolare?

TensorFlow è ben documentato e include numerose librerie di machine learning. Offre alcune funzionalità e metodi importanti per lo stesso.

TensorFlow è anche chiamato un prodotto "Google". Include una varietà di algoritmi di machine learning e deep learning. TensorFlow può addestrare ed eseguire reti neurali profonde per la classificazione delle cifre scritte a mano, il riconoscimento delle immagini, l'incorporamento di parole e la creazione di vari modelli di sequenza.

Per installare TensorFlow, è importante che "Python" sia installato nel sistema. La versione 3.4+ di Python è considerata la migliore per iniziare con l'installazione di TensorFlow.

Considera i seguenti passaggi per installare TensorFlow nel sistema operativo Windows.

Step 1 - Verifica la versione di Python da installare.

Step 2- Un utente può utilizzare qualsiasi meccanismo per installare TensorFlow nel sistema. Consigliamo "pip" e "Anaconda". Pip è un comando utilizzato per eseguire e installare moduli in Python.

Prima di installare TensorFlow, dobbiamo installare il framework Anaconda nel nostro sistema.

Al termine dell'installazione, controllare il prompt dei comandi tramite il comando "conda". L'esecuzione del comando è visualizzata di seguito:

Step 3 - Esegui il seguente comando per inizializzare l'installazione di TensorFlow -

conda create --name tensorflow python = 3.5

Scarica i pacchetti necessari necessari per la configurazione di TensorFlow.

Step 4 - Dopo una corretta configurazione ambientale, è importante attivare il modulo TensorFlow.

activate tensorflow

Step 5- Utilizzare pip per installare "Tensorflow" nel sistema. Il comando utilizzato per l'installazione è menzionato come di seguito:

pip install tensorflow

E,

pip install tensorflow-gpu

Al termine dell'installazione, è importante conoscere l'esecuzione del programma di esempio di TensorFlow.

L'esempio seguente ci aiuta a comprendere la creazione del programma di base "Hello World" in TensorFlow.

Il codice per la prima implementazione del programma è menzionato di seguito:

>> activate tensorflow
>> python (activating python shell)
>> import tensorflow as tf
>> hello = tf.constant(‘Hello, Tensorflow!’)
>> sess = tf.Session()
>> print(sess.run(hello))

L'intelligenza artificiale include il processo di simulazione dell'intelligenza umana da parte di macchine e sistemi informatici speciali. Gli esempi di intelligenza artificiale includono l'apprendimento, il ragionamento e l'auto-correzione. Le applicazioni dell'intelligenza artificiale includono riconoscimento vocale, sistemi esperti e riconoscimento di immagini e visione artificiale.

L'apprendimento automatico è il ramo dell'intelligenza artificiale, che si occupa di sistemi e algoritmi in grado di apprendere nuovi dati e modelli di dati.

Concentriamoci sul diagramma di Venn menzionato di seguito per comprendere i concetti di machine learning e deep learning.

Il machine learning include una sezione del machine learning e il deep learning è una parte del machine learning. La capacità del programma che segue i concetti di apprendimento automatico è quella di migliorare le prestazioni dei dati osservati. Il motivo principale della trasformazione dei dati è migliorare la propria conoscenza al fine di ottenere risultati migliori in futuro, fornire un output più vicino all'output desiderato per quel particolare sistema. L'apprendimento automatico include il "riconoscimento di modelli" che include la capacità di riconoscere i modelli nei dati.

I modelli dovrebbero essere addestrati per mostrare l'output in modo desiderabile.

L'apprendimento automatico può essere addestrato in due modi diversi:

• Formazione supervisionata
• Formazione senza supervisione

Apprendimento supervisionato

L'apprendimento supervisionato o l'addestramento supervisionato include una procedura in cui l'insieme di addestramento viene fornito come input al sistema in cui ogni esempio è etichettato con un valore di output desiderato. L'addestramento in questo tipo viene eseguito utilizzando la minimizzazione di una particolare funzione di perdita, che rappresenta l'errore di output rispetto al sistema di output desiderato.

Dopo il completamento della formazione, l'accuratezza di ciascun modello viene misurata rispetto agli esempi disgiunti del set di addestramento, chiamato anche set di convalida.

Il miglior esempio per illustrare "Apprendimento supervisionato" è con un mucchio di foto fornite con informazioni incluse in esse. Qui l'utente può addestrare un modello a riconoscere le nuove foto.

Apprendimento senza supervisione

Nell'apprendimento senza supervisione o nella formazione senza supervisione, includere esempi di formazione, che non sono etichettati dal sistema a cui appartengono. Il sistema cerca i dati, che condividono caratteristiche comuni, e li modifica in base alle caratteristiche della conoscenza interna. Questo tipo di algoritmi di apprendimento sono fondamentalmente utilizzati nei problemi di clustering.

Il miglior esempio per illustrare l '"apprendimento senza supervisione" è con un gruppo di foto senza informazioni incluse e l'utente addestra il modello con classificazione e raggruppamento. Questo tipo di algoritmo di addestramento funziona con ipotesi poiché non vengono fornite informazioni.

È importante comprendere i concetti matematici necessari per TensorFlow prima di creare l'applicazione di base in TensorFlow. La matematica è considerata il cuore di qualsiasi algoritmo di apprendimento automatico. È con l'aiuto dei concetti fondamentali della matematica, viene definita una soluzione per uno specifico algoritmo di apprendimento automatico.

Vettore

Una matrice di numeri, continua o discreta, è definita come vettore. Gli algoritmi di apprendimento automatico si occupano di vettori di lunghezza fissa per una migliore generazione di output.

Gli algoritmi di apprendimento automatico gestiscono dati multidimensionali, quindi i vettori svolgono un ruolo cruciale.

La rappresentazione pittorica del modello vettoriale è come mostrato di seguito:

Scalare

Scalare può essere definito come vettore unidimensionale. Gli scalari sono quelli che includono solo la magnitudine e nessuna direzione. Con gli scalari, ci occupiamo solo della grandezza.

Esempi di scalare includono i parametri di peso e altezza dei bambini.

Matrice

Le matrici possono essere definite come array multidimensionali, disposti nel formato di righe e colonne. La dimensione della matrice è definita dalla lunghezza della riga e dalla lunghezza della colonna. La figura seguente mostra la rappresentazione di qualsiasi matrice specificata.

Considerare la matrice con "m" righe e "n" colonne come menzionato sopra, la rappresentazione della matrice sarà specificata come "m * n matrice" che ha definito anche la lunghezza della matrice.

Calcoli matematici

In questa sezione, impareremo i diversi calcoli matematici in TensorFlow.

Aggiunta di matrici

L'aggiunta di due o più matrici è possibile se le matrici sono della stessa dimensione. L'addizione implica l'aggiunta di ogni elemento secondo la posizione data.

Considera il seguente esempio per capire come funziona l'aggiunta di matrici:

$$ Esempio: A = \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B = \ begin {bmatrix} 5 & 6 \\ 7 & 8 \ end {bmatrix} \: then \: A + B = \ begin {bmatrix} 1 + 5 & 2 + 6 \\ 3 + 7 & 4 + 8 \ end {bmatrix} = \ begin {bmatrix} 6 & 8 \\ 10 & 12 \ end {bmatrix} $$

Sottrazione di matrici

La sottrazione di matrici opera in modo simile come l'aggiunta di due matrici. L'utente può sottrarre due matrici a condizione che le dimensioni siano uguali.

$$ Esempio: A- \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B- \ begin {bmatrix} 5 & 6 \\ 7 & 8 \ end {bmatrix} \: then \: AB - \ begin {bmatrix} 1-5 & 2-6 \\ 3-7 & 4-8 \ end {bmatrix} - \ begin {bmatrix} -4 & -4 \\ - 4 & -4 \ end {bmatrix} $$

Moltiplicazione di matrici

Affinché due matrici A m * ne B p * q siano moltiplicabili, n dovrebbe essere uguale a p. La matrice risultante è -

C m * q

$$ A = \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B = \ begin {bmatrix} 5 & 6 \\ 7 & 8 \ end {bmatrix} $$

$$ c_ {11} = \ begin {bmatrix} 1 & 2 \ end {bmatrix} \ begin {bmatrix} 5 \\ 7 \ end {bmatrix} = 1 \ times5 + 2 \ times7 = 19 \: c_ {12} = \ begin {bmatrix} 1 & 2 \ end {bmatrix} \ begin {bmatrix} 6 \\ 8 \ end {bmatrix} = 1 \ times6 + 2 \ times8 = 22 $$

$$ c_ {21} = \ begin {bmatrix} 3 & 4 \ end {bmatrix} \ begin {bmatrix} 5 \\ 7 \ end {bmatrix} = 3 \ times5 + 4 \ times7 = 43 \: c_ {22} = \ begin {bmatrix} 3 & 4 \ end {bmatrix} \ begin {bmatrix} 6 \\ 8 \ end {bmatrix} = 3 \ times6 + 4 \ times8 = 50 $$

$$ C = \ begin {bmatrix} c_ {11} & c_ {12} \\ c_ {21} & c_ {22} \ end {bmatrix} = \ begin {bmatrix} 19 & 22 \\ 43 & 50 \ end {bmatrix} $$

Trasposizione della matrice

La trasposizione di una matrice A, m * n è generalmente rappresentata da AT (trasposizione) n * m ed è ottenuta trasponendo i vettori colonna come vettori riga.

$$ Esempio: A = \ begin {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} \: then \: A ^ {T} \ begin {bmatrix} 1 & 3 \\ 2 & 4 \ end { bmatrix} $$

Prodotto scalare di vettori

Qualsiasi vettore di dimensione n può essere rappresentato come una matrice v = R ^ n * 1.

$$ v_ {1} = \ begin {bmatrix} v_ {11} \\ v_ {12} \\\ cdot \\\ cdot \\\ cdot \\ v_ {1n} \ end {bmatrix} v_ {2} = \ begin {bmatrix} v_ {21} \\ v_ {22} \\\ cdot \\\ cdot \\\ cdot \\ v_ {2n} \ end {bmatrix} $$

Il prodotto scalare di due vettori è la somma del prodotto dei componenti corrispondenti - Componenti lungo la stessa dimensione e può essere espresso come

$$ v_ {1} \ cdot v_ {2} = v_1 ^ Tv_ {2} = v_2 ^ Tv_ {1} = v_ {11} v_ {21} + v_ {12} v_ {22} + \ cdot \ cdot + v_ {1n} v_ {2n} = \ displaystyle \ sum \ limits_ {k = 1} ^ n v_ {1k} v_ {2k} $$

L'esempio del prodotto scalare di vettori è menzionato di seguito:

$$ Esempio: v_ {1} = \ begin {bmatrix} 1 \\ 2 \\ 3 \ end {bmatrix} v_ {2} = \ begin {bmatrix} 3 \\ 5 \\ - 1 \ end {bmatrix} v_ {1} \ cdot v_ {2} = v_1 ^ Tv_ {2} = 1 \ times3 + 2 \ times5-3 \ times1 = 10 $$

L'intelligenza artificiale è una delle tendenze più popolari degli ultimi tempi. L'apprendimento automatico e l'apprendimento profondo costituiscono l'intelligenza artificiale. Il diagramma di Venn mostrato di seguito spiega la relazione tra machine learning e deep learning:

Apprendimento automatico

L'apprendimento automatico è l'arte della scienza di far agire i computer secondo gli algoritmi progettati e programmati. Molti ricercatori pensano che l'apprendimento automatico sia il modo migliore per progredire verso l'IA a livello umano. L'apprendimento automatico include i seguenti tipi di pattern

• Modello di apprendimento supervisionato
• Modello di apprendimento senza supervisione

Apprendimento approfondito

L'apprendimento profondo è un sottocampo dell'apprendimento automatico in cui gli algoritmi interessati sono ispirati dalla struttura e dalla funzione del cervello chiamate reti neurali artificiali.

Tutto il valore oggi del deep learning è attraverso l'apprendimento supervisionato o l'apprendimento da dati e algoritmi etichettati.

Ogni algoritmo nel deep learning passa attraverso lo stesso processo. Include una gerarchia di trasformazione non lineare dell'input che può essere utilizzata per generare un modello statistico come output.

Considera i seguenti passaggi che definiscono il processo di Machine Learning

• Identifica i set di dati rilevanti e li prepara per l'analisi.
• Sceglie il tipo di algoritmo da utilizzare
• Costruisce un modello analitico basato sull'algoritmo utilizzato.
• Addestra il modello su set di dati di test, rivedendolo secondo necessità.
• Esegue il modello per generare i punteggi dei test.

Differenza tra machine learning e deep learning

In questa sezione, impareremo la differenza tra Machine Learning e Deep Learning.

Quantità di dati

L'apprendimento automatico funziona con grandi quantità di dati. È utile anche per piccole quantità di dati. Il deep learning, invece, funziona in modo efficiente se la quantità di dati aumenta rapidamente. Il diagramma seguente mostra il funzionamento del machine learning e del deep learning con la quantità di dati:

Dipendenze hardware

Gli algoritmi di deep learning sono progettati per dipendere fortemente da macchine di fascia alta, a differenza dei tradizionali algoritmi di machine learning. Gli algoritmi di deep learning eseguono una serie di operazioni di moltiplicazione di matrici, che richiedono una grande quantità di supporto hardware.

Feature Engineering

L'ingegnerizzazione delle funzionalità è il processo di inserimento della conoscenza del dominio in funzionalità specifiche per ridurre la complessità dei dati e creare modelli visibili agli algoritmi di apprendimento su cui funziona.

Esempio: i modelli di apprendimento automatico tradizionali si concentrano sui pixel e altri attributi necessari per il processo di progettazione delle funzionalità. Gli algoritmi di deep learning si concentrano su funzionalità di alto livello dai dati. Riduce il compito di sviluppare nuove funzionalità per estrarre ogni nuovo problema.

Approccio alla risoluzione dei problemi

I tradizionali algoritmi di machine learning seguono una procedura standard per risolvere il problema. Spezza il problema in parti, risolve ognuna di esse e le combina per ottenere il risultato richiesto. Il deep learning si concentra sulla risoluzione del problema dall'inizio alla fine invece di suddividerli in divisioni.

Tempo di esecuzione

Il tempo di esecuzione è la quantità di tempo necessaria per addestrare un algoritmo. L'apprendimento profondo richiede molto tempo per allenarsi poiché include molti parametri che richiedono più tempo del solito. L'algoritmo di apprendimento automatico richiede comparativamente meno tempo di esecuzione.

Interpretabilità

L'interpretabilità è il fattore principale per il confronto tra algoritmi di machine learning e deep learning. Il motivo principale è che il deep learning è ancora oggetto di ripensamento prima del suo utilizzo nell'industria.

Applicazioni di Machine Learning e Deep Learning

In questa sezione, impareremo le diverse applicazioni di Machine Learning e Deep Learning.

• Visione artificiale che viene utilizzata per il riconoscimento facciale e il segno di presenza tramite impronte digitali o identificazione del veicolo tramite targa.

• Recupero di informazioni dai motori di ricerca come la ricerca di testo per la ricerca di immagini.

• Email marketing automatizzato con identificazione del target specificato.

• Diagnosi medica di tumori cancerosi o identificazione di anomalie di qualsiasi malattia cronica.

• Elaborazione del linguaggio naturale per applicazioni come il tagging delle foto. Il miglior esempio per spiegare questo scenario è utilizzato in Facebook.

• Pubblicità online.

Tendenze future

• Con la crescente tendenza a utilizzare la scienza dei dati e l'apprendimento automatico nel settore, diventerà importante per ogni organizzazione inculcare l'apprendimento automatico nelle proprie attività.

• Il deep learning sta acquisendo sempre più importanza rispetto al machine learning. L'apprendimento profondo si sta dimostrando una delle migliori tecniche per prestazioni all'avanguardia.

• L'apprendimento automatico e l'apprendimento profondo si dimostreranno utili nel campo della ricerca e del mondo accademico.

Conclusione

In questo articolo, abbiamo avuto una panoramica del machine learning e del deep learning con illustrazioni e differenze incentrate anche sulle tendenze future. Molte delle applicazioni di intelligenza artificiale utilizzano algoritmi di apprendimento automatico principalmente per guidare il self-service, aumentare la produttività degli agenti e flussi di lavoro più affidabili. Gli algoritmi di machine learning e deep learning rappresentano una prospettiva entusiasmante per molte aziende e leader del settore.

In questo capitolo impareremo le basi di TensorFlow. Inizieremo comprendendo la struttura dei dati del tensore.

Struttura dei dati tensoriali

I tensori vengono utilizzati come strutture dati di base nel linguaggio TensorFlow. I tensori rappresentano i bordi di connessione in qualsiasi diagramma di flusso chiamato grafico del flusso di dati. I tensori sono definiti come array o liste multidimensionali.

I tensori sono identificati dai seguenti tre parametri:

Rango

L'unità di dimensionalità descritta all'interno del tensore è chiamata rango. Identifica il numero di dimensioni del tensore. Un rango di un tensore può essere descritto come l'ordine o le n dimensioni di un tensore definito.

Forma

Il numero di righe e colonne insieme definisce la forma del tensore.

genere

Tipo descrive il tipo di dati assegnato agli elementi di Tensor.

Un utente deve considerare le seguenti attività per costruire un tensore:

• Costruisci un array n-dimensionale
• Converti la matrice n-dimensionale.

Varie dimensioni di TensorFlow

TensorFlow include varie dimensioni. Le dimensioni sono descritte brevemente di seguito:

Tensore unidimensionale

Un tensore dimensionale è una normale struttura a matrice che include un insieme di valori dello stesso tipo di dati.

Declaration

>>> import numpy as np
>>> tensor_1d = np.array([1.3, 1, 4.0, 23.99])
>>> print tensor_1d

L'implementazione con l'output è mostrata nello screenshot qui sotto:

L'indicizzazione degli elementi è la stessa degli elenchi di Python. Il primo elemento inizia con indice di 0; per stampare i valori attraverso l'indice, tutto ciò che devi fare è menzionare il numero dell'indice.

>>> print tensor_1d[0]
1.3
>>> print tensor_1d[2]
4.0

Tensori bidimensionali

Le sequenze di array vengono utilizzate per creare "tensori bidimensionali".

La creazione di tensori bidimensionali è descritta di seguito:

Di seguito è riportata la sintassi completa per la creazione di array bidimensionali:

>>> import numpy as np
>>> tensor_2d = np.array([(1,2,3,4),(4,5,6,7),(8,9,10,11),(12,13,14,15)])
>>> print(tensor_2d)
[[ 1 2 3 4]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
>>>

Gli elementi specifici dei tensori bidimensionali possono essere tracciati con l'aiuto del numero di riga e del numero di colonna specificato come numeri di indice.

>>> tensor_2d[3][2]
14

Manipolazione e manipolazione dei tensori

In questa sezione, impareremo a gestire e manipolare i tensori.

Per cominciare, consideriamo il seguente codice:

import tensorflow as tf
import numpy as np

matrix1 = np.array([(2,2,2),(2,2,2),(2,2,2)],dtype = 'int32')
matrix2 = np.array([(1,1,1),(1,1,1),(1,1,1)],dtype = 'int32')

print (matrix1)
print (matrix2)

matrix1 = tf.constant(matrix1)
matrix2 = tf.constant(matrix2)
matrix_product = tf.matmul(matrix1, matrix2)
matrix_sum = tf.add(matrix1,matrix2)
matrix_3 = np.array([(2,7,2),(1,4,2),(9,0,2)],dtype = 'float32')
print (matrix_3)

matrix_det = tf.matrix_determinant(matrix_3)
with tf.Session() as sess:
   result1 = sess.run(matrix_product)
   result2 = sess.run(matrix_sum)
   result3 = sess.run(matrix_det)

print (result1)
print (result2)
print (result3)

Output

Il codice sopra genererà il seguente output:

Spiegazione

Abbiamo creato array multidimensionali nel codice sorgente sopra. Ora, è importante capire che abbiamo creato grafico e sessioni, che gestiscono i tensori e generano l'output appropriato. Con l'aiuto del grafico, abbiamo l'output che specifica i calcoli matematici tra i tensori.

Dopo aver compreso i concetti di apprendimento automatico, ora possiamo spostare la nostra attenzione sui concetti di apprendimento profondo. Il deep learning è una divisione dell'apprendimento automatico ed è considerato un passo cruciale compiuto dai ricercatori negli ultimi decenni. Gli esempi di implementazione del deep learning includono applicazioni come il riconoscimento delle immagini e il riconoscimento vocale.

Di seguito sono riportati i due importanti tipi di reti neurali profonde:

• Reti neurali convoluzionali
• Reti neurali ricorrenti

In questo capitolo, ci concentreremo sulla CNN, Convolutional Neural Networks.

Reti neurali convoluzionali

Le reti neurali convoluzionali sono progettate per elaborare i dati attraverso più livelli di array. Questo tipo di reti neurali viene utilizzato in applicazioni come il riconoscimento delle immagini o il riconoscimento facciale. La differenza principale tra la CNN e qualsiasi altra rete neurale ordinaria è che la CNN prende l'input come un array bidimensionale e opera direttamente sulle immagini piuttosto che concentrarsi sull'estrazione di caratteristiche su cui si concentrano altre reti neurali.

L'approccio dominante della CNN include soluzioni per problemi di riconoscimento. Le migliori aziende come Google e Facebook hanno investito in ricerca e sviluppo verso progetti di riconoscimento per svolgere le attività con maggiore velocità.

Una rete neurale convoluzionale utilizza tre idee di base:

• Campi rispettivi locali
• Convolution
• Pooling

Cerchiamo di capire queste idee in dettaglio.

La CNN utilizza le correlazioni spaziali che esistono all'interno dei dati di input. Ogni strato simultaneo di una rete neurale collega alcuni neuroni di input. Questa regione specifica è chiamata campo ricettivo locale. Il campo ricettivo locale si concentra sui neuroni nascosti. I neuroni nascosti elaborano i dati di input all'interno del campo menzionato non realizzando i cambiamenti al di fuori del confine specifico.

Di seguito è riportato un diagramma che rappresenta la generazione dei rispettivi campi locali:

Se osserviamo la rappresentazione di cui sopra, ogni connessione apprende un peso del neurone nascosto con una connessione associata con il movimento da uno strato all'altro. Qui, i singoli neuroni eseguono un cambiamento di volta in volta. Questo processo è chiamato "convoluzione".

La mappatura delle connessioni dal livello di input alla mappa degli elementi nascosti è definita come "pesi condivisi" e il bias incluso è chiamato "bias condiviso".

CNN o reti neurali convoluzionali utilizzano livelli di pooling, che sono i livelli, posizionati immediatamente dopo la dichiarazione della CNN. Prende l'input dell'utente come una mappa delle caratteristiche che esce dalle reti convoluzionali e prepara una mappa delle caratteristiche condensata. Il raggruppamento dei livelli aiuta a creare livelli con i neuroni dei livelli precedenti.

TensorFlow Implementazione della CNN

In questa sezione apprenderemo l'implementazione di TensorFlow della CNN. I passaggi, che richiedono l'esecuzione e la corretta dimensione dell'intera rete, sono i seguenti:

Step 1 - Includere i moduli necessari per TensorFlow e i moduli del set di dati, necessari per calcolare il modello CNN.

import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

Step 2 - Dichiarare una funzione chiamata run_cnn(), che include vari parametri e variabili di ottimizzazione con dichiarazione di segnaposto dati. Queste variabili di ottimizzazione dichiareranno il modello di addestramento.

def run_cnn():
   mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
   learning_rate = 0.0001
   epochs = 10
   batch_size = 50

Step 3 - In questo passaggio, dichiareremo i segnaposto dei dati di addestramento con i parametri di input - per 28 x 28 pixel = 784. Questi sono i dati dell'immagine appiattita che vengono estratti mnist.train.nextbatch().

Possiamo rimodellare il tensore secondo le nostre esigenze. Il primo valore (-1) indica alla funzione di modellare dinamicamente quella dimensione in base alla quantità di dati trasmessi. Le due dimensioni intermedie sono impostate sulla dimensione dell'immagine (cioè 28 x 28).

x = tf.placeholder(tf.float32, [None, 784])
x_shaped = tf.reshape(x, [-1, 28, 28, 1])
y = tf.placeholder(tf.float32, [None, 10])

Step 4 - Ora è importante creare alcuni strati convoluzionali -

layer1 = create_new_conv_layer(x_shaped, 1, 32, [5, 5], [2, 2], name = 'layer1')
layer2 = create_new_conv_layer(layer1, 32, 64, [5, 5], [2, 2], name = 'layer2')

Step 5- Appiattiamo l'uscita pronta per lo stadio di uscita completamente connesso - dopo due strati di raggruppamento della falcata 2 con le dimensioni di 28 x 28, alla dimensione di 14 x 14 o minimo 7 x 7 x, coordinate y, ma con 64 canali di uscita. Per creare il livello completamente connesso con "denso", la nuova forma deve essere [-1, 7 x 7 x 64]. Possiamo impostare alcuni pesi e valori di bias per questo livello, quindi attivarli con ReLU.

flattened = tf.reshape(layer2, [-1, 7 * 7 * 64])

wd1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1000], stddev = 0.03), name = 'wd1')
bd1 = tf.Variable(tf.truncated_normal([1000], stddev = 0.01), name = 'bd1')

dense_layer1 = tf.matmul(flattened, wd1) + bd1
dense_layer1 = tf.nn.relu(dense_layer1)

Step 6 - Un altro livello con attivazioni softmax specifiche con l'ottimizzatore richiesto definisce la valutazione dell'accuratezza, che rende operatore il setup di inizializzazione.

wd2 = tf.Variable(tf.truncated_normal([1000, 10], stddev = 0.03), name = 'wd2')
bd2 = tf.Variable(tf.truncated_normal([10], stddev = 0.01), name = 'bd2')

dense_layer2 = tf.matmul(dense_layer1, wd2) + bd2
y_ = tf.nn.softmax(dense_layer2)

cross_entropy = tf.reduce_mean(
   tf.nn.softmax_cross_entropy_with_logits(logits = dense_layer2, labels = y))

optimiser = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init_op = tf.global_variables_initializer()

Step 7- Dovremmo impostare le variabili di registrazione. Questo aggiunge un riepilogo per memorizzare l'accuratezza dei dati.

tf.summary.scalar('accuracy', accuracy)
   merged = tf.summary.merge_all()
   writer = tf.summary.FileWriter('E:\TensorFlowProject')
   
   with tf.Session() as sess:
      sess.run(init_op)
      total_batch = int(len(mnist.train.labels) / batch_size)
      
      for epoch in range(epochs):
         avg_cost = 0
      for i in range(total_batch):
         batch_x, batch_y = mnist.train.next_batch(batch_size = batch_size)
            _, c = sess.run([optimiser, cross_entropy], feed_dict = {
            x:batch_x, y: batch_y})
            avg_cost += c / total_batch
         test_acc = sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
            summary = sess.run(merged, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
         writer.add_summary(summary, epoch)

   print("\nTraining complete!")
   writer.add_graph(sess.graph)
   print(sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
      mnist.test.labels}))

def create_new_conv_layer(
   input_data, num_input_channels, num_filters,filter_shape, pool_shape, name):

   conv_filt_shape = [
      filter_shape[0], filter_shape[1], num_input_channels, num_filters]

   weights = tf.Variable(
      tf.truncated_normal(conv_filt_shape, stddev = 0.03), name = name+'_W')
   bias = tf.Variable(tf.truncated_normal([num_filters]), name = name+'_b')

#Out layer defines the output
   out_layer =
      tf.nn.conv2d(input_data, weights, [1, 1, 1, 1], padding = 'SAME')

   out_layer += bias
   out_layer = tf.nn.relu(out_layer)
   ksize = [1, pool_shape[0], pool_shape[1], 1]
   strides = [1, 2, 2, 1]
   out_layer = tf.nn.max_pool(
      out_layer, ksize = ksize, strides = strides, padding = 'SAME')

   return out_layer

if __name__ == "__main__":
run_cnn()

Di seguito è riportato l'output generato dal codice sopra -

See @{tf.nn.softmax_cross_entropy_with_logits_v2}.

2018-09-19 17:22:58.802268: I
T:\src\github\tensorflow\tensorflow\core\platform\cpu_feature_guard.cc:140]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2

2018-09-19 17:25:41.522845: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

2018-09-19 17:25:44.630941: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 501760000 exceeds 10% of system memory.

Epoch: 1 cost = 0.676 test accuracy: 0.940

2018-09-19 17:26:51.987554: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

Le reti neurali ricorrenti sono un tipo di algoritmo orientato al deep learning, che segue un approccio sequenziale. Nelle reti neurali, assumiamo sempre che ogni input e output sia indipendente da tutti gli altri livelli. Questo tipo di reti neurali sono chiamate ricorrenti perché eseguono calcoli matematici in modo sequenziale.

Considera i seguenti passaggi per addestrare una rete neurale ricorrente:

Step 1 - Immettere un esempio specifico dal set di dati.

Step 2 - La rete prenderà un esempio e calcolerà alcuni calcoli utilizzando variabili inizializzate casualmente.

Step 3 - Viene quindi calcolato un risultato previsto.

Step 4 - Il confronto del risultato effettivo generato con il valore atteso produrrà un errore.

Step 5 - Per tracciare l'errore, viene propagato attraverso lo stesso percorso in cui vengono regolate anche le variabili.

Step 6 - I passaggi da 1 a 5 vengono ripetuti fino a quando non siamo sicuri che le variabili dichiarate per ottenere l'output siano definite correttamente.

Step 7 - Viene effettuata una previsione sistematica applicando queste variabili per ottenere nuovi input invisibili.

L'approccio schematico per rappresentare le reti neurali ricorrenti è descritto di seguito:

Implementazione ricorrente della rete neurale con TensorFlow

In questa sezione, impareremo come implementare una rete neurale ricorrente con TensorFlow.

Step 1 - TensorFlow include varie librerie per l'implementazione specifica del modulo di rete neurale ricorrente.

#Import necessary modules
from __future__ import print_function

import tensorflow as tf
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

Come accennato in precedenza, le librerie aiutano a definire i dati di input, che costituiscono la parte principale dell'implementazione della rete neurale ricorrente.

Step 2- Il nostro motivo principale è classificare le immagini utilizzando una rete neurale ricorrente, dove consideriamo ogni riga di immagini come una sequenza di pixel. La forma dell'immagine MNIST è specificatamente definita come 28 * 28 px. Ora gestiremo 28 sequenze di 28 passaggi per ogni campione menzionato. Definiremo i parametri di input per ottenere il modello sequenziale.

n_input = 28 # MNIST data input with img shape 28*28
n_steps = 28
n_hidden = 128
n_classes = 10

# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes]
weights = {
   'out': tf.Variable(tf.random_normal([n_hidden, n_classes]))
}
biases = {
   'out': tf.Variable(tf.random_normal([n_classes]))
}

Step 3- Calcola i risultati utilizzando una funzione definita in RNN per ottenere i migliori risultati. Qui, ogni forma di dati viene confrontata con la forma di input corrente e i risultati vengono calcolati per mantenere il tasso di precisione.

def RNN(x, weights, biases):
   x = tf.unstack(x, n_steps, 1)

   # Define a lstm cell with tensorflow
   lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)

   # Get lstm cell output
   outputs, states = rnn.static_rnn(lstm_cell, x, dtype = tf.float32)

   # Linear activation, using rnn inner loop last output
   return tf.matmul(outputs[-1], weights['out']) + biases['out']

pred = RNN(x, weights, biases)

# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initializing the variables
init = tf.global_variables_initializer()

Step 4- In questa fase, lanceremo il grafico per ottenere i risultati computazionali. Questo aiuta anche a calcolare l'accuratezza dei risultati dei test.

with tf.Session() as sess:
   sess.run(init)
   step = 1
   # Keep training until reach max iterations
   
   while step * batch_size < training_iters:
      batch_x, batch_y = mnist.train.next_batch(batch_size)
      batch_x = batch_x.reshape((batch_size, n_steps, n_input))
      sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
      
      if step % display_step == 0:
         # Calculate batch accuracy
         acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})
         
         # Calculate batch loss
         loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
         
         print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
            "{:.6f}".format(loss) + ", Training Accuracy= " + \
            "{:.5f}".format(acc))
      step += 1
   print("Optimization Finished!")
      test_len = 128
   test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
   
   test_label = mnist.test.labels[:test_len]
   print("Testing Accuracy:", \
      sess.run(accuracy, feed_dict={x: test_data, y: test_label}))

Gli screenshot seguenti mostrano l'output generato -

TensorFlow include uno strumento di visualizzazione, chiamato TensorBoard. Viene utilizzato per analizzare il grafico del flusso di dati e anche per comprendere i modelli di apprendimento automatico. L'importante caratteristica di TensorBoard include una visualizzazione di diversi tipi di statistiche sui parametri e dettagli di qualsiasi grafico in allineamento verticale.

La rete neurale profonda include fino a 36.000 nodi. TensorBoard aiuta a collassare questi nodi in blocchi di alto livello e ad evidenziare le strutture identiche. Ciò consente una migliore analisi del grafico concentrandosi sulle sezioni primarie del grafico di calcolo. Si dice che la visualizzazione di TensorBoard sia molto interattiva in cui un utente può eseguire una panoramica, ingrandire ed espandere i nodi per visualizzare i dettagli.

La seguente rappresentazione schematica del diagramma mostra il funzionamento completo della visualizzazione di TensorBoard:

Gli algoritmi comprimono i nodi in blocchi di alto livello ed evidenziano i gruppi specifici con strutture identiche, che separano i nodi di alto livello. Il TensorBoard così creato è utile ed è considerato altrettanto importante per l'ottimizzazione di un modello di machine learning. Questo strumento di visualizzazione è progettato per il file di registro della configurazione con informazioni di riepilogo e dettagli che devono essere visualizzati.

Concentriamoci sull'esempio demo della visualizzazione di TensorBoard con l'aiuto del codice seguente:

import tensorflow as tf 

# Constants creation for TensorBoard visualization 
a = tf.constant(10,name = "a") 
b = tf.constant(90,name = "b") 
y = tf.Variable(a+b*2,name = 'y') 
model = tf.initialize_all_variables() #Creation of model 

with tf.Session() as session: 
   merged = tf.merge_all_summaries() 
   writer = tf.train.SummaryWriter("/tmp/tensorflowlogs",session.graph) 
   session.run(model) 
   print(session.run(y))

La tabella seguente mostra i vari simboli della visualizzazione TensorBoard utilizzati per la rappresentazione del nodo:

L'incorporamento di parole è il concetto di mappatura da oggetti discreti come parole a vettori e numeri reali. È importante per l'input per l'apprendimento automatico. Il concetto include funzioni standard, che trasformano efficacemente oggetti di input discreti in vettori utili.

L'illustrazione di esempio dell'input di word embedding è mostrata di seguito:

blue: (0.01359, 0.00075997, 0.24608, ..., -0.2524, 1.0048, 0.06259)
blues: (0.01396, 0.11887, -0.48963, ..., 0.033483, -0.10007, 0.1158)
orange: (-0.24776, -0.12359, 0.20986, ..., 0.079717, 0.23865, -0.014213)
oranges: (-0.35609, 0.21854, 0.080944, ..., -0.35413, 0.38511, -0.070976)

Word2vec

Word2vec è l'approccio più comune utilizzato per la tecnica di incorporamento di parole senza supervisione. Addestra il modello in modo tale che una data parola di input preveda il contesto della parola utilizzando skip-grammi.

TensorFlow consente molti modi per implementare questo tipo di modello con livelli crescenti di sofisticazione e ottimizzazione e utilizzando concetti di multithreading e astrazioni di livello superiore.

import os 
import math 
import numpy as np 
import tensorflow as tf 

from tensorflow.contrib.tensorboard.plugins import projector 
batch_size = 64 
embedding_dimension = 5 
negative_samples = 8 
LOG_DIR = "logs/word2vec_intro" 

digit_to_word_map = {
   1: "One", 
   2: "Two", 
   3: "Three", 
   4: "Four", 
   5: "Five", 
   6: "Six", 
   7: "Seven", 
   8: "Eight", 
   9: "Nine"} 
sentences = [] 

# Create two kinds of sentences - sequences of odd and even digits. 
   for i in range(10000): 
   rand_odd_ints = np.random.choice(range(1, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_odd_ints])) 
   rand_even_ints = np.random.choice(range(2, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_even_ints])) 
   
# Map words to indices
word2index_map = {} 
index = 0 

for sent in sentences: 
   for word in sent.lower().split(): 
   
   if word not in word2index_map: 
      word2index_map[word] = index 
      index += 1 
index2word_map = {index: word for word, index in word2index_map.items()} 

vocabulary_size = len(index2word_map) 

# Generate skip-gram pairs 
skip_gram_pairs = [] 

for sent in sentences: 
   tokenized_sent = sent.lower().split() 
   
   for i in range(1, len(tokenized_sent)-1):        
      word_context_pair = [[word2index_map[tokenized_sent[i-1]], 
         word2index_map[tokenized_sent[i+1]]], word2index_map[tokenized_sent[i]]] 
      
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][0]]) 
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][1]]) 

def get_skipgram_batch(batch_size): 
   instance_indices = list(range(len(skip_gram_pairs))) 
      np.random.shuffle(instance_indices)
   batch = instance_indices[:batch_size] 
   x = [skip_gram_pairs[i][0] for i in batch] 
   y = [[skip_gram_pairs[i][1]] for i in batch] 
   return x, y 
   
# batch example 
x_batch, y_batch = get_skipgram_batch(8) 
x_batch 
y_batch 
[index2word_map[word] for word in x_batch] [index2word_map[word[0]] for word in y_batch] 

# Input data, labels train_inputs = tf.placeholder(tf.int32, shape = [batch_size]) 
   train_labels = tf.placeholder(tf.int32, shape = [batch_size, 1]) 

# Embedding lookup table currently only implemented in CPU with 
   tf.name_scope("embeddings"): 
   embeddings = tf.Variable(    
      tf.random_uniform([vocabulary_size, embedding_dimension], -1.0, 1.0), 
         name = 'embedding') 
   # This is essentialy a lookup table 
   embed = tf.nn.embedding_lookup(embeddings, train_inputs) 
   
# Create variables for the NCE loss
nce_weights = tf.Variable(     
   tf.truncated_normal([vocabulary_size, embedding_dimension], stddev = 1.0 / 
      math.sqrt(embedding_dimension))) 
   
nce_biases = tf.Variable(tf.zeros([vocabulary_size])) 

loss = tf.reduce_mean(     
   tf.nn.nce_loss(weights = nce_weights, biases = nce_biases, inputs = embed, 
   labels = train_labels,num_sampled = negative_samples, 
   num_classes = vocabulary_size)) tf.summary.scalar("NCE_loss", loss) 
   
# Learning rate decay 
global_step = tf.Variable(0, trainable = False) 
   learningRate = tf.train.exponential_decay(learning_rate = 0.1, 
   global_step = global_step, decay_steps = 1000, decay_rate = 0.95, staircase = True) 

train_step = tf.train.GradientDescentOptimizer(learningRate).minimize(loss) 
   merged = tf.summary.merge_all() 
with tf.Session() as sess: 
   train_writer = tf.summary.FileWriter(LOG_DIR,    
      graph = tf.get_default_graph()) 
   saver = tf.train.Saver() 
   
   with open(os.path.join(LOG_DIR, 'metadata.tsv'), "w") as metadata: 
      metadata.write('Name\tClass\n') for k, v in index2word_map.items(): 
      metadata.write('%s\t%d\n' % (v, k)) 
   
   config = projector.ProjectorConfig() 
   embedding = config.embeddings.add() embedding.tensor_name = embeddings.name 
   
   # Link this tensor to its metadata file (e.g. labels). 
   embedding.metadata_path = os.path.join(LOG_DIR, 'metadata.tsv') 
      projector.visualize_embeddings(train_writer, config) 
   
   tf.global_variables_initializer().run() 
   
   for step in range(1000): 
      x_batch, y_batch = get_skipgram_batch(batch_size) summary, _ = sess.run(
         [merged, train_step], feed_dict = {train_inputs: x_batch, train_labels: y_batch})
      train_writer.add_summary(summary, step)
      
      if step % 100 == 0:
         saver.save(sess, os.path.join(LOG_DIR, "w2v_model.ckpt"), step)
         loss_value = sess.run(loss, feed_dict = {
            train_inputs: x_batch, train_labels: y_batch})
         print("Loss at %d: %.5f" % (step, loss_value))

   # Normalize embeddings before using
   norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims = True))
   normalized_embeddings = embeddings /
      norm normalized_embeddings_matrix = sess.run(normalized_embeddings)
   
ref_word = normalized_embeddings_matrix[word2index_map["one"]]

cosine_dists = np.dot(normalized_embeddings_matrix, ref_word)
ff = np.argsort(cosine_dists)[::-1][1:10] for f in ff: print(index2word_map[f])
print(cosine_dists[f])

Produzione

Il codice precedente genera il seguente output:

Per comprendere il perceptron a strato singolo, è importante comprendere le reti neurali artificiali (ANN). Le reti neurali artificiali sono il sistema di elaborazione delle informazioni il cui meccanismo si ispira alla funzionalità dei circuiti neurali biologici. Una rete neurale artificiale possiede molte unità di elaborazione collegate tra loro. Di seguito è riportata la rappresentazione schematica della rete neurale artificiale:

Il diagramma mostra che le unità nascoste comunicano con il livello esterno. Mentre le unità di input e output comunicano solo attraverso lo strato nascosto della rete.

Il modello di connessione con i nodi, il numero totale di strati e il livello di nodi tra input e output con il numero di neuroni per strato definiscono l'architettura di una rete neurale.

Esistono due tipi di architettura. Questi tipi si concentrano sulla funzionalità delle reti neurali artificiali come segue:

• Perceptron a strato singolo
• Perceptron multistrato

Perceptron a strato singolo

Il perceptron a strato singolo è il primo modello neurale proposto creato. Il contenuto della memoria locale del neurone è costituito da un vettore di pesi. Il calcolo di un perceptron a singolo strato viene eseguito sul calcolo della somma del vettore di input ciascuno con il valore moltiplicato per l'elemento corrispondente del vettore dei pesi. Il valore visualizzato nell'uscita sarà l'ingresso di una funzione di attivazione.

Concentriamoci sull'implementazione del perceptron a strato singolo per un problema di classificazione delle immagini utilizzando TensorFlow. Il miglior esempio per illustrare il perceptron a strato singolo è attraverso la rappresentazione di "Regressione logistica".

Consideriamo ora i seguenti passaggi di base della regressione logistica dell'addestramento:

• I pesi vengono inizializzati con valori casuali all'inizio dell'addestramento.

• Per ogni elemento del training set, l'errore viene calcolato con la differenza tra l'output desiderato e l'output effettivo. L'errore calcolato viene utilizzato per regolare i pesi.

• Il processo viene ripetuto fino a quando l'errore commesso sull'intero training set non è inferiore alla soglia specificata, fino al raggiungimento del numero massimo di iterazioni.

Di seguito è indicato il codice completo per la valutazione della regressione logistica:

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.01 
training_epochs = 25 
batch_size = 100 
display_step = 1 

# tf Graph Input 
x = tf.placeholder("float", [None, 784]) # mnist data image of shape 28*28 = 784 
y = tf.placeholder("float", [None, 10]) # 0-9 digits recognition => 10 classes 

# Create model 
# Set model weights 
W = tf.Variable(tf.zeros([784, 10])) 
b = tf.Variable(tf.zeros([10])) 

# Construct model 
activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax 

# Minimize error using cross entropy 
cross_entropy = y*tf.log(activation) 
cost = tf.reduce_mean\ (-tf.reduce_sum\ (cross_entropy,reduction_indices = 1)) 

optimizer = tf.train.\ GradientDescentOptimizer(learning_rate).minimize(cost) 

#Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables init = tf.initialize_all_variables()
# Launch the graph 
with tf.Session() as sess:
   sess.run(init)
   
   # Training cycle
   for epoch in range(training_epochs):
      avg_cost = 0.
      total_batch = int(mnist.train.num_examples/batch_size)
      
      # Loop over all batches
      for i in range(total_batch):
         batch_xs, batch_ys = \ mnist.train.next_batch(batch_size)
         # Fit training using batch data sess.run(optimizer, \ feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss avg_cost += sess.run(cost, \ feed_dict = {
            x: batch_xs, \ y: batch_ys})/total_batch
      # Display logs per epoch step
      if epoch % display_step == 0:
         print ("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
            avg_set.append(avg_cost) epoch_set.append(epoch+1)
   print ("Training phase finished")
    
   plt.plot(epoch_set,avg_set, 'o', label = 'Logistic Regression Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
    
   # Test model 
   correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print 
      ("Model accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

Produzione

Il codice precedente genera il seguente output:

La regressione logistica è considerata un'analisi predittiva. La regressione logistica viene utilizzata per descrivere i dati e per spiegare la relazione tra una variabile binaria dipendente e una o più variabili nominali o indipendenti.

In questo capitolo, ci concentreremo sull'esempio di base dell'implementazione della regressione lineare utilizzando TensorFlow. La regressione logistica o regressione lineare è un approccio di apprendimento automatico supervisionato per la classificazione di categorie discrete di ordine. Il nostro obiettivo in questo capitolo è costruire un modello in base al quale un utente possa prevedere la relazione tra le variabili predittive e una o più variabili indipendenti.

La relazione tra queste due variabili è considerata lineare. Se y è la variabile dipendente e x è considerata la variabile indipendente, la relazione di regressione lineare di due variabili sarà simile alla seguente equazione:

Y = Ax+b

Progetteremo un algoritmo per la regressione lineare. Questo ci permetterà di comprendere i seguenti due importanti concetti:

• Funzione di costo
• Algoritmi di discesa del gradiente

La rappresentazione schematica della regressione lineare è menzionata di seguito:

La vista grafica dell'equazione della regressione lineare è menzionata di seguito:

Passaggi per progettare un algoritmo per la regressione lineare

Ora impareremo i passaggi che aiutano nella progettazione di un algoritmo per la regressione lineare.

Passo 1

È importante importare i moduli necessari per tracciare il modulo di regressione lineare. Iniziamo importando la libreria Python NumPy e Matplotlib.

import numpy as np 
import matplotlib.pyplot as plt

Passo 2

Definire il numero di coefficienti necessari per la regressione logistica.

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78

Passaggio 3

Itera le variabili per generare 300 punti casuali attorno all'equazione di regressione -

Y = 0,22x + 0,78

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y])

Passaggio 4

Visualizza i punti generati utilizzando Matplotlib.

fplt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() plt.show()

Il codice completo per la regressione logistica è il seguente:

import numpy as np 
import matplotlib.pyplot as plt 

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78 

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y]) 
   
plt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() 
plt.show()

Il numero di punti che viene preso come input è considerato come dati di input.

TFLearn può essere definito come un aspetto di deep learning modulare e trasparente utilizzato nel framework TensorFlow. Il motivo principale di TFLearn è fornire un'API di livello superiore a TensorFlow per facilitare e mostrare nuovi esperimenti.

Considera le seguenti importanti caratteristiche di TFLearn:

• TFLearn è facile da usare e da capire.

• Comprende concetti semplici per costruire livelli di rete altamente modulari, ottimizzatori e varie metriche incorporate al loro interno.

• Include la piena trasparenza con il sistema di lavoro TensorFlow.

• Include potenti funzioni di supporto per addestrare i tensori incorporati che accettano più input, output e ottimizzatori.

• Include una visualizzazione grafica semplice e bella.

• La visualizzazione del grafico include vari dettagli di pesi, gradienti e attivazioni.

Installa TFLearn eseguendo il seguente comando:

pip install tflearn

All'esecuzione del codice precedente, verrà generato il seguente output:

La figura seguente mostra l'implementazione di TFLearn con il classificatore Random Forest -

from __future__ import division, print_function, absolute_import

#TFLearn module implementation
import tflearn
from tflearn.estimators import RandomForestClassifier

# Data loading and pre-processing with respect to dataset
import tflearn.datasets.mnist as mnist
X, Y, testX, testY = mnist.load_data(one_hot = False)

m = RandomForestClassifier(n_estimators = 100, max_nodes = 1000)
m.fit(X, Y, batch_size = 10000, display_step = 10)

print("Compute the accuracy on train data:")
print(m.evaluate(X, Y, tflearn.accuracy_op))

print("Compute the accuracy on test set:")
print(m.evaluate(testX, testY, tflearn.accuracy_op))

print("Digits for test images id 0 to 5:")
print(m.predict(testX[:5]))

print("True digits:")
print(testY[:5])

In questo capitolo, ci concentreremo sulla differenza tra CNN e RNN -

CNN	RNN
È adatto per dati spaziali come le immagini.	RNN è adatto per dati temporali, chiamati anche dati sequenziali.
La CNN è considerata più potente della RNN.	RNN include una minore compatibilità delle funzionalità rispetto alla CNN.
Questa rete accetta input di dimensione fissa e genera output di dimensione fissa.	RNN può gestire lunghezze di input / output arbitrarie.
La CNN è un tipo di rete neurale artificiale feed-forward con variazioni di percettroni multistrato progettati per utilizzare quantità minime di preelaborazione.	RNN, a differenza delle reti neurali feed forward, può utilizzare la propria memoria interna per elaborare sequenze arbitrarie di input.
Le CNN utilizzano il modello di connettività tra i neuroni. Questo è ispirato dall'organizzazione della corteccia visiva animale, i cui singoli neuroni sono disposti in modo tale da rispondere a regioni sovrapposte che piastrellano il campo visivo.	Le reti neurali ricorrenti utilizzano informazioni di serie temporali: ciò che un utente ha parlato per ultimo avrà un impatto su ciò che parlerà dopo.
Le CNN sono ideali per l'elaborazione di immagini e video.	Gli RNN sono ideali per l'analisi del testo e del parlato.

La seguente illustrazione mostra la rappresentazione schematica di CNN e RNN -

Keras è una libreria Python compatta, facile da imparare e di alto livello eseguita sul framework TensorFlow. È realizzato con l'obiettivo di comprendere le tecniche di apprendimento profondo, come la creazione di livelli per le reti neurali mantenendo i concetti di forme e dettagli matematici. La creazione di freamework può essere dei seguenti due tipi:

• API sequenziale
• API funzionale

Considera i seguenti otto passaggi per creare un modello di apprendimento profondo in Keras:

• Caricamento dei dati
• Pre-processare i dati caricati
• Definizione di modello
• Compilazione del modello
• Adatta il modello specificato
• Valutalo
• Fai le previsioni richieste
• Salva il modello

Useremo il Jupyter Notebook per l'esecuzione e la visualizzazione dell'output come mostrato di seguito -

Step 1 - Il caricamento dei dati e la preelaborazione dei dati caricati vengono implementati per primi per eseguire il modello di apprendimento profondo.

import warnings
warnings.filterwarnings('ignore')

import numpy as np
np.random.seed(123) # for reproducibility

from keras.models import Sequential
from keras.layers import Flatten, MaxPool2D, Conv2D, Dense, Reshape, Dropout
from keras.utils import np_utils
Using TensorFlow backend.
from keras.datasets import mnist

# Load pre-shuffled MNIST data into train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)

Questo passaggio può essere definito come "Importa librerie e moduli", il che significa che tutte le librerie e i moduli vengono importati come passaggio iniziale.

Step 2 - In questa fase definiremo l'architettura del modello -

model = Sequential()
model.add(Conv2D(32, 3, 3, activation = 'relu', input_shape = (28,28,1)))
model.add(Conv2D(32, 3, 3, activation = 'relu'))
model.add(MaxPool2D(pool_size = (2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation = 'softmax'))

Step 3 - Compiliamo ora il modello specificato -

model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

Step 4 - Ora adatteremo il modello utilizzando i dati di addestramento -

model.fit(X_train, Y_train, batch_size = 32, epochs = 10, verbose = 1)

L'output delle iterazioni create è il seguente:

Epoch 1/10 60000/60000 [==============================] - 65s - 
loss: 0.2124 - 
acc: 0.9345 
Epoch 2/10 60000/60000 [==============================] - 62s - 
loss: 0.0893 - 
acc: 0.9740 
Epoch 3/10 60000/60000 [==============================] - 58s - 
loss: 0.0665 - 
acc: 0.9802 
Epoch 4/10 60000/60000 [==============================] - 62s - 
loss: 0.0571 - 
acc: 0.9830 
Epoch 5/10 60000/60000 [==============================] - 62s - 
loss: 0.0474 - 
acc: 0.9855 
Epoch 6/10 60000/60000 [==============================] - 59s -
loss: 0.0416 - 
acc: 0.9871 
Epoch 7/10 60000/60000 [==============================] - 61s - 
loss: 0.0380 - 
acc: 0.9877 
Epoch 8/10 60000/60000 [==============================] - 63s - 
loss: 0.0333 - 
acc: 0.9895 
Epoch 9/10 60000/60000 [==============================] - 64s - 
loss: 0.0325 - 
acc: 0.9898 
Epoch 10/10 60000/60000 [==============================] - 60s - 
loss: 0.0284 - 
acc: 0.9910

Questo capitolo si concentrerà su come iniziare con TensorFlow distribuito. Lo scopo è aiutare gli sviluppatori a comprendere i concetti di base di TF distribuito che si stanno ripetendo, come i server TF. Useremo il Jupyter Notebook per valutare TensorFlow distribuito. L'implementazione dell'elaborazione distribuita con TensorFlow è menzionata di seguito:

Step 1 - Importa i moduli necessari obbligatori per il calcolo distribuito -

import tensorflow as tf

Step 2- Crea un cluster TensorFlow con un nodo. Lascia che questo nodo sia responsabile di un lavoro che abbia il nome "worker" e che opererà un take su localhost: 2222.

cluster_spec = tf.train.ClusterSpec({'worker' : ['localhost:2222']})
server = tf.train.Server(cluster_spec)
server.target

Gli script precedenti generano il seguente output:

'grpc://localhost:2222'
The server is currently running.

Step 3 - La configurazione del server con la rispettiva sessione può essere calcolata eseguendo il seguente comando -

server.server_def

Il comando precedente genera il seguente output:

cluster {
   job {
      name: "worker"
      tasks {
         value: "localhost:2222"
      }
   }
}
job_name: "worker"
protocol: "grpc"

Step 4- Avvia una sessione TensorFlow con il motore di esecuzione come server. Usa TensorFlow per creare un server locale e usalsof per scoprire la posizione del server.

sess = tf.Session(target = server.target)
server = tf.train.Server.create_local_server()

Step 5 - Visualizza i dispositivi disponibili in questa sessione e chiudi la rispettiva sessione.

devices = sess.list_devices()
for d in devices:
   print(d.name)
sess.close()

Il comando precedente genera il seguente output:

/job:worker/replica:0/task:0/device:CPU:0

Qui ci concentreremo sulla formazione di MetaGraph in TensorFlow. Questo ci aiuterà a comprendere il modulo di esportazione in TensorFlow. Il MetaGraph contiene le informazioni di base, necessarie per addestrare, eseguire valutazioni o eseguire inferenze su un grafico precedentemente addestrato.

Di seguito è riportato lo snippet di codice per lo stesso:

def export_meta_graph(filename = None, collection_list = None, as_text = False): 
   """this code writes `MetaGraphDef` to save_path/filename. 
   
   Arguments: 
   filename: Optional meta_graph filename including the path. collection_list: 
      List of string keys to collect. as_text: If `True`, 
      writes the meta_graph as an ASCII proto. 
   
   Returns: 
   A `MetaGraphDef` proto. """

Uno dei modelli di utilizzo tipici per lo stesso è menzionato di seguito:

# Build the model ... 
with tf.Session() as sess: 
   # Use the model ... 
# Export the model to /tmp/my-model.meta. 
meta_graph_def = tf.train.export_meta_graph(filename = '/tmp/my-model.meta')

Il perceptron multistrato definisce l'architettura più complicata delle reti neurali artificiali. È sostanzialmente formato da più strati di perceptron.

La rappresentazione schematica dell'apprendimento percettrone multistrato è come mostrato di seguito:

Le reti MLP vengono solitamente utilizzate per il formato di apprendimento supervisionato. Un tipico algoritmo di apprendimento per le reti MLP è anche chiamato algoritmo di propagazione posteriore.

Ora ci concentreremo sull'implementazione con MLP per un problema di classificazione delle immagini.

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.001 
training_epochs = 20 
batch_size = 100 
display_step = 1 

# Network Parameters 
n_hidden_1 = 256 

# 1st layer num features
n_hidden_2 = 256 # 2nd layer num features 
n_input = 784 # MNIST data input (img shape: 28*28) n_classes = 10 
# MNIST total classes (0-9 digits) 

# tf Graph input 
x = tf.placeholder("float", [None, n_input]) 
y = tf.placeholder("float", [None, n_classes]) 

# weights layer 1 
h = tf.Variable(tf.random_normal([n_input, n_hidden_1])) # bias layer 1 
bias_layer_1 = tf.Variable(tf.random_normal([n_hidden_1])) 
# layer 1 layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, h), bias_layer_1)) 

# weights layer 2 
w = tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])) 

# bias layer 2 
bias_layer_2 = tf.Variable(tf.random_normal([n_hidden_2])) 

# layer 2 
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, w), bias_layer_2)) 

# weights output layer 
output = tf.Variable(tf.random_normal([n_hidden_2, n_classes])) 

# biar output layer 
bias_output = tf.Variable(tf.random_normal([n_classes])) # output layer 
output_layer = tf.matmul(layer_2, output) + bias_output

# cost function 
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
   logits = output_layer, labels = y)) 

#cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output_layer, y)) 
# optimizer 
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost) 

# optimizer = tf.train.GradientDescentOptimizer(
   learning_rate = learning_rate).minimize(cost) 

# Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables 
init = tf.global_variables_initializer() 

# Launch the graph 
with tf.Session() as sess: 
   sess.run(init) 
   
   # Training cycle
   for epoch in range(training_epochs): 
      avg_cost = 0. 
      total_batch = int(mnist.train.num_examples / batch_size) 
      
      # Loop over all batches 
      for i in range(total_batch): 
         batch_xs, batch_ys = mnist.train.next_batch(batch_size) 
         # Fit training using batch data sess.run(optimizer, feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss 
         avg_cost += sess.run(cost, feed_dict = {x: batch_xs, y: batch_ys}) / total_batch
      # Display logs per epoch step 
      if epoch % display_step == 0: 
         print 
         Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost)
      avg_set.append(avg_cost) 
      epoch_set.append(epoch + 1)
   print 
   "Training phase finished" 
   
   plt.plot(epoch_set, avg_set, 'o', label = 'MLP Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
   
   # Test model 
   correct_prediction = tf.equal(tf.argmax(output_layer, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 
   print 
   "Model Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})

La riga di codice sopra genera il seguente output:

In questo capitolo, ci concentreremo sulla rete che dovremo imparare da un insieme noto di punti chiamati x e f (x). Un singolo livello nascosto costruirà questa semplice rete.

Il codice per la spiegazione degli strati nascosti del perceptron è come mostrato di seguito:

#Importing the necessary modules 
import tensorflow as tf 
import numpy as np 
import math, random 
import matplotlib.pyplot as plt 

np.random.seed(1000) 
function_to_learn = lambda x: np.cos(x) + 0.1*np.random.randn(*x.shape) 
layer_1_neurons = 10 
NUM_points = 1000 

#Training the parameters 
batch_size = 100 
NUM_EPOCHS = 1500 

all_x = np.float32(np.random.uniform(-2*math.pi, 2*math.pi, (1, NUM_points))).T 
   np.random.shuffle(all_x) 

train_size = int(900) 
#Training the first 700 points in the given set x_training = all_x[:train_size] 
y_training = function_to_learn(x_training)

#Training the last 300 points in the given set x_validation = all_x[train_size:] 
y_validation = function_to_learn(x_validation) 

plt.figure(1) 
plt.scatter(x_training, y_training, c = 'blue', label = 'train') 
plt.scatter(x_validation, y_validation, c = 'pink', label = 'validation') 
plt.legend() 
plt.show()

X = tf.placeholder(tf.float32, [None, 1], name = "X")
Y = tf.placeholder(tf.float32, [None, 1], name = "Y")

#first layer 
#Number of neurons = 10 
w_h = tf.Variable(
   tf.random_uniform([1, layer_1_neurons],\ minval = -1, maxval = 1, dtype = tf.float32)) 
b_h = tf.Variable(tf.zeros([1, layer_1_neurons], dtype = tf.float32)) 
h = tf.nn.sigmoid(tf.matmul(X, w_h) + b_h)

#output layer 
#Number of neurons = 10 
w_o = tf.Variable(
   tf.random_uniform([layer_1_neurons, 1],\ minval = -1, maxval = 1, dtype = tf.float32)) 
b_o = tf.Variable(tf.zeros([1, 1], dtype = tf.float32)) 

#build the model 
model = tf.matmul(h, w_o) + b_o 

#minimize the cost function (model - Y) 
train_op = tf.train.AdamOptimizer().minimize(tf.nn.l2_loss(model - Y)) 

#Start the Learning phase 
sess = tf.Session() sess.run(tf.initialize_all_variables()) 

errors = [] 
for i in range(NUM_EPOCHS): 
   for start, end in zip(range(0, len(x_training), batch_size),\ 
      range(batch_size, len(x_training), batch_size)): 
      sess.run(train_op, feed_dict = {X: x_training[start:end],\ Y: y_training[start:end]})
   cost = sess.run(tf.nn.l2_loss(model - y_validation),\ feed_dict = {X:x_validation}) 
   errors.append(cost) 
   
   if i%100 == 0: 
      print("epoch %d, cost = %g" % (i, cost)) 
      
plt.plot(errors,label='MLP Function Approximation') plt.xlabel('epochs') 
plt.ylabel('cost') 
plt.legend() 
plt.show()

Produzione

Di seguito è riportata la rappresentazione dell'approssimazione del layer funzionale:

Qui due dati sono rappresentati in forma di W. I due dati sono: train e validation che sono rappresentati in colori distinti come visibili nella sezione legenda.

Gli ottimizzatori sono la classe estesa, che include informazioni aggiuntive per addestrare un modello specifico. La classe optimizer viene inizializzata con parametri dati, ma è importante ricordare che non è necessario alcun tensore. Gli ottimizzatori vengono utilizzati per migliorare la velocità e le prestazioni per l'addestramento di un modello specifico.

L'ottimizzatore di base di TensorFlow è:

tf.train.Optimizer

Questa classe è definita nel percorso specificato di tensorflow / python / training / optimizer.py.

Di seguito sono riportati alcuni ottimizzatori in Tensorflow:

• Discesa stocastica in gradiente
• Stocastico Discesa gradiente con clipping gradiente
• Momentum
• Lo slancio di Nesterov
• Adagrad
• Adadelta
• RMSProp
• Adam
• Adamax
• SMORMS3

Ci concentreremo sulla discesa Stochastic Gradient. L'illustrazione per creare l'ottimizzatore per lo stesso è menzionata di seguito:

def sgd(cost, params, lr = np.float32(0.01)):
   g_params = tf.gradients(cost, params)
   updates = []
   
   for param, g_param in zip(params, g_params):
      updates.append(param.assign(param - lr*g_param))
   return updates

I parametri di base sono definiti all'interno della specifica funzione. Nel capitolo successivo, ci concentreremo sull'ottimizzazione della discesa del gradiente con l'implementazione di ottimizzatori.

In questo capitolo apprenderemo l'implementazione di XOR utilizzando TensorFlow. Prima di iniziare con l'implementazione di XOR in TensorFlow, vediamo i valori della tabella XOR. Questo ci aiuterà a comprendere il processo di crittografia e decrittografia.

UN	B	UN XOR B
0	0	0
0	1	1
1	0	1
1	1	0

Il metodo di crittografia XOR Cipher viene fondamentalmente utilizzato per crittografare i dati che è difficile da decifrare con il metodo della forza bruta, ovvero generando chiavi di crittografia casuali che corrispondono alla chiave appropriata.

Il concetto di implementazione con XOR Cipher è definire una chiave di crittografia XOR e quindi eseguire l'operazione XOR dei caratteri nella stringa specificata con questa chiave, che un utente tenta di crittografare. Ora ci concentreremo sull'implementazione di XOR utilizzando TensorFlow, menzionato di seguito:

#Declaring necessary modules
import tensorflow as tf
import numpy as np
"""
A simple numpy implementation of a XOR gate to understand the backpropagation
algorithm
"""

x = tf.placeholder(tf.float64,shape = [4,2],name = "x")
#declaring a place holder for input x
y = tf.placeholder(tf.float64,shape = [4,1],name = "y")
#declaring a place holder for desired output y

m = np.shape(x)[0]#number of training examples
n = np.shape(x)[1]#number of features
hidden_s = 2 #number of nodes in the hidden layer
l_r = 1#learning rate initialization

theta1 = tf.cast(tf.Variable(tf.random_normal([3,hidden_s]),name = "theta1"),tf.float64)
theta2 = tf.cast(tf.Variable(tf.random_normal([hidden_s+1,1]),name = "theta2"),tf.float64)

#conducting forward propagation
a1 = tf.concat([np.c_[np.ones(x.shape[0])],x],1)
#the weights of the first layer are multiplied by the input of the first layer

z1 = tf.matmul(a1,theta1)
#the input of the second layer is the output of the first layer, passed through the 
   activation function and column of biases is added

a2 = tf.concat([np.c_[np.ones(x.shape[0])],tf.sigmoid(z1)],1)
#the input of the second layer is multiplied by the weights

z3 = tf.matmul(a2,theta2)
#the output is passed through the activation function to obtain the final probability

h3 = tf.sigmoid(z3)
cost_func = -tf.reduce_sum(y*tf.log(h3)+(1-y)*tf.log(1-h3),axis = 1)

#built in tensorflow optimizer that conducts gradient descent using specified 
   learning rate to obtain theta values

optimiser = tf.train.GradientDescentOptimizer(learning_rate = l_r).minimize(cost_func)

#setting required X and Y values to perform XOR operation
X = [[0,0],[0,1],[1,0],[1,1]]
Y = [[0],[1],[1],[0]]

#initializing all variables, creating a session and running a tensorflow session
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

#running gradient descent for each iteration and printing the hypothesis 
   obtained using the updated theta values
for i in range(100000):
   sess.run(optimiser, feed_dict = {x:X,y:Y})#setting place holder values using feed_dict
   if i%100==0:
      print("Epoch:",i)
      print("Hyp:",sess.run(h3,feed_dict = {x:X,y:Y}))

La riga di codice sopra genera un output come mostrato nello screenshot qui sotto -

L'ottimizzazione della discesa del gradiente è considerata un concetto importante nella scienza dei dati.

Considera i passaggi mostrati di seguito per comprendere l'implementazione dell'ottimizzazione della discesa del gradiente:

Passo 1

Includere i moduli necessari e la dichiarazione delle variabili xey attraverso le quali definiremo l'ottimizzazione della discesa del gradiente.

import tensorflow as tf

x = tf.Variable(2, name = 'x', dtype = tf.float32)
log_x = tf.log(x)
log_x_squared = tf.square(log_x)

optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(log_x_squared)

Passo 2

Inizializza le variabili necessarie e chiama gli ottimizzatori per definirlo e chiamarlo con la rispettiva funzione.

init = tf.initialize_all_variables()

def optimize():
   with tf.Session() as session:
      session.run(init)
      print("starting at", "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
      
      for step in range(10):
         session.run(train)
         print("step", step, "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
optimize()

La riga di codice sopra genera un output come mostrato nello screenshot qui sotto -

Possiamo vedere che le epoche e le iterazioni necessarie vengono calcolate come mostrato nell'output.

Un'equazione differenziale parziale (PDE) è un'equazione differenziale, che coinvolge derivate parziali con funzione sconosciuta di diverse variabili indipendenti. Con riferimento alle equazioni alle derivate parziali, ci concentreremo sulla creazione di nuovi grafici.

Supponiamo che ci sia uno stagno con dimensioni 500 * 500 quadrati -

N = 500

Ora, calcoleremo l'equazione differenziale parziale e formeremo il rispettivo grafico usandola. Considera i passaggi indicati di seguito per il calcolo del grafico.

Step 1 - Importa librerie per la simulazione.

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

Step 2 - Include funzioni per la trasformazione di un array 2D in un kernel di convoluzione e un'operazione di convoluzione 2D semplificata.

def make_kernel(a):
   a = np.asarray(a)
   a = a.reshape(list(a.shape) + [1,1])
   return tf.constant(a, dtype=1)

def simple_conv(x, k):
   """A simplified 2D convolution operation"""
   x = tf.expand_dims(tf.expand_dims(x, 0), -1)
   y = tf.nn.depthwise_conv2d(x, k, [1, 1, 1, 1], padding = 'SAME')
   return y[0, :, :, 0]

def laplace(x):
   """Compute the 2D laplacian of an array"""
   laplace_k = make_kernel([[0.5, 1.0, 0.5], [1.0, -6., 1.0], [0.5, 1.0, 0.5]])
   return simple_conv(x, laplace_k)
   
sess = tf.InteractiveSession()

Step 3 - Includere il numero di iterazioni e calcolare il grafico per visualizzare i record di conseguenza.

N = 500

# Initial Conditions -- some rain drops hit a pond

# Set everything to zero
u_init = np.zeros([N, N], dtype = np.float32)
ut_init = np.zeros([N, N], dtype = np.float32)

# Some rain drops hit a pond at random points
for n in range(100):
   a,b = np.random.randint(0, N, 2)
   u_init[a,b] = np.random.uniform()

plt.imshow(u_init)
plt.show()

# Parameters:
# eps -- time resolution
# damping -- wave damping
eps = tf.placeholder(tf.float32, shape = ())
damping = tf.placeholder(tf.float32, shape = ())

# Create variables for simulation state
U = tf.Variable(u_init)
Ut = tf.Variable(ut_init)

# Discretized PDE update rules
U_ = U + eps * Ut
Ut_ = Ut + eps * (laplace(U) - damping * Ut)

# Operation to update the state
step = tf.group(U.assign(U_), Ut.assign(Ut_))

# Initialize state to initial conditions
tf.initialize_all_variables().run()

# Run 1000 steps of PDE
for i in range(1000):
   # Step simulation
   step.run({eps: 0.03, damping: 0.04})
   
   # Visualize every 50 steps
   if i % 500 == 0:
      plt.imshow(U.eval())
      plt.show()

I grafici vengono tracciati come mostrato di seguito:

TensorFlow include una funzione speciale di riconoscimento delle immagini e queste immagini vengono archiviate in una cartella specifica. Con immagini relativamente identiche, sarà facile implementare questa logica per motivi di sicurezza.

La struttura delle cartelle dell'implementazione del codice di riconoscimento delle immagini è come mostrato di seguito:

Il dataset_image include le immagini correlate, che devono essere caricate. Ci concentreremo sul riconoscimento delle immagini con il nostro logo definito al suo interno. Le immagini vengono caricate con lo script "load_data.py", che aiuta a tenere una nota sui vari moduli di riconoscimento delle immagini al loro interno.

import pickle
from sklearn.model_selection import train_test_split
from scipy import misc

import numpy as np
import os

label = os.listdir("dataset_image")
label = label[1:]
dataset = []

for image_label in label:
   images = os.listdir("dataset_image/"+image_label)
   
   for image in images:
      img = misc.imread("dataset_image/"+image_label+"/"+image)
      img = misc.imresize(img, (64, 64))
      dataset.append((img,image_label))
X = []
Y = []

for input,image_label in dataset:
   X.append(input)
   Y.append(label.index(image_label))

X = np.array(X)
Y = np.array(Y)

X_train,y_train, = X,Y

data_set = (X_train,y_train)

save_label = open("int_to_word_out.pickle","wb")
pickle.dump(label, save_label)
save_label.close()

La formazione delle immagini aiuta a memorizzare i modelli riconoscibili all'interno di una cartella specificata.

import numpy
import matplotlib.pyplot as plt

from keras.layers import Dropout
from keras.layers import Flatten
from keras.constraints import maxnorm
from keras.optimizers import SGD
from keras.layers import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend as K

import load_data
from keras.models import Sequential
from keras.layers import Dense

import keras
K.set_image_dim_ordering('tf')

# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)

# load data
(X_train,y_train) = load_data.data_set

# normalize inputs from 0-255 to 0.0-1.0
X_train = X_train.astype('float32')

#X_test = X_test.astype('float32')
X_train = X_train / 255.0

#X_test = X_test / 255.0
# one hot encode outputs
y_train = np_utils.to_categorical(y_train)

#y_test = np_utils.to_categorical(y_test)
num_classes = y_train.shape[1]

# Create the model
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), padding = 'same', 
   activation = 'relu', kernel_constraint = maxnorm(3)))

model.add(Dropout(0.2))
model.add(Conv2D(32, (3, 3), activation = 'relu', padding = 'same', 
   kernel_constraint = maxnorm(3)))

model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Flatten())
model.add(Dense(512, activation = 'relu', kernel_constraint = maxnorm(3)))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation = 'softmax'))

# Compile model
epochs = 10
lrate = 0.01
decay = lrate/epochs
sgd = SGD(lr = lrate, momentum = 0.9, decay = decay, nesterov = False)
model.compile(loss = 'categorical_crossentropy', optimizer = sgd, metrics = ['accuracy'])
print(model.summary())

#callbacks = [keras.callbacks.EarlyStopping(
   monitor = 'val_loss', min_delta = 0, patience = 0, verbose = 0, mode = 'auto')]
callbacks = [keras.callbacks.TensorBoard(log_dir='./logs', 
   histogram_freq = 0, batch_size = 32, write_graph = True, write_grads = False, 
   write_images = True, embeddings_freq = 0, embeddings_layer_names = None, 
   embeddings_metadata = None)]

# Fit the model

model.fit(X_train, y_train, epochs = epochs, 
   batch_size = 32,shuffle = True,callbacks = callbacks)

# Final evaluation of the model
scores = model.evaluate(X_train, y_train, verbose = 0)
print("Accuracy: %.2f%%" % (scores[1]*100))

# serialize model to JSONx
model_json = model.to_json()
with open("model_face.json", "w") as json_file:
   json_file.write(model_json)

# serialize weights to HDF5
model.save_weights("model_face.h5")
print("Saved model to disk")

La riga di codice sopra genera un output come mostrato di seguito -

In questo capitolo, comprenderemo i vari aspetti dell'addestramento alla rete neurale che possono essere implementati utilizzando il framework TensorFlow.

Di seguito sono riportate le dieci raccomandazioni, che possono essere valutate:

Propagazione posteriore

La propagazione all'indietro è un metodo semplice per calcolare le derivate parziali, che include la forma di composizione di base più adatta per le reti neurali.

Discesa stocastica del gradiente

Nella discesa del gradiente stocastico, a batchè il numero totale di esempi, che un utente utilizza per calcolare il gradiente in una singola iterazione. Finora, si presume che il batch sia stato l'intero set di dati. L'illustrazione migliore funziona su scala Google; i set di dati contengono spesso miliardi o addirittura centinaia di miliardi di esempi.

Decadimento del tasso di apprendimento

Adattare la velocità di apprendimento è una delle caratteristiche più importanti dell'ottimizzazione della discesa del gradiente. Questo è fondamentale per l'implementazione di TensorFlow.

Buttare fuori

Le reti neurali profonde con un gran numero di parametri formano potenti sistemi di apprendimento automatico. Tuttavia, l'adattamento eccessivo è un problema serio in tali reti.

Max Pooling

Max pooling è un processo di discretizzazione basato su campioni. Lo scopo è sottoporre a campionamento una rappresentazione di input, che riduce la dimensionalità con i presupposti richiesti.

Memoria a lungo termine (LSTM)

LSTM controlla la decisione su quali input dovrebbero essere presi all'interno del neurone specificato. Include il controllo per decidere cosa calcolare e quale output generare.