🧪 Jupyter Practical Lab Cases

Focus: Applicazioni reali di data engineering, analisi IA e monitoraggio sistemi.

::: info Questa pagina raccoglie template e workflow per notebook pronti all’uso. Ogni esempio segue la struttura: Caricamento Dati -> Elaborazione -> Visualizzazione -> Conclusioni. :::

🤖 Caso 1: AI Model Benchmarking (Local LLM)

Utilizziamo Jupyter per testare la velocità di inferenza di un modello locale (es. tramite le API di Ollama o LM Studio) e visualizzare la distribuzione della latenza.

Snippet Tecnico (Python)

import requests
import time
import pandas as pd
import matplotlib.pyplot as plt

def benchmark_llm(prompt, model="llama3"):
    start_time = time.time()
    response = requests.post("http://localhost:11434/api/generate", 
                             json={"model": model, "prompt": prompt, "stream": False})
    duration = time.time() - start_time
    return duration, response.json().get('response')

# Esecuzione test iterativo
results = [benchmark_llm("Explain Quantum Computing in one sentence") for _ in range(10)]
df = pd.DataFrame(results, columns=['Latency', 'Response'])

# Visualizzazione
df['Latency'].plot(kind='bar', title="LLM Inference Latency (s)")
plt.ylabel("Seconds")
plt.show()

🏠 Caso 2: Home Assistant Log Analysis

Analisi dei dati estratti dal database di Home Assistant (MariaDB) per identificare pattern di consumo energetico o cicli di temperatura.

Workflow di Analisi

1. Connessione: Accesso al database documentato in [[homeassistant/Database_Add-ons_Essenziali]].
2. Query: Estrazione stati delle entità negli ultimi 7 giorni.
3. Resampling: Pulizia dei dati e aggregazione oraria tramite Pandas.

Pro-Tip per l’Architetto

Usa la cella Jupyter per trasformare i timestamp grezzi in oggetti datetime e calcolare la derivata (es. velocità di riscaldamento di una stanza).

⚙️ Caso 3: C++ Bindings Validation (Pybind11)

Se stai sviluppando core logic in C++ (sezione [[programmazione/cpp/bindings]]), Jupyter è il posto perfetto per validare che i dati passati tra C++ e Python non subiscano corruzioni.

import my_cpp_module  # Il tuo modulo compilato in C++

data_input = [1.5, 2.3, 3.8]
cpp_result = my_cpp_module.heavy_computation(data_input)

# Verifica immediata con asserzioni
assert len(cpp_result) == len(data_input), "Data size mismatch!"
print(f"Result from C++ engine: {cpp_result}")

🎓 Caso 4: Python Playground (Livello Base - Scuole Superiori)

L’obiettivo è imparare la logica di programmazione tramite la manipolazione immediata delle variabili.

Struttura del Percorso Didattico:

1. Variabili e Matematica: Usare Jupyter come una calcolatrice potenziata.
2. Input e Output: Interagire con l’utente.
3. Cicli e Decisioni: Creare piccoli programmi logici.

Snippet Didattico (Primi Passi)

# --- STEP 1: DEFINIZIONE ---
user_name = input("Hi! What's your name? ")
current_age = int(input("How old are you? "))

# --- STEP 2: LOGICA ---
years_to_100 = 100 - current_age

# --- STEP 3: OUTPUT ---
print(f"Nice to meet you {user_name}!")
print(f"You will be 100 years old in {years_to_100} years.")

# ESERCIZIO: Prova a cambiare '100' con un altro numero e riesegui la cella (Shift + Enter)

🚀 Caso 5: Mastering Python (Livello Avanzato - Engineering)

Qui Jupyter viene usato per visualizzare concetti complessi che altrimenti resterebbero astratti.

Temi Trattati:

• List Comprehensions: Elaborazione dati in una riga.
• Decoratori: Modificare il comportamento delle funzioni.
• Gestione Errori: Scrivere codice resiliente.

Snippet Tecnico (Performance & Clean Code)

import time

# Un DECORATORE per misurare il tempo di esecuzione
def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"Execution time of {func.__name__}: {end - start:.6f} seconds")
        return result
    return wrapper

@timer_decorator
def advanced_processing(limit):
    """Calcola i quadrati dei numeri pari usando una list comprehension."""
    return [x**2 for x in range(limit) if x % 2 == 0]

# Test del carico
result = advanced_processing(100000)
print(f"Found {len(result)} elements.")

📉 Struttura Ideale di un Notebook (Mermaid)

graph TD
    INIT[1. Initialization: Imports & Config] --> DATA[2. Data Ingestion: API/SQL/CSV]
    DATA --> CLEAN[3. Preprocessing: Pandas/NumPy]
    CLEAN --> CORE[4. Core Logic: AI Inference / Algorithms]
    CORE --> VIZ[5. Visualization: Matplotlib/Seaborn]
    VIZ --> EXPORT[6. Findings Export: Markdown/PDF]
    
    style INIT fill:#f5f5f5,stroke:#333
    style CORE fill:#bbf,stroke:#333,stroke-width:2px
    style EXPORT fill:#bfb,stroke:#333

📉 Mappa dell’Apprendimento in Jupyter (Mermaid)

graph TD
    subgraph Beginner_Path [Livello Studente]
        B1[Variabili & Tipi] --> B2[Controllo di Flusso: If/Loops]
        B2 --> B3[Funzioni Semplici]
    end

    subgraph Advanced_Path [Livello Architect]
        A1[OOP: Classi e Oggetti] --> A2[Functional: Lambda & Iterators]
        A2 --> A3[Error Handling & Logging]
    end

    B3 -->|The Bridge| A1
    A3 --> PRO[Real World Projects]

💡 Metodologia di Studio Consigliata

Per un neofita che usa il tuo Wiki, ecco come dovrebbe utilizzare i notebook:

1. Read: Leggi la cella Markdown che spiega la teoria.
2. Run: Esegui il codice esistente per vedere cosa succede.
3. Break: Cambia i parametri (es. cambia un + con un *) e osserva come l’output cambia.
4. Fix: Risolvi eventuali errori che hai introdotto (questo è il modo più veloce per imparare).
5. Challenge: Prova a scrivere una nuova funzione simile in una cella vuota.

💡 Engineering Checklist per i tuoi Lab

Prima di chiudere un esperimento nel notebook, verifica:

• Riproducibilità: Se clicco “Restart & Run All”, il notebook arriva alla fine senza errori?
• Documentazione: Ogni blocco di codice è preceduto da una cella Markdown che ne spiega l’intento?
• Cleanup: Ho rimosso le chiavi API o i segreti prima di salvare?
• Environment: Il file requirements.txt è aggiornato con le librerie usate?

Tags: #AI #HomeAssistant #DataScience #Benchmarking #Python #Labs*