Corso
Introduzione a R
4 ore
3.1M
Introduzione alle reti neurali
Le reti neurali, o reti neurali simulate, sono un sottoinsieme del machine learning ispirato al cervello umano. Imitano il modo in cui i neuroni biologici comunicano tra loro per arrivare a una decisione.
Una rete neurale è composta da uno strato di input, uno o più strati nascosti e uno strato di output. Il primo strato riceve l’input grezzo, che viene elaborato da più strati nascosti, e l’ultimo strato produce il risultato.
Nell’esempio seguente, abbiamo simulato il processo di addestramento di reti neurali per classificare dati tabellari. Abbiamo i parametri X1 e X2 che passano attraverso 2 strati nascosti di 4 e 2 neuroni per produrre l’output. Con più iterazioni, il modello migliora nella classificazione dei target.
Immagine creata con TF Playground
Gli algoritmi di deep learning, o reti neurali profonde, sono costituiti da molteplici strati nascosti e nodi. Il termine “deep” si riferisce alla profondità delle reti neurali. In genere sono utilizzati per risolvere problemi complessi come la classificazione di immagini, il riconoscimento vocale e la generazione di testo.
Per saperne di più sulle reti neurali, leggi il nostro tutorial sul Deep Learning. Imparerai come funzionano la funzione di attivazione, la funzione di perdita e la backpropagation per produrre risultati accurati.
Tipi di reti neurali
Esistono diversi tipi di reti neurali utilizzati per applicazioni avanzate di machine learning. Non esiste un’unica architettura di modello che funzioni per tutto. Il tipo più antico di rete neurale è noto come Perceptron, creato da Frank Rosenblatt nel 1958.
In questa sezione, vedremo i 5 tipi di reti neurali più popolari utilizzati nel settore tech.
Reti neurali feedforward
Le reti neurali feedforward sono composte da uno strato di input, strati nascosti e uno strato di output. Si chiamano feedforward perché il flusso dei dati è in direzione avanti e non c’è backpropagation. Sono usate soprattutto in classificazione, riconoscimento vocale, riconoscimento facciale e riconoscimento di pattern.
Perceptron multistrato
I Perceptron Multistrato (MLP) risolvono i limiti delle reti neurali feedforward, che non possono apprendere tramite backpropagation. Sono bidirezionali e consistono in più strati nascosti e funzioni di attivazione. Gli MLP usano la propagazione in avanti per gli input e la backpropagation per aggiornare i pesi. Sono reti neurali di base che hanno posto le fondamenta per la computer vision, le tecnologie del linguaggio e altre reti neurali.
Nota: gli MLP sono composti da neuroni sigmoidali, non da perceptron, perché i problemi del mondo reale sono non lineari.
Reti neurali convoluzionali (CNN)
Le Convolutional Neural Network (CNN) sono usate generalmente in computer vision, riconoscimento di immagini e riconoscimento di pattern. Servono per estrarre caratteristiche importanti dalle immagini usando molteplici strati convoluzionali. Lo strato di convoluzione in una CNN utilizza una matrice personalizzata (filtro) per effettuare la convoluzione sulle immagini e creare una mappa.
In genere, le Convolutional Neural Network comprendono lo strato di input, lo strato di convoluzione, lo strato di pooling, lo strato completamente connesso e lo strato di output. Leggi il nostro tutorial Reti Neurali Convoluzionali (CNN) in Python con TensorFlow per capire meglio come funzionano le CNN.
Reti neurali ricorrenti (RNN)
Le Recurrent Neural Network (RNN) sono comunemente usate per dati sequenziali come testi, sequenze di immagini e serie temporali. Sono simili alle reti feed-forward, tranne per il fatto che ricevono input da sequenze precedenti tramite un ciclo di feedback. Le RNN sono utilizzate in NLP, previsioni di vendita e previsione meteo.
Le RNN presentano problemi di gradiente che svanisce, risolti da versioni avanzate delle RNN chiamate Long Short-Term Memory (LSTM) e Gated Recurrent Unit (GRU). Leggi il tutorial sulle Reti Neurali Ricorrenti (RNN) per saperne di più su LSTM e GRU.
Implementazione delle reti neurali in R
Impareremo a creare reti neurali con i popolari pacchetti R neuralnet e Keras.
Nel primo esempio, creeremo una semplice rete neurale con il minimo sforzo, e nel secondo affronteremo un problema più avanzato usando il pacchetto Keras.
Impostiamo l’ambiente R scaricando librerie e dipendenze essenziali.
install.packages(c('neuralnet','keras','tensorflow'),dependencies = T)Implementazione di una semplice rete neurale in R
In questo primo esempio useremo il dataset integrato di R iris e risolveremo un problema di classificazione multiclasse con una semplice rete neurale.
Inizieremo importando i pacchetti R essenziali per la manipolazione dei dati e l’addestramento del modello.
library(tidyverse)
library(neuralnet)Analisi dei dati
Puoi accedere ai dati digitando `iris` ed eseguendolo nella console R. Prima di addestrare i dati, dobbiamo convertire le colonne di tipo carattere in fattori.
Nota: stiamo usando lo workspace R di DataCamp per eseguire gli esempi.
iris <- iris %>% mutate_if(is.character, as.factor)La funzione `summary` è usata per l’analisi statistica e la distribuzione dei dati.
summary(iris)Come possiamo vedere, i dati sono bilanciati. Tutte e tre le classi target hanno 50 campioni ciascuna.
Sepal.Length Sepal.Width Petal.Length Petal.Width
Min. :4.300 Min. :2.000 Min. :1.000 Min. :0.100
1st Qu.:5.100 1st Qu.:2.800 1st Qu.:1.600 1st Qu.:0.300
Median :5.800 Median :3.000 Median :4.350 Median :1.300
Mean :5.843 Mean :3.057 Mean :3.758 Mean :1.199
3rd Qu.:6.400 3rd Qu.:3.300 3rd Qu.:5.100 3rd Qu.:1.800
Max. :7.900 Max. :4.400 Max. :6.900 Max. :2.500
Species
setosa :50
versicolor:50
virginica :50 Suddivisione train e test
Imposteremo il seed per la riproducibilità e divideremo i dati in train e test per l’addestramento e la valutazione del modello. Useremo una suddivisione 80:20.
set.seed(245)
data_rows <- floor(0.80 * nrow(iris))
train_indices <- sample(c(1:nrow(iris)), data_rows)
train_data <- iris[train_indices,]
test_data <- iris[-train_indices,]Addestrare la rete neurale
Il pacchetto neuralnet è obsoleto, ma è ancora popolare nella community R.
La funzione `neuralnet` è semplice. Non ci lascia libertà di creare un’architettura di modello completamente personalizzabile.
Nel nostro caso, le forniamo una formula di machine learning e i dati, proprio come in GLM. La formula è composta da variabili target e feature.
Dopodiché, creiamo due strati nascosti: il primo con quattro neuroni e il secondo con due neuroni.
model = neuralnet(
Species~Sepal.Length+Sepal.Width+Petal.Length+Petal.Width,
data=train_data,
hidden=c(4,2),
linear.output = FALSE
)Per visualizzare l’architettura del modello, useremo la funzione `plot`. Richiede un oggetto modello e l’argomento `rep`.
plot(model,rep = "best")
Valutazione del modello
Per la matrice di confusione:
- Prevedremo le categorie usando il dataset di test.
- Creeremo un elenco di nomi di categoria.
- Creeremo un dataframe di predizione e sostituiremo gli output numerici con etichette.
- Useremo tabelle per visualizzare i valori ‘effettivi’ e ‘predetti’ affiancati.
pred <- predict(model, test_data)
labels <- c("setosa", "versicolor", "virginca")
prediction_label <- data.frame(max.col(pred)) %>%
mutate(pred=labels[max.col.pred.]) %>%
select(2) %>%
unlist()
table(test_data$Species, prediction_label)Abbiamo ottenuto risultati quasi perfetti. Sembra che il nostro modello abbia previsto in modo errato tre campioni. Possiamo migliorare il risultato aggiungendo più neuroni in ogni strato.
prediction_label
setosa versicolor virginica
setosa 8 0 0
versicolor 0 13 0
virginica 0 3 6 Per verificare l’accuratezza, dobbiamo prima convertire i valori categoriali effettivi in valori numerici e confrontarli con quelli previsti. Come risultato, otterremo un elenco di valori booleani.
Possiamo usare la funzione `sum` per trovare il numero di valori `TRUE` e dividerlo per il numero totale di campioni per ottenere l’accuratezza.
check = as.numeric(test_data$Species) == max.col(pred)
accuracy = (sum(check)/nrow(test_data))*100
print(accuracy)Il modello ha previsto i valori con un’accuratezza del 90%.
90Nota: il codice sorgente di questo esempio è disponibile su R workspace: Building Neural Network (NN) Models in R.
Rete Neurale Convoluzionale in R con Keras
In questo esempio useremo Keras e TensorFlow per creare e addestrare un modello di Rete Neurale Convoluzionale per il compito di classificazione di immagini. Per farlo, useremo il dataset di immagini cifar10 composto da 60.000 immagini a colori 32x32 etichettate su dieci categorie.
Immagine da CIFAR-10
Importa i pacchetti R essenziali.
library(keras)
library(tensorflow)Preparazione dei dati
Importeremo il dataset integrato di Keras e lo divideremo in set di train e test.
c(c(x_train, y_train), c(x_test, y_test)) %<-% dataset_cifar10()Dividi le feature di train e test per 255 per normalizzare i dati.
x_train <- x_train / 255
x_test <- x_test / 255Costruzione del modello
L’API di Keras ci offre la flessibilità per creare architetture di reti neurali complesse e completamente personalizzabili.
Nel nostro caso, creeremo più strati di convoluzione, seguiti da uno strato di max pooling, uno strato di dropout, uno strato denso e lo strato di output.
Utilizziamo la ‘Leaky ReLU’ come funzione di attivazione per tutti gli strati tranne quello di output, per il quale usiamo ‘softmax’.
Dobbiamo impostare la forma di input del primo strato di convoluzione 2D sulla dimensione dell’immagine (32,32,3) del dataset di addestramento.
model <- keras_model_sequential()%>%
# Start with a hidden 2D convolutional layer
layer_conv_2d(
filter = 16, kernel_size = c(3,3), padding = "same",
input_shape = c(32, 32, 3), activation = 'leaky_relu'
) %>%
# 2nd hidden layer
layer_conv_2d(filter = 32, kernel_size = c(3,3), activation = 'leaky_relu') %>%
# Use max pooling
layer_max_pooling_2d(pool_size = c(2,2)) %>%
layer_dropout(0.25) %>%
# 3rd and 4th hidden 2D convolutional layers
layer_conv_2d(filter = 32, kernel_size = c(3,3), padding = "same", activation = 'leaky_relu') %>%
layer_conv_2d(filter = 64, kernel_size = c(3,3), activation = 'leaky_relu') %>%
# Use max pooling
layer_max_pooling_2d(pool_size = c(2,2)) %>%
layer_dropout(0.25) %>%
# Flatten max filtered output into feature vector
# and feed into dense layer
layer_flatten() %>%
layer_dense(256, activation = 'leaky_relu') %>%
layer_dropout(0.5) %>%
# Outputs from dense layer
layer_dense(10, activation = 'softmax')Per visualizzare l’architettura del modello, useremo la funzione `summary`.
summary(model)Abbiamo due strati di convoluzione seguiti da uno strato di max pooling, altri due strati di convoluzione, uno strato di max pooling, uno strato di flatten per trasformare l’output filtrato massimo in vettori e poi due strati densi.
Model: "sequential"
________________________________________________________________________________
Layer (type) Output Shape Param #
================================================================================
conv2d_3 (Conv2D) (None, 32, 32, 16) 448
________________________________________________________________________________
conv2d_2 (Conv2D) (None, 30, 30, 32) 4640
________________________________________________________________________________
max_pooling2d_1 (MaxPooling2D) (None, 15, 15, 32) 0
________________________________________________________________________________
dropout_2 (Dropout) (None, 15, 15, 32) 0
________________________________________________________________________________
conv2d_1 (Conv2D) (None, 15, 15, 32) 9248
________________________________________________________________________________
conv2d (Conv2D) (None, 13, 13, 64) 18496
________________________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 6, 6, 64) 0
________________________________________________________________________________
dropout_1 (Dropout) (None, 6, 6, 64) 0
________________________________________________________________________________
flatten (Flatten) (None, 2304) 0
________________________________________________________________________________
dense_1 (Dense) (None, 256) 590080
________________________________________________________________________________
dropout (Dropout) (None, 256) 0
________________________________________________________________________________
dense (Dense) (None, 10) 2570
================================================================================
Total params: 625,482
Trainable params: 625,482
Non-trainable params: 0
________________________________________________________________________________Compilazione del modello
- Imposteremo il learning rate usando una funzione di decadimento esponenziale programmata. Riduce il learning rate dopo 1500 step di 0,98.
- Passa l’oggetto learning rate all’ottimizzatore Adamax.
- La nostra funzione di perdita sarà la sparse categorical cross-entropy.
- Compila il modello usando funzione di perdita, ottimizzatore e metrica di performance.
learning_rate <- learning_rate_schedule_exponential_decay(
initial_learning_rate = 5e-3,
decay_rate = 0.96,
decay_steps = 1500,
staircase = TRUE
)
opt <- optimizer_adamax(learning_rate = learning_rate)
loss <- loss_sparse_categorical_crossentropy(from_logits = TRUE)
model %>% compile(
loss = loss,
optimizer = opt,
metrics = "accuracy"
)Addestramento del modello
Effettueremo il fit del modello e memorizzeremo la metrica di valutazione in `history`.
- Alleneremo il modello per 10 epoche e imposteremo la dimensione del batch a 32.
- Aggiungeremo il dataset di test per la validazione.
- L’argomento `shuffle` mescolerà i dati di addestramento all’inizio di ogni epoca.
history <- model %>% fit(
x_train, y_train,
batch_size = 32,
epochs = 10,
validation_data = list(x_test, y_test),
shuffle = TRUE
)Valutazione del modello
Puoi valutare il modello sul dataset di test usando la funzione `evaluate`, che restituirà perdita e accuratezza finali.
model %>% evaluate(x_test, y_test)Riaddestrare il modello per 50 epoche migliorerà l’accuratezza.
Loss 0.648191571235657 Accuracy 0.776799976825714Per tracciare i grafici a linee di perdita e accuratezza per ogni epoca, useremo la funzione `plot`.
plot(history)Osservando il grafico, possiamo notare che la linea non si è ancora appiattita. Significa che con più epoche possiamo migliorare le metriche del modello.
Se vuoi approfondire l’API di Keras e come usarla per costruire reti neurali profonde, dai un’occhiata al tutorial keras: Deep Learning in R.
Applicazioni delle reti neurali
Esempi reali di reti neurali si trovano ovunque, dalle app mobile all’ingegneria. Grazie al recente boom dei modelli linguistici e visuali di grandi dimensioni, sempre più aziende sono interessate a implementare reti neurali profonde per aumentare profitti e soddisfazione dei clienti.
In questa sezione, vedremo le 10 principali applicazioni delle reti neurali che stanno plasmando il mondo moderno.
1. Predizione su dati tabellari
Le semplici reti neurali sono molto efficaci su grandi dati tabellari. Possiamo usarle per problemi di classificazione, clustering e regressione.
2. Previsione dei prezzi azionari
Molte aziende utilizzano LSTM, GRU e RNN per le previsioni finanziarie. Ciò consente di prendere decisioni migliori.
3. Imaging medico
Rilevamento del tumore al seno, rilevamento di anomalie e segmentazione di immagini sono alcune applicazioni delle reti neurali convoluzionali. Grazie ai transformer pre-addestrati, abbiamo visto ricerche avanzate nella prevenzione delle malattie e nel rilevamento precoce di patologie gravi.
4. E-commerce
Raccomandazioni di prodotto, esperienze personalizzate e chatbot sono alcune applicazioni delle reti neurali utilizzate nell’e-commerce. Questi modelli sono impiegati principalmente per clustering, elaborazione del linguaggio naturale e computer vision per migliorare l’esperienza dei clienti sulla piattaforma.
5. Immagini generative
A causa della popolarità di DALL·E 2 e della stable diffusion, questo ambito è diventato mainstream. Aziende come Canva e Adobe hanno già implementato funzionalità di generazione di immagini per aumentare il numero di utenti. Oltre all’hype mainstream, le immagini generative sono usate in ogni settore per creare dati sintetici e migliorare prestazioni, stabilità e bias dei modelli.
6. Testo generativo
ChatGPT, GPT-3 e GPT-NEO sono modelli di reti neurali profonde che dominano l’ambito. Questi modelli sono usati per assistenza alla programmazione, chatbot, traduzione, domanda/risposta e altro. Sono ovunque e le aziende trovano facile integrarli nei sistemi esistenti.
7. Chat bot per l’assistenza clienti
DialoGPT e BlenderBot sono modelli conversazionali popolari che migliorano l’esperienza con i chatbot. Sono adattivi e possono essere perfezionati per uno scopo specifico. In futuro, non vedremo tempi di attesa lunghi: questi chatbot saranno in grado di capire i tuoi problemi e fornire soluzioni in tempo reale.
8. Robotica
Il reinforcement learning e i modelli di reti neurali per la computer vision stanno giocando un ruolo fondamentale nella trasformazione dei settori. Per esempio, la gestione dei magazzini completamente automatizzata, le fabbriche e l’esperienza d’acquisto.
9. Riconoscimento vocale
I modelli di riconoscimento vocale, text-to-speech e rilevamento di attività audio sono usati per assistenti vocali, trascrizione automatica e applicazioni di comunicazione avanzata.
10. Multimodale
Text to Image (DALLE-2), Image Text, Visual Question Answering ed estrazione di feature sono alcune applicazioni utilizzate nelle reti neurali multimodali. In futuro, vedrai text-to-video con audio. Potrai creare un film completo fornendo la sceneggiatura.
Conclusione
I pacchetti R Keras e TensorFlow ci forniscono un set completo di strumenti per creare architetture di modelli complesse per compiti specifici. Puoi caricare il dataset, eseguire il pre-processing, costruire e ottimizzare il modello e valutarlo con poche righe di codice. Inoltre, con TensorFlow puoi monitorare gli esperimenti, configurare le GPU e distribuire il modello in produzione.
In questo tutorial abbiamo visto le basi delle reti neurali, i tipi di architetture di modello e le applicazioni. Inoltre, abbiamo imparato come addestrare una semplice rete neurale con `neuralnet` e una rete neurale convoluzionale con `keras`. Il tutorial copre la costruzione del modello, la compilazione, l’addestramento e la valutazione.
Approfondisci TensorFlow e l’API di Keras seguendo il corso Introduction to TensorFlow in R. Imparerai a usare TensorBoard e altre API di TensorFlow, a costruire reti neurali profonde e a migliorare le prestazioni del modello con regolarizzazione, dropout e ottimizzazione degli iperparametri.
