Come creare una AI in casa
L'intento di questa pagina è quello di fornire le indicazioni di massima per poter implementare una intelligenza artificiale in completa autonomia
Per realizzare un progetto di Intelligenza Artificiale (IA/AI) è indispensabile
avere una certa confdenza col linguaggio di programmazione Python.
Questo linguaggio è tra i più utilizzati nel campo grazie alla sua sintassi
semplice e intuitiva, ma soprattutto per la ricca disponibilità di librerie
e framework dedicati al machine learning e all’analisi dei dati, come TensorFlow,
PyTorch, Scikit-learn e molte altre.
La combinazione di potenza, flessibilità e una vasta community di supporto
rende Python lo strumento ideale per affrontare con successo qualsiasi tipo
di progetto legato all’intelligenza artificiale.
1 Obiettivo
Il primo passo per sviluppare un’Intelligenza Artificiale è definire con
chiarezza il suo scopo.
L’IA può essere progettata per diversi obiettivi: ad esempio, potrebbe trattarsi
di un chatbot conversazionale, simile a ChatGPT, capace di generare testo
e interagire in linguaggio naturale; oppure di un sistema dedicato al riconoscimento
di immagini, utile in ambiti come la sicurezza o la diagnostica; o ancora
di un modello per la generazione di immagini, impiegato in ambiti creativi
e artistici.
Ogni tipo di applicazione richiede un processo di addestramento specifico,
con dataset, tecniche e approcci differenti, che vanno scelti in base alle
esigenze del progetto.
2 Scelta della libreria
Il secondo step è quello di scegliere la libreria da utilizzare, ci sono 2 librerie principali:
- TensorFlow , sviluppato da Google, è più adatto a sistemi complessi e produzione su larga scala.
- PyTorch , sviluppata da Meta, a differenza di TensorFlow è molto più semplice da imparare e intuitiva, viene molto apprezzata da ricercatori e studenti grazie alla sua semplicità ma allo stesso tempo efficienza.
3 Preparazione dell’ambiente
Il terzo passo per realizzare la nostra Intelligenza Artificiale consiste
nel preparare l’ambiente di sviluppo. Questo passaggio è fondamentale per
garantire che tutti gli strumenti necessari siano correttamente configurati
e pronti all’uso. Il primo step consiste nell’installazione di Python, scaricabile
dal
sito ufficiale , che rappresenta il linguaggio di base su cui costruiremo
il progetto. Una volta completata l’installazione, sarà necessario procedere
con l’installazione di PyTorch, una delle librerie più potenti e flessibili
per lo sviluppo e l’addestramento di modelli di deep learning. Per farlo,
è sufficiente eseguire il seguente comando nel terminale:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
Questa configurazione ci permetterà di iniziare a costruire e testare la nostra IA in un ambiente ottimizzato e pronto per l’elaborazione avanzata.
4 Raccolta dei dati
Entriamo ora nella fase operativa del progetto: il primo passo concreto
è la raccolta dei dati, attraverso la creazione o l’utilizzo di un dataset.
Il dataset rappresenta il cuore dell’addestramento di qualsiasi modello
di Intelligenza Artificiale, in quanto fornisce le informazioni su cui la
rete neurale imparerà a svolgere il suo compito.
Solitamente i dataset sono disponibili in formato CSV, ma non è raro trovarli
anche in JSON o in altri formati strutturati. Nel caso di un chatbot, ad
esempio, il dataset sarà composto da coppie di domande e risposte. Tuttavia,
per una maggiore efficacia e contestualizzazione, spesso viene incluso anche
un campo di contesto che aiuta il modello a comprendere meglio il significato
delle conversazioni. Per reperire dataset già pronti e di buona qualità,
esistono piattaforme affidabili come HuggingFace
e Kaggle,
che mettono a disposizione una vasta selezione di dataset pubblici utilizzabili
in progetti di machine learning e AI.
5 Realizzazione della Rete
Neurale
Prima di tutto dobbiamo capire che cos’è effettivamente una Rete Neurale
(RN/NN) e a cosa serve.
La rete neurale è come se fosse il cuore del progetto, si tratta di emulare
il comportamento e il funzionamento del cervello umano, è costituita da
strati di neuroni (artificiali) che elaborano i dati in ingresso e generano
un output.
Il suo scopo è quello di imparare a svolgere un compito specifico ad esempio
conversare, questi neuroni apprendono durante la fase di addestramento nella
quale la rete analizza migliaia o milioni di esempi e regola i propri parametri
(chiamati anche pesi) per migliorare le proprie risposte.
I pesi sono le effettive connessioni tra i vari neuroni della rete neurale
e determinano quanto è importante un certo input per il risultato finale.
Una buona rete neurale di un piccolo/medio modello ha tra i 10 e i 50 miliardi
di parametri che consentono di avere una buona conoscenza e una buona precisione
nelle risposte. Un esempio di rete neurale in Python usando PyTorch è il
seguente:
class NeuralNetwork(nn.Module): #
Creazione della classe con estensione la rete neurale
def __init__(self, input_size, hidden_size, output_size):
# Crea il modello
super(NeuralNetwork, self).__init__() #
Inizializza il modello
self.fc1 = nn.Linear(input_size, hidden_size) #
Crea il primo layer (converte l’input in un numero di neuroni uguale a hidden_size)
self.fc2 = nn.Linear(hidden_size, output_size) # Crea
un secondo strato che risponde in output con la previsione del modello
del forward(self, x): # Questa funzione definisce
come i dati scorrono nel modello
x = F.relu(self.fc1(x)) # Applica il primo layer e
poi passa alla funzione di attivazione ReLU il risultato.
x = self.fc2(x) # Passa il risultato dal primo strato
al secondo strato
che genera l’output
return x
6 Addestramento del modello
L’addestramento è la fase nella quale la rete neurale apprende, questo processo
avviene tramite l’immissione di esempi con prompt e relativa risposta. Gli
esempi li abbiamo naturalmente all’interno del dataset, quando diamo il
dataset in pasto alla rete, sostanzialmente la rete prova a prevedere la
risposta dandogli un prompt in input e poi confronta il suo output con la
risposta effettiva nel dataset. Il processo di addestramento si suddivide
in epoche e ogni epoca dà nuovamente in input il dataset.
import torch.nn as nn # Qua si importa tutto il necessario per costruire la rete neurale
import torch.optim as optim # Invece questo fornisce le funzioni per ottimizzare i pesi
model = ChatbotModel(input_size=10, hidden_size=8, output_size=3) # Creazione del modello definendo i valori dei neuroni
x = torch.tensor([[0, 1, 0, 1, 0, 0, 1, 0, 0, 1]], dtype=torch.float32) # Questo è un esempio di frase codificata in numeri
y = torch.tensor([1], dtype=torch.long) # Classe corretta corrispondente all'input
criterion = nn.CrossEntropyLoss() # Questa funzione calcola l'errore tra l'output e il valore corretto
optimizer = optim.Adam(model.parameters(), lr=0.01) # Si utilizza l'ottimizzatore Adam per aggiornare i pesi
for epoch in range(10): # Definiamo il numero di epoche
output = model(x) # Passa l'input nella rete neurale
loss = criterion(output, y) # Calcola l'errore tra la previsione e la risposta corretta
optimizer.zero_grad() # Azzera i gradienti
loss.backward() # Calcola quanto ogni peso ha contribuito all'errore
optimizer.step() # Aggiorna i pesi per migliorare le risposte future
print(f"Epoca {epoch+1}, Loss: {loss.item():.4f}") # Stampa l'epoca e l'errore attuale del modello
7 Inferenza del modello
L'inferenza è la fase in cui il modello usa ciò che ha imparato per fare una previsione. A differenza dell'addestramento non aggiorna i pesi, ma semplicemente riceve un input, lo passa nel modello e restituisce un output.
output = model(x_test) # Passaggio del dato nel modello
predicted_out = torch.argmax(output, dim=1) # Seleziona la classe con probabilità più alta (es. 0 = saluto, 1 = domanda, ecc.)
print(f"Predizione del modello: classe {predicted_out.item()}") # Stampa dell’output