Potenza calcolo necessaria per l’AI.

di

Dialogo con Gemini.

Ciao, una AI come Gemini, cerca dati e li elabora in intenet, per esempio filmati youtube, ocr di immagini, …, con quante CPU in media (basta una stima molto rozza)?

Per rispondere alla tua domanda dobbiamo fare una premessa fondamentale: una IA come Gemini non usa quasi mai le CPU (i processori tradizionali) per l’elaborazione vera e propria dei dati. Utilizza invece chip super-specializzati chiamati TPU (Tensor Processing Units, i chip proprietari di Google) o GPU (schede video avanzate). Le CPU tradizionali rimangono sullo sfondo solo per coordinare il traffico dei dati e gestire i server. [1, 2, 3, 4, 5, 6]

Fatta questa distinzione, ecco una stima molto rozza della potenza di calcolo necessaria divisa nelle due fasi principali di Gemini: la “comprensione” (Addestramento) e la “risposta” (Inferenza). [1, 2]

1. Per “Imparare” (Addestramento del Modello)

Quando Google deve addestrare una versione di Gemini a fare OCR su miliardi di immagini, leggere video di YouTube o analizzare l’intero web, non usa un solo computer, ma un intero supercomputer distribuito (chiamato Cluster o Pod). [1, 2, 3]

  • Chip IA dedicati (TPU/GPU): Tra i 20.000 e i 50.000+ chip paralleli (come i TPU v5e/v6e/v7 di Google) che lavorano contemporaneamente per mesi. [1, 2, 3]
  • CPU di supporto: Per far funzionare questi cinquantamila chip IA servono dei server classici (“nodi”). Calcolando circa una CPU ad alte prestazioni ogni 4-8 chip IA, parliamo di circa 5.000 – 10.000 CPU fisiche (equivalenti a circa 60.000 – 120.000 core di calcolo) solo per gestire il flusso dei file da elaborare. [1, 2]

2. Per Singola Domanda dell’Utente (Inferenza)

Cosa succede quando tu carichi un video o un’immagine e chiedi a Gemini di analizzarla in tempo reale?

Il tuo singolo file non viene inviato a tutto il supercomputer, ma viene gestito da una piccola “porzione” (chiamata istanza) del data center. [1, 2]

  • Per un testo o un’immagine (OCR): Bastano mediamente da 1 a 4 chip IA (TPU/GPU dedicati) che lavorano per frazioni di secondo. A questi sono affiancate 1 o 2 CPU tradizionali per leggere il tuo input, formattarlo e inviarti la risposta. [1, 2, 3]
  • Per un filmato YouTube: I video sono enormi perché l’IA deve guardare decine di fotogrammi al secondo e contemporaneamente ascoltare l’audio. In questo caso la richiesta viene “spezzettata” e distribuita su un gruppo più grande, stimabile in circa 8 – 16 chip IA dedicati e 2 – 4 CPU di coordinamento per poterti rispondere in pochi secondi. [1, 2, 3]

Riassunto in cifre (Molto stimato)

Se consideriamo Gemini nel suo complesso, considerando che riceve milioni di domande al secondo da tutto il mondo: [1, 2]

  • Nel mondo, in questo preciso istante, ci sono centinaia di migliaia di chip IA (TPU) attivi che lavorano per Google.
  • Il numero di CPU tradizionali di supporto che fanno da “direttori d’orchestra” per questa infrastruttura globale è stimabile nell’ordine delle decine di migliaia. [1, 2]

Se hai un progetto specifico in mente o ti interessa sapere come l’IA gestisce un file multimediale (es. come “legge” i fotogrammi di un video), chiedi pure e approfondiamo!

You said: Tra i modelli eseguibili con Ollama ci sono modelli che possono elaborare filmati tipo da Youtube?

Sì, è possibile farlo, ma con un’importante distinzione tecnica: Ollama, di per sé, non gestisce lo streaming video diretto da YouTube né legge i file video .mp4. [1]

Tuttavia, puoi farlo combinando Ollama con dei modelli Multimodali (Vision) e un pizzico di codice Python (o tool pronti) per scaricare e “preparare” il video.

Ecco come funziona l’architettura per riuscirci a livello locale:

1. Quali modelli usare in Ollama?

Devi scegliere i modelli contrassegnati come Vision. I migliori attualmente disponibili su Ollama sono: [1]

  • LLaVA (Large Language and Vision Assistant): Il più famoso e collaudato su Ollama per l’analisi visiva.
  • MiniCPM-V: Eccellente nel comprendere sequenze di immagini e dettagli visivi consumando poche risorse.
  • Qwen2-VL / Qwen2.5-VL: Modelli straordinari nati proprio per l’analisi di immagini e sequenze video complesse.

2. Come fa un modello locale a “vedere” un video?

I modelli di visione non guardano il video in tempo reale come un essere umano. Il processo viene scomposto in tre passaggi automatici (solitamente gestiti tramite uno script Python):

  1. Estrazione Audio (Trascrizione): Lo script scarica l’audio da YouTube e usa un modello di speech-to-text locale (come Whisper di OpenAI) per creare il testo del parlato.
  2. Campionamento Visivo (Fotogrammi): Lo script “scatta delle foto” al video a intervalli regolari (ad esempio, un fotogramma ogni 2 o 5 secondi).
  3. Analisi con Ollama: Il testo trascritto e la sequenza di immagini vengono inviati al modello Vision su Ollama, che unisce le informazioni e ti fornisce il riassunto o risponde alle tue domande. [1]

Strumenti pronti da usare (Senza programmare)

Se vuoi testare questa funzione senza scrivere codice da zero, esistono due progetti open-source molto famosi che integrano Ollama e fanno esattamente questo:

  • Fabric (di Daniel Miessler): È un framework da riga di comando fenomenale. Ha dei comandi specifici (chiamati patterns) come yt (YouTube) dedicati a catturare i video di YouTube, estrarre i dati e mandarli al tuo modello Ollama locale per fare riassunti o analisi.
  • Open WebUI: È l’interfaccia grafica stile ChatGPT più usata per Ollama. Supporta le “Pipelines” e le funzioni multimediali: puoi installare dei plugin interni che ti permettono di incollare un link di YouTube direttamente nella chat per analizzarlo con il tuo modello locale. [1]

Se vuoi provare a configurare uno di questi strumenti o se preferisci vedere un piccolo esempio di codice Python per capire come automatizzare il processo sul tuo PC, fammelo sapere!

You said: Si grazie

Ecco una guida pratica e un esempio di codice Python pronto all’uso per far “leggere” un video a Ollama sul tuo computer.

Come abbiamo visto, i modelli locali elaborano i video analizzando una sequenza di immagini (fotogrammi) accoppiata al testo dell’audio. [1]

I Preparativi

Prima di eseguire il codice, devi installare i programmi e le librerie necessarie sul tuo PC.

  1. Installa FFmpeg (indispensabile per estrarre audio e fotogrammi dai video):
    • Windows: Scaricalo dal sito ufficiale e aggiungilo al PATH di sistema.
    • Mac: Apri il terminale e digita brew install ffmpeg.
    • Linux: Digita sudo apt install ffmpeg. [1]
  2. Scarica il modello Vision su Ollama:
    Nel tuo terminale, scarica il modello multimodale più efficiente (ad esempio Llama 3.2 Vision o Qwen 2.5 VL):bashollama pull llama3.2-vision Use code with caution. [1, 2]
  3. Installa le librerie Python:
    Nel tuo terminale, installa i pacchetti necessari per gestire i video, trascrivere l’audio e comunicare con Ollama:bashpip install opencv-python openai-whisper ollama yt-dlp Use code with caution. [1]

Il Codice Python

Questo script fa tutto in automatico: scarica un video da YouTube con yt-dlp, estrae l’audio, lo trascrive localmente usando Whisper, cattura alcuni fotogrammi chiave del video e infine invia tutto a Ollama per generare un riassunto completo basato su ciò che l’IA ha sia “visto” che “sentito”. [1, 2, 3]

Crea un file chiamato analizza_video.py e incolla questo codice:

python

import os
import cv2
import whisper
import yt_dlp
import ollama

# --- CONFIGURAZIONE ---
YOUTUBE_URL = "INSERISCI_QUI_IL_LINK_DI_YOUTUBE"  # Sostituisci con il link del tuo video
MODELLO_OLLAMA = "llama3.2-vision"               # Il modello scaricato prima
FOTOGRAMMI_AL_MINUTO = 4                         # Quanti "screenshot" catturare per ogni minuto di video

print("1. Scaricamento del video da YouTube...")
ydl_opts = {
    'format': 'mp4',
    'outtmpl': 'video_temporaneo.mp4',
    'quiet': True
}
with yt_dlp.YoutubeDL(ydl_opts) as ydl:
    ydl.download([YOUTUBE_URL])

print("2. Estrazione e trascrizione dell'audio (Locale con Whisper)...")
# Usiamo il modello 'base' di Whisper, leggero e preciso
modello_whisper = whisper.load_model("base")
risultato_audio = modello_whisper.transcribe("video_temporaneo.mp4")
testo_trascritto = risultato_audio["text"]

print("3. Estrazione dei fotogrammi visivi dal video...")
video = cv2.VideoCapture("video_temporaneo.mp4")
fps = video.get(cv2.CAP_PROP_FPS)
totale_frame = video.get(cv2.CAP_PROP_FRAME_COUNT)
durata_secondi = totale_frame / fps

# Calcoliamo ogni quanti frame scattare una foto
intervallo_frame = int((fps * 60) / FOTOGRAMMI_AL_MINUTO)
fotogrammi_salvati = []

successo, frame = video.read()
contatore = 0
id_foto = 0

while successo:
    if contatore % intervallo_frame == 0:
        nome_foto = f"frame_{id_foto}.jpg"
        cv2.imwrite(nome_foto, frame)
        fotogrammi_salvati.append(nome_foto)
        id_foto += 1
    successo, frame = video.read()
    contatore += 1

video.release()
print(f"   Estratti {len(fotogrammi_salvati)} fotogrammi dal video.")

print("4. Invio dei dati a Ollama (Analisi Multimodale)...")
prompt = f"""
Sei un assistente IA locale. Ti ho fornito la trascrizione del testo di un video e una serie di fotogrammi chiave estratti dal video stesso.
Combina quello che vedi nelle immagini con quello che c'è scritto nel testo per fare un riassunto dettagliato del video.

TRASCRIZIONE AUDIO:
{testo_trascritto}
"""

# Inviamo la richiesta a Ollama includendo la lista dei fotogrammi estratti
risposta = ollama.chat(
    model=MODELLO_OLLAMA,
    messages=[{
        'role': 'user',
        'content': prompt,
        'images': fotogrammi_salvati  # Ollama caricherà queste immagini nel contesto del modello
    }]
)

print("\n=== RISULTATO DELL'ANALISI LOCALE ===")
print(risposta['message']['content'])

# Pulizia dei file temporanei creati sul computer
print("\nPulizia dei file temporanei...")
os.remove("video_temporaneo.mp4")
for foto in fotogrammi_salvati:
    os.remove(foto)
print("Fatto!")

Use code with caution.

Come interpretare il comportamento del PC

Quando avvierai lo script, noterai due cose interessanti legandoci alla tua domanda precedente sulle CPU:

  1. Durante la fase di Whisper (passo 2) e di Ollama (passo 4), la tua scheda video (GPU) o la memoria unificata del processore schizzeranno al 100%. È l’IA che sta calcolando i vettori delle immagini e del testo. [1]
  2. Durante la fase di OpenCV (passo 3), vedrai lavorare la CPU tradizionale, impegnata nel decodificare fisicamente il file .mp4 e salvarlo in singole immagini sul disco rigido.