Differenze tra Reti Neurali CNN Vs ANN Vs RNN

Né tutti i modelli possono essere applicati a un problema, né tutti i problemi possono essere affrontati con una rete neurale .

Prerequisiti :

• Come funziona il Deep Learning o Apprendimento Profondo ?

• Spiegazione della più semplice rete neurale per principianti

• Come hackerare una rete neurale

• Cosa sono le reti neurali artificiali ANN?

• Cosa sono le reti neurali ricorrenti RNN?

• Cosa sono le reti neurali convoluzionali CNN?

Differenze tra Reti Neurali CNN Vs ANN Vs RNN

Se ti sei imbattuto in macchine che riconoscono il tuo viso e la tua voce tra milioni di immagini o audio e ti chiedi come sia possibile, è tutto merito delle reti neurali e del deep learning.

Assomiglia al ragionamento umano e ha ispirato i ricercatori di intelligenza artificiale a sviluppare algoritmi di rete neurale . Mentre gli algoritmi di apprendimento automatico prendono decisioni in base ai dati che ricevono, le reti neurali sono progettate per seguire un percorso per arrivare all'output in modo autonomo. I ricercatori sviluppano centinaia di algoritmi in un giorno con caratteristiche e capacità di prestazioni diverse e la maggior parte dei quali si basa su modelli esistenti per prevedere e costruire modelli del mondo reale. Né tutti i modelli possono essere applicati a un problema, né tutti i problemi possono essere affrontati con una rete neurale.

Tipi di reti neurali:

Rete neurale artificiale (ANN):

È un tipo di rete neurale progettata come rete feed-forward. Le informazioni passano da un livello all'altro senza rivisitare i livelli precedenti. È progettato per identificare il modello nei dati grezzi e migliorare ogni nuovo input che ottiene. L'architettura del design si sovrappone a tre livelli, in cui ogni strato aggiunge peso al passaggio delle informazioni. Sono popolarmente conosciuti come approssimatori funzionali universali, poiché sono in grado di apprendere funzioni non lineari. Utilizzato principalmente nei processi predittivi come nella business intelligence, nella previsione del testo, nel rilevamento di e-mail di spam, ecc., presenta pochi inconvenienti e vantaggi rispetto ad altri algoritmi.

Anche se si tratta di un algoritmo a più livelli, le possibilità di una corruzione graduale sono basse. Piuttosto si verifica per un lungo periodo in modo da avere abbastanza tempo per correggere gli errori. A differenza di altre reti, memorizza le informazioni sull'intera rete lasciando pochissime possibilità di interruzione dell'intero sistema a causa di alcune informazioni mancanti. Questa stessa caratteristica rende l'ANN più tollerante ai guasti di altre. Sono popolari per le loro capacità multitasking, poiché utilizzano un sistema a più livelli in cui le informazioni sono archiviate in ogni nodo, sviluppando così la capacità di generare risultati confrontando l'evento con quelli precedenti. Nonostante i suoi numerosi vantaggi, è praticamente difficile progettare una ANN perché richiede una grande quantità di dati e molte più prove per azzerare l'architettura giusta.

Semplice Esempio python Rete neurale artificiale (ANN):

import numpy as np

class NeuralNetwork():
    
    def __init__(self):
        # impostiamo il seed
        np.random.seed(1)
        
        #Convertiamo i pesi
        self.synaptic_weights = 2 * np.random.random((3, 1)) - 1

    def sigmoid(self, x):
        #sigmoide
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        #sigmoide derivata
        return x * (1 - x)

    def train(self, training_inputs, training_outputs, training_iterations):
        
        #Alleniamo il modello e aggiustiamo i pesi
        for iteration in range(training_iterations):
            
            output = self.think(training_inputs)

            #Calcoliamo l error rate per la back-propagation
            error = training_outputs - output
            
            #aggiustiamo i pesi
            adjustments = np.dot(training_inputs.T, error * self.sigmoid_derivative(output))

            self.synaptic_weights += adjustments

    def think(self, inputs):
        #passiamo gli input ai neuroni
        
        inputs = inputs.astype(float)
        output = self.sigmoid(np.dot(inputs, self.synaptic_weights))
        return output


if __name__ == "__main__":

    #Inizializziamo la classe
    neural_network = NeuralNetwork()

    print("Genero pesi casuali: ")
    print(neural_network.synaptic_weights)

    #creo un dataset fittizzio
    training_inputs = np.array([[0,0,1],
                                [1,1,1],
                                [1,0,1],
                                [0,1,1]])

    training_outputs = np.array([[0,1,1,0]]).T

    #Alleno il modello
    neural_network.train(training_inputs, training_outputs, 15000)

    print("Pesi dopo l allenamento: ")
    print(neural_network.synaptic_weights)

    user_input_one = str(input("User Input 1: "))
    user_input_two = str(input("User Input 2: "))
    user_input_three = str(input("User Input 3: "))
    
    print("Considerando un altra situazione: ", user_input_one, user_input_two, user_input_three)
    print("Output data: ")
    print(neural_network.think(np.array([user_input_one, user_input_two, user_input_three])))
    print("Ecco una ANN in python")

Rete neurale di convoluzione (CNN):

Ampiamente usate per le sue applicazioni di visione artificiale, viene implementasti con tre tipi di strati , livello convoluzionale, livello di pooling e livello completamente connesso. La complessità degli algoritmi aumenta ad ogni livello. Analizzano l'input attraverso una serie di filtri noti come kernel. Sono come matrici che si spostano sui dati di input, utilizzate per estrarre le caratteristiche dalle immagini. Man mano che le immagini di input vengono elaborate, i collegamenti tra i neuroni si sviluppano come kernel negli strati. Ad esempio, per elaborare un'immagine, i kernel passano attraverso livelli sequenziali e cambiano di conseguenza nel processo di identificazione di colori, forme e, infine, l'immagine complessiva.

Gli algoritmi della CNN sono diventati famosi dopo che la tecnologia visiva è diventata la principale fonte di diffusione delle informazioni. I compiti che gli esseri umani erano soliti svolgere in precedenza, ora sono semplificati con strumenti abilitati all'intelligenza artificiale sviluppati per il riconoscimento facciale, il riconoscimento delle immagini, l'analisi dei caratteri scritti a mano, l'analisi a raggi X, ecc. Gli algoritmi della CNN sono ancora nascenti e hanno problemi a lavorare con le variabili dati. È stato riferito che gli algoritmi della CNN non sono all'altezza quando si tratta di elaborare oggetti nascosti nelle immagini, elaborare immagini intitolate o ruotate. L'addestramento degli algoritmi della CNN richiede buone GPU (Graphical Processing Units), la cui mancanza potrebbe rallentare il progetto.

Semplice Esempio python Rete neurale di convoluzione (CNN):

#Importiamo le librerie
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import MaxPool2D
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dropout
from tensorflow.keras.layers import Dense

#Carichiamo i dati
(X_train,y_train) , (X_test,y_test)=mnist.load_data()

X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], X_train.shape[2], 1))
X_test = X_test.reshape((X_test.shape[0],X_test.shape[1],X_test.shape[2],1))
 
#Check dopo il reshape
print(X_train.shape)
print(X_test.shape)

#Normalizziamo il valore dei pixel
X_train=X_train/255
X_test=X_test/255

#Struttura modello 
model=Sequential()
# convolution layer
model.add(Conv2D(32,(3,3),activation='relu',input_shape=(28,28,1)))

# pooling layer
model.add(MaxPool2D(2,2))

# fully connected layer
model.add(Flatten())
model.add(Dense(100,activation='relu'))

# output layer
model.add(Dense(10,activation='softmax'))

#Compiliamo il modello
model.compile(loss='sparse_categorical_crossentropy',optimizer='adam',metrics=['accuracy'])

# Alleniamo il modello
model.fit(X_train,y_train,epochs=10)

#Valutiamo il modello
model.evaluate(X_test,y_test)

Reti neurali ricorrenti (RNN):

Il riconoscimento vocale e l'elaborazione del linguaggio naturale sono i due cardini della rete RNN. Che si tratti di ricerca vocale con Siri di Apple, Google Translate o la tecnologia di rilevamento dei volti di Picasa, tutto è possibile grazie agli algoritmi RNN. Contrariamente alle reti feed-forward, le reti RNN sfruttano la memoria. Mentre per le reti neurali tradizionali si presume che gli input e gli output siano indipendenti, la rete RNN dipende dagli output precedenti all'interno della sequenza. Le reti RTT utilizzano una tecnica di backpropagation leggermente diversa da quella utilizzata da altre reti, specifica per la sequenza completa di dati.

RNN è noto per la sua doppia capacità di elaborazione dei dati, ovvero elabora dati appartenenti al presente e al passato immediato, sviluppando quindi memoria e consapevolezza del contesto attraverso una comprensione approfondita delle sequenze. Questi algoritmi possono essere progettati per elaborare diversi input e output simultaneamente mappando set di dati uno-a-uno, uno-molti, molti-a-uno e molti-a-molti. Nonostante i vantaggi che RNN ha da offrire, presenta notevoli ostacoli nel processo di sviluppo. Richiedono molto tempo per addestrare gli algoritmi RNN e non sono così facili da sviluppare o implementare. A causa del modo in cui i livelli sono disposti nel modello RNN, la sequenza diventa piuttosto lunga con conseguente esplosione o pesi nulli, portando a un problema di gradiente. Per far funzionare un modello RNN, è necessario impilare le sequenze,

Non c'è da stupirsi, le reti neurali stanno rapidamente diventando indispensabili per la loro versatilità nel fornire soluzioni a diversi problemi aziendali. McKinsey stima che il deep learning e le reti neurali abbiano il potenziale per far girare un mercato da 3,5 trilioni di dollari a 5,8 trilioni di dollari in diversi domini. L'unico problema a portata di mano dovrebbe essere identificare la rete neurale giusta.

Semplice Esempio python Reti neurali ricorrenti (RNN):

• Implementare le reti neurali ricorrenti (RNN) con Python e Keras

Vuoi mettere in pratica quello che hai letto ?

1. Scarica Progetti già pronti

2. Lavora con il nostro editor online senza dover installare librerie

3. Usa i nostri set di Dati

Oppure segui i tutorial correlati :

• Tutorial di Regressione Logistica per l'apprendimento automatico

• Riconoscimento facciale con Python, in meno di 25 righe di codice

• Tutorial di Regressione Logistica per l'apprendimento automatico

• Scikit Learn e Python Tutorial Per Creare Modelli di Intelligenza Artificiale

• Tutorial Pratico Tensorflow , TensorBoard e Python

• Feature Engineering e Feature Selection per Principianti e non

• Spiegazione della più semplice rete neurale per principianti

• PyScript, come usare Python nel browser!

• Il tuo Primo Programma di Machine Learning con Python e Google Colab

• Il tuo primo Programma di Deep Learning in Python con Keras Step-By-Step

• Come costruire modelli predittivi sanitari utilizzando PyHealth?

• Esempio pratico Rilevamento Di Veicoli In Tempo Reale

• Come implementare l'algoritmo Perceptron da zero in Python

• Implementare le reti neurali ricorrenti (RNN) con Python e Keras

• Deep learnign e python : Object Recognition e Object Predict esempio

• Come salvare e caricare il tuo modello di deep learning