Ricerca nel sito web

Implementazione della rete neurale utilizzando TensorFlow in Python

La rete neurale è un concetto ampiamente utilizzato nel campo dell'intelligenza artificiale e si basa sulla struttura del cervello umano. Una rete neurale funziona a strati, il più semplice è un modello sequenziale in cui l'input dello strato corrente è l'output dello strato precedente.

Per creare, addestrare e testare un modello di rete neurale, possiamo utilizzare un framework di deep learning come Tensorflow in Python. Ogni modello di rete neurale si basa su pochi semplici passaggi come acquisire dati, fare previsioni, confrontare previsioni e infine modificarle per avvicinarsi all'obiettivo.

Algoritmo

  • Passaggio 1 - Importa le librerie numpy e pandas di Python e carica il file csv come frame di dati.

  • Passaggio 2: importa tensorflow e dividi i dati in set di training e convalida.

  • Passaggio 3: preelabora e ridimensiona i dati di entrambi i set.

  • Passaggio 4 - Separa i dati di entrambi i set in caratteristiche diverse.

  • Passaggio 5 - Utilizza il modulo Keras per formare un modello di rete neurale lineare e imposta i parametri adam e mae per esso. Tieni presente che Adam funziona come un ottimizzatore mentre Mae funziona nelle previsioni.

  • Passaggio 6 - Addestra il set di dati per tutte le epoche che desideri. Qui stiamo prendendo solo 10 epoche.

  • Passaggio 7 - Ora utilizza la funzione di previsione per testare il nostro modello. Qui stiamo passando le prime 4 righe come input per generare il risultato.

  • Passaggio 8 - Confronta il risultato con il valore target. Se i valori previsti sono abbastanza vicini a quelli reali, allora possiamo concludere che il modello funziona bene.

Esempio

In questo esempio, prenderemo un set di dati sul diabete da Kaggle e implementeremo una rete neurale per esso. Sebbene sia possibile creare anche un modello di rete neurale multistrato, qui ci limiteremo a una rete lineare per semplicità.

#step 1 - import numpy and pandas and load the dataset
import numpy as np
import pandas as pd
df = pd.read_csv('dataset.csv')
df.head()

#step 2 - import tensorflow and split the data into training and validation sets 
import tensorflow as tf
train_df = df.sample(frac=0.85, random_state=4)
val_df = df.drop(train_df.index)

#step 3 - scale and preprocess the data
max_val = train_df.max(axis= 0)
min_val = train_df.min(axis= 0)
range = max_val - min_val
train_df = (train_df - min_val)/(range)
val_df =  (val_df- min_val)/range

#step 4 - separate the data into features
X_train = train_df.drop('gravity',axis=1)
X_val = val_df.drop('gravity',axis=1)
y_train = train_df['gravity']
y_val = val_df['gravity']
input_shape = [X_train.shape[1]]
input_shape

#step 5 - make a linear neural network model and add parameters
model = tf.keras.Sequential([
tf.keras.layers.Dense(units=1,input_shape=input_shape)])
model.summary()
model.compile(optimizer='adam',
              loss='mae') 

#step 6 - train the dataset for epochs
losses = model.fit(X_train, y_train,
 
            validation_data=(X_val, y_val),
            batch_size=256,
            epochs=10,  
 
         )

#step 7 - use the predict function to test the model 
model.predict(X_val.iloc[0:4, :])

#step 8 - compare the result with the target value 
y_val.iloc[0:4]

Dividiamo i dati in set di training e validazione e preelaboriamo i dati calcolando i valori massimo e minimo nel set di training e normalizziamo i dati tra 0 e 1. Separiamo ulteriormente i dati in caratteristiche e definiamo una forma di input in base al numero di caratteristiche.

Creiamo quindi un modello di rete neurale lineare e aggiungiamo un livello con 1, che rappresenta l'output, con la forma di input precedentemente definita. Compiliamo e addestriamo il modello e otteniamo previsioni dal modello addestrato per le prime 4 righe di dati. Quindi confrontiamo i valori previsti con i valori effettivi per valutare le prestazioni.

Produzione

Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense_1 (Dense)             (None, 1)                 8         
                                                                 
=================================================================
Total params: 8
Trainable params: 8
Non-trainable params: 0

_________________________________________________________________
Epoch 1/10
1/1 [==============================] - 1s 944ms/step - loss: 0.8678 - val_loss: 1.0600
Epoch 2/10
1/1 [==============================] - 0s 71ms/step - loss: 0.8639 - val_loss: 1.0556
Epoch 3/10
1/1 [==============================] - 0s 63ms/step - loss: 0.8600 - val_loss: 1.0511
Epoch 4/10
1/1 [==============================] - 0s 66ms/step - loss: 0.8561 - val_loss: 1.0467
Epoch 5/10
1/1 [==============================] - 0s 65ms/step - loss: 0.8522 - val_loss: 1.0422
Epoch 6/10
1/1 [==============================] - 0s 66ms/step - loss: 0.8483 - val_loss: 1.0378
Epoch 7/10
1/1 [==============================] - 0s 74ms/step - loss: 0.8444 - val_loss: 1.0334
Epoch 8/10
1/1 [==============================] - 0s 71ms/step - loss: 0.8405 - val_loss: 1.0289
Epoch 9/10
1/1 [==============================] - 0s 74ms/step - loss: 0.8366 - val_loss: 1.0245
Epoch 10/10
1/1 [==============================] - 0s 68ms/step - loss: 0.8327 - val_loss: 1.0200
1/1 [==============================] - 0s 84ms/step

1     0.413793
9     0.551724
36    0.103448
44    0.517241
Name: gravity, dtype: float64

Conclusione

È noto che le reti neurali elaborano enormi quantità di dati abbastanza facilmente oltre a fornire un'elevata potenza di calcolo e capacità di elaborazione parallela. Tuttavia, l’implementazione di una rete neurale rimane ancora un po’ costosa rispetto ai metodi tradizionali. Tuttavia, trovano grande utilizzo nelle applicazioni basate sull'intelligenza artificiale come il riconoscimento delle immagini, il riconoscimento dei volti o le previsioni del mercato azionario, per citarne alcuni.

Articoli correlati: