NumPy per l'Intelligenza Artificiale

import numpy as np

velocita = np.array([12.3, 11.8, np.nan, 13.1, 12.7, np.nan, 11.5, 14.0])

# 1. Quante sessioni mancanti?
n_mancanti = np.sum(np.isnan(velocita))
print(f"Sessioni con dati mancanti: {n_mancanti}")  # 2

# 2. Rimozione NaN
velocita_pulita = velocita[~np.isnan(velocita)]
print(f"Velocità valide: {velocita_pulita}")
# [12.3, 11.8, 13.1, 12.7, 11.5, 14.0]

# 3. Velocità media
media = velocita_pulita.mean()
print(f"Velocità media: {media:.2f} km/h")  # 12.57 km/h

# 4. Sessioni sopra la media
sopra_media = velocita_pulita[velocita_pulita > media]
print(f"Sessioni sopra la media: {len(sopra_media)}")  # 3
print(f"Velocità di quelle sessioni: {sopra_media}")

import numpy as np

canzoni = np.array([
    [128, 210, -5,  87],
    [ 95, 195, -8,  62],
    [140, 240, -3,  95],
    [ 75, 180, -12, 41],
    [110, 225, -6,  78],
])

# 1. Normalizzazione Min-Max colonna per colonna
minimi = canzoni.min(axis=0)   # [75, 180, -12, 41]
massimi = canzoni.max(axis=0)  # [140, 240, -3, 95]
canzoni_norm = (canzoni - minimi) / (massimi - minimi)

print("Canzoni normalizzate:")
print(canzoni_norm.round(3))

# 2. Verifica: ogni colonna va da 0.0 a 1.0
print("\nMinimi per colonna:", canzoni_norm.min(axis=0))  # [0. 0. 0. 0.]
print("Massimi per colonna:", canzoni_norm.max(axis=0))  # [1. 1. 1. 1.]

# 3. Canzone con BPM più alto
idx_bpm_max = np.argmax(canzoni_norm[:, 0])
print(f"\nCanzone con BPM più alto: canzone {idx_bpm_max}")  # canzone 2 (140 BPM)

import numpy as np

pressione = np.array([118, 125, 132, 119, 450, 128, 121,
                       135, 127, 122, 12, 130])

# 1. Media vs mediana
print(f"Media:   {pressione.mean():.1f} mmHg")    # 139.1 — distorta dagli outlier
print(f"Mediana: {np.median(pressione):.1f} mmHg") # 126.5 — molto più realistica
print("→ Sono diverse perché 450 e 12 distorcono la media!\n")

# 2. Filtrare nel range fisiologico
pressione_pulita = pressione[(pressione >= 80) & (pressione <= 200)]
print(f"Dati rimossi: {len(pressione) - len(pressione_pulita)}")  # 2
print(f"Pressioni valide: {pressione_pulita}")

# 3. Standardizzazione
media = pressione_pulita.mean()
std = pressione_pulita.std()
pressione_std = (pressione_pulita - media) / std
print(f"\nPressioni standardizzate: {pressione_std.round(2)}")
print(f"Verifica media: {pressione_std.mean():.4f}")  # ~0.0000
print(f"Verifica std:   {pressione_std.std():.4f}")   # ~1.0000

# 4. Paziente con pressione più alta nel gruppo
idx_max = np.argmax(pressione_std)
print(f"\nPaziente {idx_max} ha la pressione più alta nel gruppo")
print(f"Z-score: {pressione_std[idx_max]:.2f} → {pressione_std[idx_max]:.1f} dev.std sopra la media")

import numpy as np

smartphone = np.array([
    [799,  8, 8.5],
    [1299, 12, 9.2],
    [749,  8, 7.8],
    [1199, 12, 8.9],
    [699,  6, 7.2],
    [1099, 12, 9.0],
])
nomi = ["iPhone SE", "iPhone 15 Pro", "Samsung A55",
        "Samsung S24", "Pixel 7a", "Pixel 8 Pro"]

# 1. Normalizzazione Min-Max (essenziale prima delle distanze!)
minimi = smartphone.min(axis=0)
massimi = smartphone.max(axis=0)
smart_norm = (smartphone - minimi) / (massimi - minimi)

# 2. Matrice distanze 6x6
n = len(smartphone)
distanze = np.zeros((n, n))
for i in range(n):
    for j in range(n):
        distanze[i, j] = np.linalg.norm(smart_norm[i] - smart_norm[j])

print("Matrice distanze (arrotondata):")
print(distanze.round(2))

# 3. Per ogni prodotto, trova il più simile
print("\n--- Prodotti simili ---")
for i in range(n):
    indici_ordinati = np.argsort(distanze[i])
    # indici_ordinati[0] = sé stesso (dist 0), indici_ordinati[1] = più vicino
    piu_simile = indici_ordinati[1]
    dist = distanze[i, piu_simile]
    print(f"{nomi[i]:15s} → più simile a: {nomi[piu_simile]:15s} (dist={dist:.2f})")

import numpy as np

dati_grezzi = np.array([
    [15000,    4,   3.2],
    [82000,    7,   5.1],
    [  np.nan, 3,   2.8],
    [210000,   2,   4.7],
    [9500000,  1,   0.3],
    [44000,    5,   np.nan],
    [67000,    6,   4.2],
    [31000,    3,   3.8],
])
nomi = np.array(["Alice", "Bob", "Carla", "Diego",
                  "Elena", "Fabio", "Giulia", "Hana"])

# FASE 1 — Rimuovi righe con NaN
# np.any(..., axis=1) → True se almeno un valore nella riga è NaN
mask_nan = ~np.any(np.isnan(dati_grezzi), axis=1)
dati = dati_grezzi[mask_nan]
nomi = nomi[mask_nan]
print(f"Fase 1 — Rimossi {np.sum(~mask_nan)} profili con dati mancanti")
print(f"Rimasti: {list(nomi)}\n")

# FASE 2 — Rimuovi outlier nei follower (colonna 0)
follower = dati[:, 0]
media_f = follower.mean()
std_f   = follower.std()
limite  = media_f + 2 * std_f
print(f"Fase 2 — Limite follower: {limite:,.0f}")
mask_out = follower <= limite
dati = dati[mask_out]
nomi = nomi[mask_out]
print(f"Rimossi outlier: {np.sum(~mask_out)}")
print(f"Rimasti: {list(nomi)}\n")

# FASE 3 — Normalizzazione Min-Max
minimi = dati.min(axis=0)
massimi = dati.max(axis=0)
dati_norm = (dati - minimi) / (massimi - minimi)
print("Fase 3 — Dati normalizzati:")
print(dati_norm.round(3))

# FASE 4 — Matrice distanze + creator simili
n = len(dati_norm)
distanze = np.zeros((n, n))
for i in range(n):
    for j in range(n):
        distanze[i, j] = np.linalg.norm(dati_norm[i] - dati_norm[j])

print("\nFase 4 — Creator più simili:")
for i in range(n):
    simile_idx = np.argsort(distanze[i])[1]
    print(f"  {nomi[i]:8s} → simile a {nomi[simile_idx]} (dist={distanze[i,simile_idx]:.2f})")

import numpy as np

sprite = np.array([
    [  0,   0, 200, 200,   0,   0],
    [  0, 200, 255, 255, 200,   0],
    [200, 255, 180, 180, 255, 200],
    [200, 255, 180, 180, 255, 200],
    [  0, 200, 255, 255, 200,   0],
    [  0,   0, 200, 200,   0,   0],
])

print("Sprite originale:")
print(sprite)

# EFFETTO 1 — Versione notturna
notturno = (sprite * 0.35).astype(int)
print("\nEffetto 1 — Notturno (35% luminosità):")
print(notturno)

# EFFETTO 2 — Versione fantasma
fantasma = np.clip(sprite, 80, 200)
print("\nEffetto 2 — Fantasma (clip 80-200):")
print(fantasma)

# EFFETTO 3 — Flip orizzontale
specchio = np.fliplr(sprite)
print("\nEffetto 3 — Specchio orizzontale:")
print(specchio)

# BONUS — Negativo fotografico
negativo = 255 - sprite
print("\nBonus — Negativo fotografico:")
print(negativo)

# Verifica del negativo:
# Il pixel in alto a sinistra era 0 (nero) → diventa 255 (bianco) ✓
print(f"\nVerifica: 0 → {255-0}, 255 → {255-255}, 200 → {255-200}")