Costruisci reti neurali in Python & Scratch: un’introduzione divertente!

sbloccare l’AI: Creare Reti Neurali in Python e Scratch

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

Il nostro viaggio coprirà la teoria fondamentale, un’implementazione pratica in Python e poi un modo creativo per afferrare la meccanica attraverso Scratch. L’obiettivo è rendere “creare reti neurali in python in scratch” accessibile e comprensibile per tutti.

Che cos’è una Rete Neurale? L’Idea Fondamentale

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

Al suo interno, una rete neurale prende dati di input, li passa attraverso strati di “neuroni” (o nodi) interconnessi e produce un output. Ogni connessione ha un “peso” e ogni neurone ha un “bias”. Questi pesi e bias vengono regolati durante l’addestramento per rendere le previsioni della rete più accurate.

Input, Strati Nascosti e Output

Pensa a questo modo:

• Input Layer: Questo è il punto in cui i tuoi dati entrano. Ad esempio, se stai prevedendo i prezzi delle case, gli input potrebbero essere la metratura, il numero di camere da letto e la posizione.
• Hidden Layers: Queste sono le parti “pensanti”. Eseguono calcoli sui dati di input, trasformandoli. Una rete può avere uno o più strati nascosti. Problemi più complessi richiedono spesso più strati nascosti.
• Output Layer: Questo è il risultato finale. Per i prezzi delle case, l’output sarebbe il prezzo previsto. Per la classificazione delle 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 maggiore significa che l’input ha un’influenza più forte sull’attivazione del neurone successivo. Un bias è un parametro aggiuntivo in ogni neurone che aiuta a spostare la funzione di attivazione. Insieme, pesi e bias sono ciò che la rete neurale “apprende” durante l’addestramento.

Funzioni di Attivazione: Introduzione alla Non-Linearità

Dopo che un neurone riceve gli input, li moltiplica per i loro pesi e aggiunge un bias, passa il risultato attraverso una funzione di attivazione. Questa funzione introduce la non-linearità nella rete. Senza 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 Semplice Rete Neurale in Python

Ora, mettiamoci pratici. Useremo Python per costruire una rete neurale di base. Per questo, utilizzeremo NumPy per le operazioni numeriche, che è una libreria fondamentale per il calcolo scientifico in Python. Questo sarà il nostro primo passo per creare una rete neurale in Python.

Impostare il Tuo Ambiente

Prima di tutto, assicurati di avere Python installato. Poi, installa NumPy:

pip install numpy

Il Problema: Porta XOR

Alleneremo la nostra rete a risolvere il problema XOR (exclusive OR). La porta XOR è un esempio classico nelle reti neurali perché non è separabile linearmente. Questo significa che una singola retta non può separare le uscite vere dalle uscite false. Richiede uno strato nascosto.

Tabella della verità XOR:

• Input (0, 0) -> Output (0)
• Input (0, 1) -> Output (1)
• Input (1, 0) -> Output (1)
• Input (1, 1) -> Output (0)

Implementazione in Python: Una Rete Neurale a Due Strati

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

import numpy as np

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

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

# Dataset di input
X = np.array([[0,0],
 [0,1],
 [1,0],
 [1,1]])

# Dataset di output
y = np.array([[0],
 [1],
 [1],
 [0]])

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

# Inizializzare pesi e bias
# Pesi per input a strato nascosto (2 input, 4 neuroni nascosti)
weights_input_hidden = np.random.uniform(size=(2,4))
# Pesi per strato nascosto a strato di output (4 neuroni nascosti, 1 output)
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 ora.
# Per reti more avanzate, i bias sono cruciali.

learning_rate = 0.1
epochs = 10000

print("Pesi iniziali (input a nascosto):\n", weights_input_hidden)
print("Pesi iniziali (nascosto a output):\n", weights_hidden_output)

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

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

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

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

 # Calcolare 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"Epoch {epoch}, Loss: {loss:.4f}")

print("\nAddestramento completato.")
print("Pesi finali (input a nascosto):\n", weights_input_hidden)
print("Pesi finali (nascosto a output):\n", weights_hidden_output)
print("\nOutput previsto dopo l'addestramento:\n", predicted_output.round())

Comprendere il Codice Python

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

1. `sigmoid` e `sigmoid_derivative` funzioni: Queste implementano la funzione di attivazione sigmoid e la sua derivata, essenziale per la backpropagation.
2. Dataset `X` e `y`: Questi rappresentano i nostri input e output 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 vengono regolati i pesi ad ogni passo dell’addestramento. Un tasso di apprendimento più piccolo significa un apprendimento più lento ma potenzialmente più stabile.
5. `epochs`: Il numero di volte in cui la rete passerà attraverso l’intero dataset di addestramento.
6. Propagazione in Avanti:
   • Gli input vengono moltiplicati 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 l’`predicted_output`.
7. Backpropagation: Questa è la parte “di apprendimento”.
   • Calcolo dell’Errore: Troviamo la differenza tra `y` (output attuale) e `predicted_output`.
   • Delta dello Strato di Output: Questo è l’errore moltiplicato per la derivata della sigmoid dell’output previsto. Ci dice quanto regolare i pesi dello strato di output.
   • Errore dello Strato Nascosto: Propagiamo l’errore dallo strato di output allo strato nascosto.
   • Delta dello Strato Nascosto: Simile allo strato di output, questo ci dice quanto regolare i pesi dello strato nascosto.
   • Aggiornamenti dei Pesi: Infine, i pesi vengono regolati in base ai loro rispettivi delta e al `learning_rate`. Questo è il nucleo di come la rete apprende.

Dopo aver eseguito questo codice, vedrai la perdita della rete diminuire nel corso delle epoche, e il `predicted_output` dovrebbe corrispondere strettamente ai valori di `y` (tabella della verità XOR), dimostrando un apprendimento riuscito. Questo è un esempio fondamentale per creare una rete neurale 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 attivazione. Questo aiuta a consolidare la comprensione di “creare reti neurali in python in scratch” fornendo un’analogia visiva.

Perché Scratch per le Reti Neurali?

• Feedback Visivo: Vedi come gli input influenzano gli output in tempo reale.
• Apprendimento Interattivo: Manipola “pesi” e “bias” direttamente.
• Semplifica la Complessità: Concentrati su un concetto alla volta.
• Coinvolgente: Rende l’apprendimento divertente e accessibile.

Creare un Singolo “Neurone” in Scratch

Simuliamo un singolo neurone che prende due input, li moltiplica per pesi, li somma e applica una semplice soglia (come una funzione di attivazione a gradino). Questo è un ottimo modo per visualizzare un percettrone, la forma più semplice di una rete neurale.

Idea di Progetto Scratch: Un Neurone “Decision Maker”

Immagina un neurone che decide se dovresti “Uscire” in base a due input: “C’è Sole?” (1 per Sì, 0 per No) e “Fa Caldo?” (1 per Sì, 0 per No).

Passaggi in Scratch:

1. Crea Variabili:
   • `Input_Sunny` (sliders, intervallo 0-1)
   • `Input_Warm` (sliders, intervallo 0-1)
   • `Weight_Sunny` (sliders, intervallo -2 a 2)
   • `Weight_Warm` (sliders, intervallo -2 a 2)
   • `Bias` (sliders, intervallo -2 a 2)
   • `Weighted_Sum`
   • `Output_Decision` (sarà 0 o 1)
2. Crea Sprite:
   • Uno sprite “Neuron” (un cerchio)
   • Uno sprite “Output” (ad esempio, una faccina felice per “Uscire”, una faccina triste per “Restare Dentro”)
3. Script Sprite Neurone:

   
    quando si clicca sulla bandiera verde
    per sempre
    imposta Weighted_Sum a (Input_Sunny * Weight_Sunny) + (Input_Warm * Weight_Warm) + Bias
    se Weighted_Sum > 0 allora
    imposta Output_Decision a 1 // Uscire
    altrimenti
    imposta Output_Decision a 0 // Restare Dentro
    fine
    fine
    

4. Script Sprite Output:

   
    quando si clicca sulla bandiera verde
    per sempre
    se Output_Decision = 1 allora
    cambia costume in [Faccia Felice]
    dì "Andiamo fuori!" per 2 secondi
    altrimenti
    cambia costume in [Faccia Triste]
    dì "Resto dentro oggi." per 2 secondi
    fine
    fine
    

Sperimentare in Scratch

Dopo aver costruito questo in Scratch, gioca con i controlli:

• Cambia `Weight_Sunny` e `Weight_Warm`: Come influisce l’aumento di un peso sull’importanza di quell’input per la decisione di “Uscire”?
• Regola `Bias`: Come influisce il bias sulla soglia? Puoi fare in modo che il neurone decida sempre di uscire, anche se non c’è sole o caldo? O sempre di restare dentro?
• Osserva `Weighted_Sum`: Vedi come cambia con diversi input e pesi.

Questo semplice progetto in Scratch illustra chiaramente le meccaniche principali: input, pesi, somma e una funzione di attivazione (soglia). È un eccellente strumento visivo per comprendere la connessione “creazione di una rete neurale in Python in Scratch”, in particolare la parte “Scratch” per la comprensione concettuale.

Espandere le Tue Conoscenze: Passi Successivi in Python

Sebbene il nostro semplice esempio in Python sia un ottimo punto di partenza, le reti neurali del mondo reale utilizzano librerie e tecniche più avanzate. Ecco alcune direzioni da esplorare dopo aver masterizzato 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 a usare direttamente NumPy. Puoi definire strati, funzioni di attivazione e compilare il tuo modello con solo poche righe di codice.

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

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

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

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

# Fai 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 debolezza a seconda del problema.

Più Strati e Neuroni

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

Funzioni di Perdita e Ottimizzatori

Esplora diverse funzioni di perdita (ad es., Mean Squared Error, Categorical Crossentropy) e ottimizzatori (ad es., Adam, SGD con momentum). Questi influenzano significativamente quanto bene e quanto velocemente la tua rete impara.

Dataset del Mondo Reale

Supera XOR. Lavora con dataset di scikit-learn (ad es., Iris, Wine) o dataset pubblicamente disponibili come MNIST per la classificazione delle immagini. Questo è il punto in cui il potere di creare reti neurali in Python brilla veramente.

Conclusione

Hai fatto un passo significativo nel mondo dell’IA comprendendo e implementando una rete neurale. Dai concetti fondamentali di neuroni, pesi e funzioni di attivazione, a un’implementazione pratica in Python per il problema XOR, e persino a una simulazione visiva in Scratch, ora hai una solida comprensione. Il viaggio di creazione di reti neurali in Python in Scratch non riguarda solo il codificare; è riguardo a costruire intuizioni 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 abilità che hai acquisito qui sono trasferibili e costituiranno una solida base per progetti di apprendimento automatico più avanzati. Buon coding!

FAQ

Q1: Perché è necessario uno strato nascosto per problemi come XOR?

A1: Il problema XOR è “non linearmente separabile”. Ciò significa che non puoi disegnare una singola linea retta per separare gli input che producono un output di 0 da quelli che producono un output di 1. Un percettrone a singolo strato (senza uno strato nascosto) può apprendere solo schemi linearmente separabili. Uno strato nascosto consente alla rete neurale di apprendere relazioni più complesse e non lineari trasformando i dati di input in una nuova rappresentazione che può essere quindi separata linearmente dallo strato di output.

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

A2: NumPy fornisce gli strumenti fondamentali per il calcolo numerico in Python, consentendoti di implementare reti neurali da zero gestendo manualmente moltiplicazioni di matrici, funzioni di attivazione e retropropagazione. Questo ti dà una profonda comprensione delle meccaniche sottostanti. Keras (costruito su TensorFlow) è un’API di alto livello che astrae gran parte di questa complessità. Fornisce strati, ottimizzatori e funzioni di perdita predefiniti, rendendo molto più veloce e semplice costruire, addestrare e sperimentare architetture di reti neurali complesse, specialmente per dataset più grandi e modelli più sofisticati. Mentre NumPy è ottimo per apprendere le basi, Keras è preferito per applicazioni pratiche nel mondo reale.

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

A3: No, Scratch non è progettato per costruire reti neurali complesse e complete. Manca dell’efficienza computazionale, delle librerie matematiche (come NumPy) e delle funzionalità avanzate necessarie per addestrare modelli grandi con molti strati e parametri. Tuttavia, Scratch è uno strumento eccellente per visualizzare e comprendere i concetti fondamentali delle reti neurali, come funzionano i singoli neuroni, come vengono pesati gli input e come le funzioni di attivazione prendono decisioni. È un fantastico strumento educativo per i principianti per afferrare l’intuizione dietro “creare reti neurali in Python in Scratch” prima di esplorare il codice.

Q4: Quanto è importante il tasso di apprendimento e cosa succede se è troppo alto o troppo basso?

A4: Il tasso di apprendimento è cruciale! Determina la dimensione del passo 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 oscillazioni selvagge nella perdita o persino divergenza (aumentare invece di diminuire). La rete potrebbe non convergere mai verso una buona soluzione.
• Troppo Basso: Se il tasso di apprendimento è troppo basso, la rete imparerà molto lentamente. L’addestramento richiederà molto tempo e potrebbe rimanere bloccata in un “minimo locale” – una soluzione subottimale – prima di raggiungere il massimo globale.

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

🕒 Published: April 3, 2026