Come illustrato nei capitoli precedenti, pag. da 1 a 6, la fase di elaborazione degli algoritmi è essenzialmente basata su principi matematici e algebrici. Durante questa fase, gli algoritmi trasformano i dati in ingresso seguendo precise istruzioni. Questa fase è fondamentale, poiché determina non solo il modo in cui i dati vengono manipolati per produrre l'output desiderato, ma anche l'efficienza e l'accuratezza dell'intero processo. - 2(Operazioni modulo (o resto):
- 4. Elaborazione delle Immagini (Esempio di Rilevamento Contorni per Riconoscimento Facciale Semplificato). L'operazione modulo può essere usata, in modo semplificato, per analizzare le informazioni di un'immagine, come ad esempio per individuare i contorni di un volto.
larghezza_immagine = 100
altezza_immagine = 80
soglia_differenza = 10
# Simula l'immagine
immagine = [
[100, 102, 101, 103, 105],
[105, 120, 122, 108, 106],
[103, 121, 123, 109, 107],
[101, 104, 106, 102, 104]
]
# Rilevamento contorni
for y in range(len(immagine)):
for x in range(len(immagine[0])):
if x + 1 < len(immagine[0]):
differenza_x = abs(immagine[y][x] - immagine[y][x+1])
if differenza_x > soglia_differenza:
print(f"Contorno orizzontale rilevato a ({x}, {y})")
if y + 1 < len(immagine):
differenza_y = abs(immagine[y][x] - immagine[y+1][x])
if differenza_y > soglia_differenza:
print(f"Contorno verticale rilevato a ({x}, {y})")
Descrizione: Questo esempio illustra un'applicazione semplificata per il rilevamento dei contorni, un passo fondamentale in molte tecniche di riconoscimento facciale. L'idea chiave è che i contorni in un'immagine sono caratterizzati da cambiamenti bruschi di intensità di colore tra pixel adiacenti. L'array 'immagine' rappresenta una versione molto semplificata di un'immagine in scala di grigi, dove ogni numero è l'intensità di un pixel. Il codice scorre attraverso i pixel e calcola la differenza di intensità tra un pixel e i suoi vicini (a destra e sotto). Se la differenza supera una certa 'soglia_differenza', si considera che ci sia un contorno. Questo metodo è una semplificazione, ma illustra il principio base. In un sistema reale di riconoscimento facciale, si userebbero tecniche più avanzate, come l'applicazione di filtri (ad esempio, il filtro di Sobel) che calcolano i gradienti di intensità. Nel contesto del riconoscimento facciale, il rilevamento dei contorni è un passo preliminare per identificare le caratteristiche chiave di un volto, come gli occhi, il naso e la bocca. Questi contorni, una volta rilevati, possono essere utilizzati per localizzare e confrontare volti. Questo esempio non esegue il riconoscimento facciale vero e proprio, ma dimostra come l'analisi delle differenze di intensità (e quindi dei contorni) sia un passaggio cruciale. Questo esempio è estremamente semplificato e non è un sistema di riconoscimento facciale funzionante, mostrando solamente un singolo passo nel processo. I sistemi reali utilizzano algoritmi molto più complessi, spesso basati su reti neurali convoluzionali (CNN) per l'estrazione delle caratteristiche e il confronto dei volti. Vedi sezione dedicata alle CNN su questo portale.
-------------------------------
5. Controllo di Parità (Integrità dei Dati Trasmessi). Il controllo di parità è un metodo fondamentale per garantire l'integrità dei dati trasmessi attraverso reti.
def calcola_parita(bit_string):
# Conta il numero di bit '1' nella stringa
numero_di_uno = bit_string.count('1')
# Calcola la parità: 0 per pari, 1 per dispari
return numero_di_uno % 2
# Esempio di utilizzo
dati_trasmessi = "1101001" # Una stringa di bit
parita = calcola_parita(dati_trasmessi)
if parita == 0:
print(f"{dati_trasmessi} hanno una parità pari.")
else:
print(f"{dati_trasmessi} hanno una parità dispari.")
Descrizione: In questo esempio, la funzione (calcola_parita) analizza una stringa di bit (una sequenza di 0 e 1) e conta quante volte appare il bit '1'. Utilizzando l'operazione (modulo), determina se questo conteggio è pari o dispari. Se il numero di '1' è pari, i dati sono considerati integri; se dispari, potrebbe esserci stato un errore di trasmissione. Questo metodo è ampiamente utilizzato nelle comunicazioni digitali, come nel protocollo di rete TCP/IP, dove la parità aiuta a garantire che i dati arrivino correttamente senza corruzione. Il controllo di parità è un metodo fondamentale per garantire l'integrità dei dati trasmessi attraverso reti.
-------------------------------
6. Data Science e Machine Learning (Elaborazione dei Dati in Batch). Nei progetti di machine learning, l'elaborazione in batch permette di ridurre il carico di memoria e migliorare l'efficienza.
import numpy as np
# Dati di esempio
dati = np.arange(100) # Un array di 100 numeri, da 0 a 99
# Dimensione del batch
batch_size = 15
# Elaborazione dei dati in batch
for i in range(len(dati)):
if i % batch_size == 0:
print(f"Inizio del batch {i // batch_size}: {dati[i:i + batch_size]}")
Descrizione: Nella data science, l'operazione modulo è spesso utilizzata per gestire l'elaborazione dei dati in batch. Questo approccio è fondamentale nei progetti di machine learning, dove i dati vengono suddivisi in piccoli gruppi (batch) per facilitare l'addestramento di modelli. Elaborare i dati in batch consente di ridurre il carico di memoria e migliorare l'efficienza. Questo esempio illustra come suddividere un array di dati in batch per l'elaborazione. Utilizzando i % batch_size, il codice determina quando iniziare un nuovo batch. Ad esempio, se batch_size è 15, il programma stamperà i numeri da 0 a 14 come primo batch, da 15 a 29 come secondo, e così via. Questo approccio è utile quando si addestrano modelli di machine learning, poiché i modelli funzionano meglio su piccoli set di dati piuttosto che su enormi quantità di dati contemporaneamente. Inoltre, l'elaborazione in batch consente di aggiornare il modello più frequentemente, migliorando la convergenza durante l'addestramento. In conclusione, L'elaborazione in batch è fondamentale nei progetti di machine learning, in quanto consente di ridurre il carico di memoria e migliorare l'efficienza dell'addestramento dei modelli. Invece di caricare l'intero set di dati in memoria, i dati vengono suddivisi in piccoli batch, che vengono elaborati sequenzialmente. Questo approccio è più adatto a gestire grandi quantità di dati.
Vengono definiti "batch" gruppi o porzioni di dati. Immaginate di avere una grande quantità di dati, come migliaia o milioni di informazioni. Se si provasse a elaborare tutti questi dati insieme, potrebbe essere troppo pesante per i processori, che potrebbero rallentare o addirittura bloccarsi (a meno che che non siano dati in pasto all'ultimo super processore quantico da poco pubblicato, ma per ora è ancora in fase di sperimentazione!). dividendo questi milioni di informazioni in piccoli gruppi (batch) ed elaborandoli batch dopo batch, i processori non devono gestire tutti i dati contemporaneamente, ma solo una piccola parte alla volta. Questo rende l'elaborazione più veloce e efficiente. Nei progetti di machine learning, l'elaborazione in batch è molto importante perché consente di addestrare i modelli in modo graduale e costante, senza sovraccaricare la memoria del computer.
-------------------------------
7. Robotica e Automazione (Controllo della Rotazione dei Motori). In robotica, l'operazione modulo è utilizzata per controllare la rotazione dei motori, garantendo che le posizioni rimangano all'interno di un intervallo definito. Questo è particolarmente importante quando si lavora con motori che ruotano in cerchio, come nel caso di robot o veicoli autonomi.
# Funzione per calcolare la posizione del motore
def calcola_posizione_motore(posizione_attuale, rotazione):
# Calcola la nuova posizione usando l'operazione modulo
nuova_posizione = (posizione_attuale + rotazione) % 360
return nuova_posizione
# Esempio di utilizzo
posizione_iniziale = 350 # Posizione attuale del motore in gradi
rotazione = 30 # Rotazione richiesta
nuova_posizione = calcola_posizione_motore(posizione_iniziale, rotazione)
print(f"La nuova posizione del motore è: {nuova_posizione} gradi.")
Descrizione: Questo esempio mostra come calcolare la nuova posizione di un motore che ruota in gradi. La funzione calcola_posizione_motore utilizza l'operazione modulo per garantire che la posizione rimanga nell'intervallo da 0 a 359 gradi. Ad esempio, se la posizione iniziale è 350 gradi e il motore deve ruotare di 30 gradi, la nuova posizione sarà 20 gradi (350 + 30 = 380, e 380 % 360 = 20). Questo è cruciale in robotica per evitare errori di movimento, come il superamento della capacità del motore, che potrebbe portare a malfunzionamenti. (Immaginate la micro precisione dei robot articolati utilizzati per saldare lastre metalliche nei cantieri navali, oppure dei robot industriali nella catena di montaggio delle automobili, che sollevano e posizionano sportelli, motori e parabrezza. Senza l'algoritmo che elabora queste operazioni, tali tecnologie non potrebbero esistere!). Utilizzando l'operazione modulo, i progettisti possono garantire che i motori funzionino in modo efficiente e preciso, mantenendo il controllo su tutte le rotazioni.
-------------------------------
Operazioni eseguite a livello di singoli bit (0 e 1). Esempi includono AND, OR, XOR, NOT, shift a sinistra e shift a destra. Cruciali in programmazione a basso livello, crittografia e manipolazione di dati binari. Nello specifico Le operazioni bitwise manipolano direttamente i bit di un dato numerico. Ecco un riassunto: AND (&):Restituisce 1 se entrambi i bit sono 1, altrimenti 0. Utile per mascherare bit.
OR (|):Restituisce 1 se almeno uno dei bit è 1, altrimenti 0. Utile per impostare bit.
XOR (^):Restituisce 1 se i bit sono diversi, altrimenti 0. Utile per invertire bit o nella crittografia.
NOT (~):Inverte i bit (0 diventa 1, 1 diventa 0). Utile per creare maschere di bit.
Shift a sinistra (<<):Sposta i bit verso sinistra di un certo numero di posizioni. Equivale a moltiplicare per una potenza di 2.
Shift a destra (>>):Sposta i bit verso destra di un certo numero di posizioni. Equivale a dividere per una potenza di 2 (arrotondando verso 0 per numeri senza segno, verso meno infinito per numeri con segno). In conclusione Le operazioni bitwise sono fondamentali per la programmazione a basso livello, permettendo il controllo diretto dell'hardware e la gestione dei registri. Trovano impiego cruciale nella crittografia, abilitando l'implementazione efficiente di algoritmi di cifratura. Inoltre, consentono la manipolazione precisa di dati binari, permettendo l'impostazione, il clearing e il test di singoli bit. In alcuni casi, le operazioni bitwise possono persino risultare più veloci delle operazioni aritmetiche, offrendo vantaggi in termini di ottimizzazione del codice. È importante considerare che le specifiche di implementazione, come il comportamento dell'operatore di shift a destra (>>) su numeri negativi, possono variare a seconda del linguaggio di programmazione e dell'architettura del computer sottostante. Queste operazioni sono quindi essenziali per algoritmi che richiedono un controllo fine a livello di bit.
1. Operatore AND (&). - L'operatore AND bitwise restituisce 1 se entrambi i bit sono 1; altrimenti, restituisce 0. È utile per mascherare bit specifici in un numero.
# Numero in binario
numero = 0b11010110 # 214 in decimale
# Maschera per i 4 bit meno significativi
maschera = 0b00001111 # 15 in decimale
# Applica l'operatore AND
risultato = numero & maschera
print(f"Risultato AND: {bin(risultato)}") # Stampa il risultato in formato binario
Descrizione: Questo esempio illustra come l'operatore AND bitwise può essere utilizzato per manipolare i bit di un numero. Gli operatori bitwise operano sui singoli bit di un numero, che in informatica è rappresentato in formato binario. Ad esempio, il numero 6 in binario è rappresentato come '110'. L'operatore AND bitwise (&) confronta i bit di due numeri e restituisce un nuovo numero. Se entrambi i bit sono 1, il risultato è 1; se uno dei due bit è 0, il risultato è 0.
In questo esempio, la maschera '00001111' ha i 4 bit meno significativi impostati a 1, il che significa che vogliamo mantenere solo questi bit e ignorare gli altri. L'operatore AND bitwise e le maschere sono utilizzati in vari contesti, tra cui programmazione di sistemi, compressione dei dati, sicurezza in crittografia e grafica computazionale. Comprendere come funziona l'operatore AND e come utilizzare le maschere è fondamentale per manipolare i bit di un numero in modo efficace.
-------------------------------
--> PAG. 10, continua la Sezione "Elaborazione" Operazioni bitwise.
(Autore: Mr. Renato Schirripa - Marzo 2025)
