Rete neurale per la classificazione con Tensorflow

Questo articolo è stato pubblicato come parte di Blogathon sulla scienza dei dati

In questo articolo creerò modelli di rete neurale con TensorFlow per risolvere un problema di classificazione. Esploriamo insieme come possiamo affrontare un problema di classificazione in Tensorflow. Ma prima di tutto vorrei assicurarmi che siamo in grado di rispondere a queste domande:

cos'è la rete neurale?

Lo scopo principale di una rete neurale è cercare di trovare la relazione tra le caratteristiche di un set di dati ed è costituita da un insieme di algoritmi che imitano il lavoro del cervello umano. Un “neurone” in una rete neurale è una funzione matematica che raccoglie e classifica le informazioni secondo un’architettura specifica.

Cos'è la classificazione?

Il problema della classificazione implica prevedere se qualcosa appartiene o meno a una classe. In altre parole, mentre lo facciamo cerchiamo di vedere che qualcosa è una cosa o l'altra.

Tipi di classificazione

• Supponiamo di voler prevedere se una persona ha il diabete o meno. Se stai affrontando questo tipo di situazione, ci sono due possibilità, giusto? Così si chiama Classificazione binaria.
• Supponiamo che tu voglia identificare se una foto ritrae un giocattolo, una persona o un gatto, giusto? questo è chiamato Classificazione multiclasse perché ci sono più di due opzioni.
• Supponiamo che tu voglia decidere quali categorie devono essere assegnate a un articolo. Se è così, si chiama Classificazione multi-etichetta, perché a un articolo potrebbero essere assegnate più categorie. Prendiamo la nostra spiegazione attraverso questo articolo. Potremmo assegnare categorie come "Deep Learning, TensorFlow, Classificazione" ecc. a questo articolo

Ora possiamo andare avanti perché abbiamo una comprensione comune del problema su cui lavoreremo. Quindi è il momento della codifica. Spero che tu li stia scrivendo con me perché l'unico modo per migliorare e fare meno errori è scrivere più codice.

Stiamo iniziando con l'importazione delle librerie che utilizzeremo:

importa numpy come np importa panda come pd importa matplotlib.pyplot come plt importa tensorflow come tf print(tf.__version__)

Creazione di un set di dati

È giunto il momento di creare un set di dati su cui lavorare:

da sklearn.datasets importa make_circles campioni = 1000 X, y = make_circles (campioni, rumore = 0.03, random_state = 42)

print(X >>[[ 0.75424625 0.23148074] [-0.75615888 0.15325888] [-0.81539193 0.17328203] ... [-0.13690036 -0.81001183] [ 0.67036156 -0.76750154 0.28105665] [ 0.96382443 XNUMX]]

stampa(y) >> [1 1 1 1 0 1 1 1 1 0]

Ok, abbiamo visto il nostro set di dati in modo più dettagliato, ma non ne sappiamo ancora nulla, giusto? Ecco perché qui un passo importante è diventare tutt’uno con i dati, e la visualizzazione è il modo migliore per farlo.

cerchio = pd.DataFrame({ 'X0' : X[:, 0], 'X1' : X[:, 1], 'label' : y}) cerchio.head()

Qui sorge una domanda: con che tipo di etichette abbiamo a che fare?

circle.label.value_counts() >> 1 500 0 500 Nome: etichetta, dtype: int64

Sembra che abbiamo a che fare un problema di classificazione binaria, perché abbiamo 2 etichette (0 e 1).

plt.scatter(X[:,0], X[:,1], c = y, cmap = plt.cm.RdYlBu)

Come ho detto sopra, il modo migliore per ottenerne uno con i dati è la visualizzazione. Ora la trama stessa dice che tipo di modello dobbiamo costruire. Costruiremo un modello in grado di distinguere i punti blu da quelli rossi.

Prima di costruire qualsiasi modello di rete neurale, dobbiamo controllare le forme delle nostre caratteristiche di input e output. devono essere uguali!

print(forma X, forma y) print(lente(X), lente(y)) >> (1000, 2) (1000,) 1000 1000

Abbiamo la stessa quantità di valori per ciascuna caratteristica, ma la forma di X è diversa? Perché? Controlliamolo.

X[0], y[0] >> (array([0.75424625, 0.23148074]), 1)

Ok, abbiamo 2 funzioni X per 1 anno. Quindi possiamo andare avanti senza alcun problema.

Passaggi nella modellazione della rete neurale per la classificazione con Tensorflow

In TensorFlow ci sono fasi fisse per la creazione di un modello:

• Creare un modello – mettere insieme gli strati di una rete neurale utilizzando l'API funzionale o sequenziale
• Compilazione di un modello – definire come misurare le prestazioni di un modello e come dovrebbe migliorare (funzione di perdita e ottimizzatore)
• Adattamento di una modalitàl – lasciare che un modello trovi schemi nei dati

Utilizzeremo l'API sequenziale. Quindi iniziamo

tf.random.set_seed(42)

modello_1 = tf.keras.Sequential([tf.keras.layers.Dense(1)])

 ottimizzatore = tf.keras.optimizers.SGD(), #SGD sta per Stochastic Gradient Descent metrics = ['precisione']) model_1.fit(X, y, epochs = 5)

>> Epoca 1/5 32/32 [==============================] - 1s 1ms/passo - perdita: 2.8544 - precisione: 0.4600 Epoca 2/5 32/32 [==============================] - 0s 2ms/passo - perdita : 0.7131 - precisione: 0.5430 Epoca 3/5 32/32 [==============================] - 0s 2ms/passo - perdita: 0.6973 - precisione: 0.5090 Epoca 4/5 32/32 [==============================] - 0s 2ms /passo - perdita: 0.6950 - precisione: 0.5010 Epoca 5/5 32/32 [==============================] - 0s 1ms/passo - perdita: 0.6942 - precisione: 0.4830

La precisione del modello è di circa il 50%, il che significa sostanzialmente che il modello sta solo indovinando, proviamo ad addestrarlo più a lungo

model_1.fit(X, y, epochs = 200, verbose = 0) #impostiamo verbose = 0 per rimuovere la procedura di addestramento) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0s 1ms/passo - perdita: 0.6935 - precisione: 0.5000 [0.6934829950332642, 0.5]

Anche dopo 200 epoche, funziona ancora come previsto. Il passo successivo è aggiungere più livelli e allenarsi più a lungo.

tf.random.set_seed(42)

model_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(loss = tf.keras.losses.BinaryCrossentropy(), ottimizzatore = tf.keras.optimizers.SGD(), metrics = ['precisione']) model_2.fit(X, y, epoche = 100, verbose = 0)

 modello_2.valuta(X,y)

>> 32/32 [==============================] - 0s 1ms/passo - perdita: 0.6933 - precisione: 0.5000 [0.6933314800262451, 0.5]

Eppure non c’è nemmeno un piccolo cambiamento, sembra che qualcosa non va.

Miglioramento del modello di rete neurale per la classificazione con Tensorflow

Esistono diversi modi per migliorare un modello in diverse fasi:

• Creare un modello – aggiungere più strati, aumentare il numero di unità nascoste (neuroni), modificare le funzioni di attivazione di ogni strato
• Compilazione di un modello – prova diverse funzioni di ottimizzazione, ad esempio usa Adam() invece di SGD().
• Adattamento di un modello – potremmo aumentare il numero di epoche

Proviamo a aggiungere più neuroni e provare Adam ottimizzatore

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # aggiungi 100 neuroni densi tf.keras.layers.Dense(10), # aggiungi un altro livello con 10 neuroni tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), ottimizzatore=tf.keras.optimizers.Adam(), metrics=['accuratezza']) model_3.fit(X, y, epoche =100, dettagliato=0)

model_3.evaluate(X,y) >> 32/32 [==============================] - 0s 1ms/passo - perdita: 0.6980 - precisione: 0.5080 [0.6980254650115967, 0.5080000162124634]

Ancora non sto migliorando! Visualizziamo i dati per vedere cosa sta andando storto.

Visualizza il modello di rete neurale

Per visualizzare le previsioni del nostro modello creeremo una funzione plot_decision_boundary() che:

• Include un modello addestrato, funzionalità ed etichette
• Crea una griglia mesh dei diversi valori X.
• Effettua previsioni sulla griglia mesh.
• Traccia le previsioni con la linea.

Nota:  Questa funzione è stata adattata da due risorse:

CS231n Realizzato con le basi del machine learning 

def plot_decision_boundary(model, X, y): # Definisce i confini dell'asse del grafico e crea una meshgrid x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1 y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np .linspace(y_min, y_max, 100)) # Crea valori X (prevediamo su tutti questi) x_in = np.c_[xx.ravel(), yy.ravel()] # Effettua previsioni utilizzando il metodo addestrato model y_pred = model.predict(x_in) # Controlla la multiclasse

 if len(y_pred[0]) > 1: print("eseguendo la classificazione multiclasse...") # Dobbiamo rimodellare le nostre previsioni per prepararle per il grafico y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("eseguendo la classificazione binaria...") y_pred = np.round(y_pred).reshape(xx.shape) # Traccia il confine decisionale plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alpha=0.7) plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu) plt.xlim(xx.min( ), xx.max()) plt.ylim(yy.min(), yy.max()) plot_decision_boundary(model_3, X, y)

Ecco qui! Ancora una volta la visualizzazione ci mostra cosa c'è che non va e cosa fare? Il nostro modello tenta di tracciare una linea retta attraverso i dati, ma i nostri dati non sono separabili da una linea retta. C'è qualcosa che manca nel nostro problema di classificazione? Cos'è?

Questa è non linearità! Abbiamo bisogno di alcune linee non lineari. Potresti sentirti confuso ora, se pensi di non aver visto quel tipo di funzione prima, ti sbagli, perché è così. Vediamoli visivamente. La visualizzazione funziona sempre meglio!

Ci sono alcune funzioni di attivazione nella rete neurale che possiamo usare, come ReLu, sigmoid. Creiamo un po' tensore del giocattolo e controlla quelle funzioni su di esso.

Funzioni di attivazione per reti neurali

A = tf.cast(tf.range(-12,12), tf.float32) print(A) >> tf.Tensore( [-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], forma=(24,), dtipo=float32)

Vediamo come appare il nostro tensore giocattolo?

plt.plot(A)

Sembra così, una linea retta! 

Ora ricreiamo le funzioni di attivazione per vedere cosa fanno al nostro tensore?

Sigmoideo:

def sigmoid(x): return 1 / (1 + tf.exp(-x)) sigmoid(A) plt.plot(sigmoid(A))

Una linea non retta!

ReLu:

def relu(x): return tf.maximum(0,x) plt.plot(relu(A))

Un'altra linea non retta!

Ora hai visto le funzioni di attivazione non lineari e queste sono ciò che funzionerà per noi, il modello non può apprendere nulla su un set di dati non lineare con funzioni di attivazione lineare! Se lo abbiamo imparato, è tempo di dividere i nostri dati in set di training e test e costruire modelli solidi.

Treno_X, treno_y = X[:800], y[:800] prova_X, prova_y = X[800:], y[800:] treno_X.forma, test_X.forma >>((800, 2), (200, 2 ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([ tf.keras.layers.Dense(4, attivazione = 'relu'), #potremmo correggere anche "tf.keras.activations.relu" tf.keras.layers.Dense(4 , attivazione = 'relu'), tf.keras.layers.Dense(1, attivazione = 'sigmoid') ]) model_4.compile( loss= tf.keras.losses.binary_crossentropy, ottimizzatore = tf.keras.optimizers.Adam( lr = 0.01), metrics = ['precisione']) model_4.fit(X_train, y_train, epochs = 25, verbose = 0)

Valuta il modello

perdita, accuratezza = model_4.evaluate(X_test, y_test) print(f' Perdita del modello sul set di test: {loss}') print(f' Precisione del modello sul set di test: {100*accuracy}')

>> 7/7 [==============================] - 0s 2ms/passo - perdita: 0.1247 - precisione: 1.0000 Perdita del modello sul set di test: 0.1246885135769844 Precisione del modello sul set di test: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Treno") plot_decision_boundary(model_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("Test") plot_decision_boundary(model_4, X=X_test, y=y_test) plt.show()

Vediamo brevemente di cosa parliamo in questo articolo. Insieme abbiamo esaminato come affrontare un compito di classificazione nella rete neurale con TensorFlow. Abbiamo creato 3 modelli nel primo modo che ci è venuto in mente e con l'aiuto della visualizzazione ci siamo resi conto dove sbagliavamo, abbiamo esplorato la linearità, la non linearità e, infine, siamo riusciti a costruire un modello generalizzato. Ciò che cercavo di dimostrare con tutti questi codici e i passaggi che seguivo era che nulla è accurato o fisso al 100%, tutto continua a cambiare ogni giorno. Per indovinare quale problema potresti incontrare con quale tipo di dati e per vedere quali combinazioni portano a un risultato migliore, tutto ciò di cui hai bisogno è scrivere molto più codice e acquisire esperienza.

Spero che l'articolo ti sia stato un po' utile e abbia dato qualche contributo.

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e sono utilizzati a discrezione dell'autore

Leggi Anche

Fonte: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/