Costruire reti neurali in Python & Scratch: Un’introduzione divertente!

Sbloccare l’IA: Creare reti neurali in Python e Scratch

Ciao, sono Alex Petrov, ingegnere ML. Oggi demistificheremo le reti neurali. Potresti pensare che siano complesse, riservate ai programmatori avanzati. Ma ti mostrerò come iniziare a creare reti neurali in Python e, sorprendentemente, persino visualizzare i concetti fondamentali con Scratch. Questo articolo fornisce passaggi pratici e concreti per i principianti per comprendere e costruire i loro primi modelli di IA.

Il nostro viaggio copierà la teoria fondamentale, un’implementazione pratica in Python, e infine un modo creativo per afferrare i meccanismi attraverso Scratch. L’obiettivo è rendere la creazione di “reti neurali in python in scratch” accessibile e comprensibile per tutti.

Che cos’è una rete neurale? L’idea principale

Immagina il tuo cervello. Ha miliardi di neuroni, interconnessi, che elaborano le informazioni. Una rete neurale è un modello semplificato di questo processo biologico. Si tratta di una serie di algoritmi che cercano di identificare relazioni sottostanti in un insieme di dati attraverso un processo che imita il modo in cui funziona il cervello umano.

Al cuore, una rete neurale prende dati in ingresso, li fa passare attraverso strati di “neuroni” (o nodi) interconnessi e produce un’uscita. Ogni connessione ha un “peso” e ogni neurone ha un “bias”. Questi pesi e bias vengono aggiustati durante l’addestramento per rendere le previsioni della rete più accurate.

Ingressi, Strati Nascosti e Uscite

Pensalo in questo modo:

• Strato di Ingresso: È qui che i tuoi dati entrano. Ad esempio, se prevedi i prezzi delle case, gli ingressi potrebbero essere la superficie, il numero di stanze e la posizione.
• Strati Nascosti: Queste sono le parti “pensanti”. Eseguono calcoli sui dati in ingresso, trasformandoli. Una rete può avere uno o più strati nascosti. I problemi più complessi richiedono spesso più strati nascosti.
• Strato di Uscita: È il risultato finale. Per i prezzi delle case, l’uscita sarebbe il prezzo previsto. Per classificare le immagini, potrebbe essere l’etichetta “gatto” o “cane”.

Pesi e Bias: I Parametri Apprendibili della Rete

Ogni connessione tra neuroni ha un peso. Questo peso determina la forza e l’importanza di quella connessione. Un peso più alto significa che questo ingresso ha un’influenza maggiore sull’attivazione del neurone successivo. Un bias è un parametro aggiuntivo in ogni neurone che aiuta a spostare la funzione di attivazione. Insieme, i pesi e i bias sono ciò che la rete neurale “impara” durante l’addestramento.

Funzioni di Attivazione: Introduzione alla Non-Linearità

Dopo che un neurone ha ricevuto ingressi, li ha moltiplicati per i loro pesi e ha aggiunto un bias, passa il risultato attraverso una funzione di attivazione. Questa funzione introduce non-linearità nella rete. Senza le funzioni di attivazione, una rete neurale sarebbe semplicemente un modello lineare, incapace di apprendere schemi complessi. Le funzioni di attivazione comuni includono ReLU (Rectified Linear Unit), Sigmoid e Tanh.

Costruire una Rete Neurale Semplice in Python

Ora, passiamo alla pratica. Utilizzeremo Python per costruire una rete neurale di base. A questo scopo, useremo NumPy per le operazioni numeriche, che è una libreria fondamentale per il calcolo scientifico in Python. Questo sarà il nostro primo passo verso la creazione di reti neurali in Python.

Configurare il Tuo Ambiente

Per prima cosa, assicurati di avere Python installato. Poi, installa NumPy:

pip install numpy

Il Problema: La Porta XOR

Stiamo per addestrare la nostra rete a risolvere il problema XOR (OR esclusivo). La porta XOR è un esempio classico nelle reti neurali perché non è linearmente separabile. Ciò significa che una sola retta non può separare le uscite vere dalle uscite falsi. Questo richiede uno strato nascosto.

Tabella della verità XOR:

• Ingresso (0, 0) -> Uscita (0)
• Ingresso (0, 1) -> Uscita (1)
• Ingresso (1, 0) -> Uscita (1)
• Ingresso (1, 1) -> Uscita (0)

Implementazione in Python: Una Rete Neurale a Due Strati

Ecco il codice Python per una rete neurale feedforward semplice con uno strato nascosto. Utilizzeremo la funzione di attivazione sigmoide e implementeremo l’algoritmo di retropropagazione per l’addestramento.

import numpy as np

# Funzione di attivazione sigmoide e la sua derivata
def sigmoid(x):
 return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
 return x * (1 - x)

# Gioco di dati di ingresso
X = np.array([[0,0],
 [0,1],
 [1,0],
 [1,1]])

# Gioco di dati di uscita
y = np.array([[0],
 [1],
 [1],
 [0]])

# Semenza per la riproducibilità
np.random.seed(1)

# Inizializzare i pesi e i bias
# Pesi dallo strato di ingresso allo strato nascosto (2 ingressi, 4 neuroni nascosti)
weights_input_hidden = np.random.uniform(size=(2,4))
# Pesi dallo strato nascosto allo strato di uscita (4 neuroni nascosti, 1 uscita)
weights_hidden_output = np.random.uniform(size=(4,1))

# Bias (opzionale, ma buona pratica per reti più complesse)
# Per semplicità, ometteremo i bias espliciti in questo esempio di base,
# lasciando che i pesi gestiscano lo spostamento per il momento.
# Per reti più avanzate, i bias sono cruciali.

learning_rate = 0.1
epochs = 10000

print("Pesi iniziali (ingresso a nascosta):\n", weights_input_hidden)
print("Pesi iniziali (nascosta a uscita):\n", weights_hidden_output)

for epoch in range(epochs):
 # Retropropagazione
 # Calcolare l'uscita dello strato nascosto
 hidden_layer_input = np.dot(X, weights_input_hidden)
 hidden_layer_output = sigmoid(hidden_layer_input)

 # Calcolare l'uscita dello strato di uscita
 output_layer_input = np.dot(hidden_layer_output, weights_hidden_output)
 predicted_output = sigmoid(output_layer_input)

 # Retropropagazione
 # Calcolare l'errore
 error = y - predicted_output

 # Calcolare il delta per lo strato di uscita
 d_predicted_output = error * sigmoid_derivative(predicted_output)

 # Calcolare l'errore per lo strato nascosto
 error_hidden_layer = d_predicted_output.dot(weights_hidden_output.T)
 d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output)

 # Aggiornare i pesi
 weights_hidden_output += hidden_layer_output.T.dot(d_predicted_output) * learning_rate
 weights_input_hidden += X.T.dot(d_hidden_layer) * learning_rate

 if epoch % 1000 == 0:
 loss = np.mean(np.abs(error))
 print(f"Epoca {epoch}, Perdita : {loss:.4f}")

print("\nAddestramento completato.")
print("Pesi finali (ingresso a nascosta):\n", weights_input_hidden)
print("Pesi finali (nascosta a uscita):\n", weights_hidden_output)
print("\nUscita prevista dopo l'addestramento:\n", predicted_output.round())

Comprendere il Codice Python

Decomponiamo il codice Python per creare una rete neurale in Python:

1. Funzioni `sigmoid` e `sigmoid_derivative`: Queste implementano la funzione di attivazione sigmoide e la sua derivata, essenziali per la retropropagazione.
2. Set di dati `X` e `y`: Questi set rappresentano i nostri ingressi e uscite per il problema XOR.
3. Inizializzazione dei pesi: `weights_input_hidden` e `weights_hidden_output` vengono inizializzati con valori casuali. Questa casualità è cruciale per evitare che tutti i neuroni apprendano la stessa cosa.
4. `learning_rate`: Questo controlla quanto i pesi vengono adeguati durante ogni fase di addestramento. Un tasso di apprendimento più piccolo significa un apprendimento più lento ma potenzialmente più stabile.
5. `epochs`: Il numero di volte che la rete passerà attraverso l’intero set di dati di addestramento.
6. Propagazione in Avanti:
   • Le entrate vengono moltiplicate per `weights_input_hidden` per ottenere `hidden_layer_input`.
   • `hidden_layer_input` viene passato attraverso la funzione `sigmoid` per ottenere `hidden_layer_output`.
   • `hidden_layer_output` viene moltiplicato per `weights_hidden_output` per ottenere `output_layer_input`.
   • `output_layer_input` viene passato attraverso `sigmoid` per ottenere `predicted_output`.
7. Retropropagazione: Questa è la parte “di apprendimento”.
   • Calcolo dell’errore: Troviamo la differenza tra `y` (uscita reale) e `predicted_output`.
   • Delta dello Strato di Uscita: È l’errore moltiplicato per la derivata della sigmoide dell’uscita prevista. Ci indica quanto adeguare i pesi dello strato di uscita.
   • Errore dello Strato Nascosto: Facciamo propagare l’errore all’indietro dallo strato di uscita allo strato nascosto.
   • Delta dello Strato Nascosto: Simile allo strato di uscita, ci indica quanto adeguare i pesi dello strato nascosto.
   • Aggiornamenti dei Pesi: Infine, i pesi vengono adeguati in base ai loro deltas rispettivi e al `learning_rate`. Questo è il cuore del modo in cui la rete impara.

Dopo aver eseguito questo codice, vedrai la perdita della rete diminuire nel tempo, e la `predicted_output` dovrebbe avvicinarsi ai valori di `y` (tabella della verità XOR), dimostrando un apprendimento riuscito. Questo è un esempio fondamentale per creare reti neurali in Python.

Visualizzare i Concetti delle Reti Neurali con Scratch

Comprendere la matematica astratta può essere difficile. È qui che entra in gioco Scratch! Anche se non puoi costruire una rete neurale complessa direttamente in Scratch, puoi creare simulazioni interattive che dimostrano concetti fondamentali come neuroni, pesi e attivazioni. Questo aiuta a solidificare la comprensione di “creare una rete neurale in python in scratch” fornendo un’analogia visiva.

Perché Scratch per le Reti Neurali?

• Feedback Visivo: Vedi come le entrate influenzano le uscite in tempo reale.
• Apprendimento Interattivo: Manipola direttamente i “pesi” e i “bias”.
• Complessità Semplificata: Concentrati su un concetto alla volta.
• Coinvolgente: Rende l’apprendimento divertente e accessibile.

Creare un Unico “Neurone” in Scratch

Simuliamo un neurone unico che prende due entrate, le moltiplica per pesi, le somma e applica una soglia semplice (come una funzione di attivazione a gradini). Questo è un ottimo modo per visualizzare un perceptron, la forma più semplice di una rete neurale.

Idea di progetto Scratch: un neurone “Prenditore di Decisioni”

Immagina un neurone che decide se uscire in base a due ingressi: “È una giornata di sole?” (1 per Sì, 0 per No) e “Fa caldo?” (1 per Sì, 0 per No).

Passaggi in Scratch:

1. Creare variabili:
   • `Input_Sunny` (slider, intervallo 0-1)
   • `Input_Warm` (slider, intervallo 0-1)
   • `Weight_Sunny` (slider, intervallo -2 a 2)
   • `Weight_Warm` (slider, intervallo -2 a 2)
   • `Bias` (slider, intervallo -2 a 2)
   • `Weighted_Sum`
   • `Output_Decision` (sarà 0 o 1)
2. Creare sprite:
   • Uno sprite “Neurone” (un cerchio)
   • Uno sprite “Uscita” (ad esempio, una faccia felice per “Uscire”, una faccia triste per “Rimanere dentro”)
3. Script dello sprite Neurone:

   
    quando il drago verde viene cliccato
    in eterno
    impostare Weighted_Sum a (Input_Sunny * Weight_Sunny) + (Input_Warm * Weight_Warm) + Bias
    se Weighted_Sum > 0 allora
    impostare Output_Decision a 1 // Uscire
    altrimenti
    impostare Output_Decision a 0 // Rimanere dentro
    fin
    fin
    

4. Script dello sprite Uscita:

   
    quando il drago verde viene cliccato
    in eterno
    se Output_Decision = 1 allora
    cambiare costume in [Faccia Felice]
    dire "Andiamo fuori!" per 2 secondi
    altrimenti
    cambiare costume in [Faccia Triste]
    dire "Rimanere dentro oggi." per 2 secondi
    fin
    fin
    

Sperimentare in Scratch

Una volta che hai costruito questo in Scratch, gioca con i cursori:

• Modificare `Weight_Sunny` e `Weight_Warm`: In che modo l’aumento di un peso rende questa entrata più importante per la decisione “Uscire”?
• Regolare `Bias`: In che modo il bias influisce sulla soglia? Puoi far sì che il neurone decida sempre di uscire, anche se non è né sole né caldo? O di rimanere sempre dentro?
• Osservare `Weighted_Sum`: Vedi come questo cambia con diverse entrate e pesi.

Questo semplice progetto Scratch illustra in modo vivido i meccanismi di base: entrate, pesi, somma e funzione di attivazione (soglia). È un ottimo supporto visivo per comprendere la connessione “creare una rete neurale in python in scratch”, in particolare la parte “scratch” per la comprensione concettuale.

Ampliare le vostre conoscenze: Passi successivi in Python

Anche se il nostro semplice esempio Python è un ottimo inizio, le vere reti neurali utilizzano librerie e tecniche più avanzate. Ecco alcune direzioni da esplorare dopo aver padroneggiato le basi della creazione di reti neurali in Python:

TensorFlow e Keras

Queste sono librerie potenti e ampiamente utilizzate per costruire e addestrare reti neurali. Keras, in particolare, fornisce un’API di alto livello che rende la costruzione di modelli complessi molto più semplice rispetto all’uso di NumPy puro. Definisci i livelli, le funzioni di attivazione e compili il tuo modello in poche righe di codice.

# Esempio utilizzando Keras (semplificato)
from tensorflow import keras
from tensorflow.keras import layers

# Definire il modello
model = keras.Sequential([
 layers.Dense(4, activation='relu', input_shape=(2,)), # Livello nascosto con 4 neuroni, ReLU
 layers.Dense(1, activation='sigmoid') # Livello di output con 1 neurone, Sigmoid
])

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

# Allenare il modello (utilizzando X e y dal nostro esempio XOR)
model.fit(X, y, epochs=1000, verbose=0)

# Fare previsioni
predictions = model.predict(X)
print("Previsioni Keras:\n", predictions.round())

Diverse funzioni di attivazione

Sperimenta con ReLU, Leaky ReLU, Tanh e altre funzioni di attivazione. Ognuna ha i suoi punti di forza e debolezze a seconda del problema.

Più livelli e neuroni

Costruisci reti più profonde (più livelli nascosti) e più larghe (più neuroni per livello) per affrontare problemi più complessi. Fai attenzione all’overfitting, in cui la rete apprende troppo bene i dati di addestramento e performa male su dati nuovi e non visti.

Funzioni di perdita e ottimizzatori

Esplora diverse funzioni di perdita (ad esempio, Errore Quadratico Medio, Entropia Incrociata Categoriale) e ottimizzatori (ad esempio, Adam, SGD con momentum). Questo influisce notevolmente sull’efficacia e sulla rapidità di apprendimento della tua rete.

Dati del mondo reale

Vai oltre XOR. Lavora con dataset provenienti da scikit-learn (ad esempio, Iris, Wine) o dataset pubblicamente disponibili come MNIST per la classificazione delle immagini. È qui che la potenza della creazione di reti neurali in Python brilla davvero.

Conclusione

Hai fatto un primo passo significativo nel mondo dell’IA comprendendo e implementando una rete neurale. Dalla comprensione dei concetti base di neuroni, pesi e funzioni di attivazione, a un’implementazione pratica in Python per il problema XOR, e persino una simulazione visiva in Scratch, ora hai una buona comprensione. Il percorso di creazione di una rete neurale in python in scratch non riguarda solo il codifica; si tratta di sviluppare intuizione e comprendere come questi sistemi intelligenti apprendono.

Ricorda, l’IA è un processo iterativo. Continua a sperimentare, continua a imparare e non aver paura di rompere le cose e ricostruirle. Le competenze che hai acquisito qui sono trasferibili e serviranno da solida base per progetti più avanzati nel machine learning. Buona programmazione!

FAQ

Q1: Perché è necessaria una rete nascosta per problemi come XOR?

A1: Il problema XOR è “non linearmente separabile.” Questo significa che non puoi tracciare una sola linea retta per separare le entrate che danno un risultato di 0 da quelle che danno un risultato di 1. Un perceptron a un solo livello (senza livello nascosto) può apprendere solo modelli linearmente separabili. Un livello nascosto consente alla rete neurale di apprendere relazioni più complesse e non lineari trasformando i dati di input in una nuova rappresentazione che può poi essere separata linearmente dal livello di output.

Q2: Qual è la principale differenza tra l’utilizzo di NumPy e Keras per creare reti neurali?

A2: NumPy fornisce gli strumenti fondamentali per il calcolo numerico in Python, consentendoti di implementare reti neurali in modo artigianale gestendo manualmente le moltiplicazioni matriciali, le funzioni di attivazione e il backpropagation. Questo ti offre una comprensione profonda dei meccanismi sottostanti. Keras (basato su TensorFlow) è un’API di alto livello che astrae gran parte di questa complessità. Fornisce livelli pre-costruiti, ottimizzatori e funzioni di perdita, rendendo molto più veloce e facile costruire, addestrare e sperimentare con architetture complesse di reti neurali, in particolare per set di dati più grandi e modelli più sofisticati. Mentre NumPy è eccellente per apprendere le basi, Keras è preferito per applicazioni pratiche nel mondo reale.

Q3: Posso costruire una rete neurale completa e complessa direttamente in Scratch?

A3 : No, Scratch non è progettato per costruire reti neurali complete e complesse. Mancano l’efficienza computazionale, le librerie matematiche (come NumPy) e le funzionalità avanzate necessarie per addestrare grandi modelli con numerosi strati e parametri. Tuttavia, Scratch è un ottimo strumento per visualizzare e comprendere i concetti fondamentali delle reti neurali, come funzionano i neuroni individuali, come vengono ponderati gli input e come le funzioni di attivazione prendono decisioni. È un fantastico strumento educativo per i principianti per afferrare l’intuizione dietro “creare una rete neurale in ptyhono in scratch” prima di esplorare il codice.

Q4 : Qual è l’importanza del tasso di apprendimento, e cosa succede se è troppo alto o troppo basso?

A4 : Il tasso di apprendimento è cruciale! Determina la dimensione dei passi con cui i pesi della rete neurale vengono aggiornati durante l’addestramento.

• Troppo alto: Se il tasso di apprendimento è troppo alto, la rete potrebbe “superare” i pesi ottimali, causando un’oscillazione selvaggia della perdita o addirittura una divergenza (aumento invece di diminuzione). La rete potrebbe non convergere mai verso una buona soluzione.
• Troppo basso: Se il tasso di apprendimento è troppo basso, la rete apprenderà molto lentamente. L’addestramento richiederà molto tempo, e potrebbe rimanere bloccata in un “minimo locale” – una soluzione subottimale – prima di raggiungere l’ottimo globale.

Trovare un tasso di apprendimento appropriato è spesso un processo di tentativi ed errori, o utilizzando ottimizzatori adattativi come Adam, che regolano automaticamente il tasso di apprendimento durante l’addestramento.

🕒 Published: April 3, 2026