Molte persone che si avvicinano al machine learning non hanno un forte background in ingegneria del software, e quando devono lavorare su un prodotto reale, il loro codice può risultare disordinato e difficile da gestire. Per questo motivo, raccomando sempre vivamente di imparare a usare le coding best practices, che ti permetteranno di lavorare senza problemi all’interno di un team e di migliorare il livello del progetto su cui stai lavorando. Oggi voglio parlare dell’inheritance di Python e mostrare alcuni semplici esempi di come utilizzarla nel campo del machine learning.

Nello sviluppo software e in altri ambiti dell’informatica, il technical debt (noto anche come design debt o code debt) rappresenta il costo implicito di future rielaborazioni dovuto a una soluzione che privilegia la rapidità rispetto a un design a lungo termine.

Se sei interessato a saperne di più sui design patterns, potresti trovare utili alcuni dei miei articoli precedenti.

Python Inheritance

L’Inheritance non è solo un concetto di Python, ma un concetto generale nell’Object Oriented Programming. Quindi, in questo tutorial, dovremo lavorare con classei e oggetti, che rappresentano un paradigma di sviluppo non molto utilizzato in Python rispetto ad altri linguaggi come Java.

Nell’OOP, possiamo definire una classe generale che rappresenta qualcosa nel mondo, ad esempio una Persona, che definiamo semplicemente con un nome, un cognome e un’età nel seguente modo.

class Person:
def __init__(self, name, surname, age):
self.name = name
self.surname = surname
self.age = age

def __str__(self):
return f"Name: {self.name}, surname: {self.surname}, age: {self.age}"

def grow(self):
self.age +=1

In questa classe, abbiamo definito un semplice costruttore (init). Poi abbiamo definito il method str, che si occuperà di stampare l’oggetto nel modo che desideriamo. Infine, abbiamo il method grow() per rendere la persona di un anno più vecchia.

Ora possiamo instanziare un oggetto e utilizzare questa classe.

person = Person("Marcello", "Politi", 28)
person.grow()
print(person)

# output wiil be
# Name: Marcello, surname: Politi, age: 29

E se volessimo definire un particolare tipo di persona, ad esempio un operaio? Possiamo fare la stessa cosa di prima, ma aggiungiamo un’altra variabile di input per aggiungere il suo stipendio.

class Worker:
def __init__(self, name, surname, age, salary):
self.name = name
self.surname = surname
self.age = age
self.salary = salary

def __str__(self):
return f"Name: {self.name}, surname: {self.surname}, age: {self.age}, salary: {self.salary}"

def grow(self):
self.age +=1

Tutto qui. Ma è questo il modo migliore per implementarlo? Vedete che la maggior parte del codice del lavoratore è uguale a quello della persona, perché un lavoratore è una persona particolare e condivide molte cose in comune con una persona.

Quello che possiamo fare è dire a Python che il lavoratore deve ereditare tutto da Persona, e poi aggiungere manualmente tutte le cose di cui abbiamo bisogno, che una persona generica non ha.

class Worker(Person):
def __init__(self, name, surname, age, salary):
super().__init__(name, surname, age)
self.salary = salary

def __str__(self):
text = super().__str__()
return text + f",salary: {self.salary}"

Nella classe worker, il costruttore richiama il costruttore della classe person sfruttando la parola chiave super() e poi aggiunge anche la variabile salary.

La stessa cosa avviene quando si definisce il metodo str. Utilizziamo lo stesso testo restituito da Person usando la parola chiave super e aggiungiamo il salario quando stampiamo l’oggetto.

Ereditarietà nel Machine Learning

Non ci sono regole su quando usare l’ereditarietà nell’machine learning . Non so a quale progetto stiate lavorando, né come sia il vostro codice. Voglio solo sottolineare il fatto che dovreste adottare un paradigma OOP nel vostro codice. Tuttavia, vediamo alcuni esempi di utilizzo dell’ereditarietà.

Definire un BaseModel

Sviluppiamo una classe di base per il modello di ML, definita da alcune variabili standard. Questa classe avrà un metodo per caricare i dati, uno per addestrare, un altro per valutare e uno per preelaborare i dati. Tuttavia, ogni modello specifico preelaborerà i dati in modo diverso, quindi le sottoclassi che erediteranno il modello di base dovranno riscrivere il metodo di preelaborazione.
Attenzione, il modello BaseMLModel stesso eredita la classe ABC. Questo è un modo per dire a Python che questa classe è una classe astratta e non deve essere usata, ma è solo un modello per costruire sottoclassi.

Lo stesso vale per il metodo preprocess_train_data, che è contrassegnato come @abstactmethod. Ciò significa che le sottoclassi devono reimplementare questo metodo.

Guardate questo video per saperne di più su classi e metodi astratti:

youtube.com/embed/UDmJGvM-OUw?…

from abc import ABC, abstractmethod
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
import numpy as np

class BaseMLModel(ABC):
def __init__(self, test_size=0.2, random_state=42):
self.model = None # This will be set in subclasses
self.test_size = test_size
self.random_state = random_state
self.X_train = None
self.X_test = None
self.y_train = None
self.y_test = None

def load_data(self, X, y):
self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(
X, y, test_size=self.test_size, random_state=self.random_state
)

@abstractmethod
def preprocess_train_data(self):
"""Each model can define custom preprocessing for training data."""
pass

def train(self):
self.X_train, self.y_train = self.preprocess_train_data()
self.model.fit(self.X_train, self.y_train)

def evaluate(self):
predictions = self.model.predict(self.X_test)
return accuracy_score(self.y_test, predictions)

Vediamo ora come ereditare da questa classe. Per prima cosa, possiamo implementare un LogisticRegressionModel. Che avrà il suo algoritmo di preelaborazione.

class LogisticRegressionModel(BaseMLModel):
def __init__(self, **kwargs):
super().__init__()
self.model = LogisticRegression(**kwargs)

def preprocess_train_data(self):
#Standardize features for Logistic Regression
mean = self.X_train.mean(axis=0)
std = self.X_train.std(axis=0)
X_train_scaled = (self.X_train - mean) / std
return X_train_scaled, self.y_train

Poi possiamo definire tutte le sottoclassi che vogliamo. Qui ne definisco una per una Random Forest.

class RandomForestModel(BaseMLModel):
def __init__(self, n_important_features=2, **kwargs):
super().__init__()
self.model = RandomForestClassifier(**kwargs)
self.n_important_features = n_important_features

def preprocess_train_data(self):
#Select top `n_important_features` features based on variance
feature_variances = np.var(self.X_train, axis=0)
top_features_indices = np.argsort(feature_variances)[-self.n_important_features:]
X_train_selected = self.X_train[:, top_features_indices]
return X_train_selected, self.y_train

Ora usiamo tutto nella funzione main.

if __name__ == "__main__":
# Load dataset
data = load_iris()
X, y = data.data, data.target

# Logistic Regression
log_reg_model = LogisticRegressionModel(max_iter=200)
log_reg_model.load_data(X, y)
log_reg_model.train()
print(f"Logistic Regression Accuracy: {log_reg_model.evaluate()}")

# Random Forest
rf_model = RandomForestModel(n_estimators=100, n_important_features=3)
rf_model.load_data(X, y)
rf_model.train()
print(f"Random Forest Accuracy: {rf_model.evaluate()}")

Conclusioni

Uno dei principali vantaggi dell’ereditarietà di Python nei progetti ML è nella progettazione di codici modulari, mantenibili e scalabili. L’ereditarietà aiuta a evitare codice ridondante, scrivendo la logica comune in una classe base, come BaseMLModel, riducendo quindi la duplicazione del codice. L’inheritance rende anche facile incapsulare comportamenti comuni in una classe base, permettendo alle subclasses di definire dettagli specifici.

Il principale vantaggio, a mio avviso, è che una codebase ben organizzata e orientata agli oggetti consente a più sviluppatori all’interno di un team di lavorare indipendentemente su parti separate. Nel nostro esempio, un ingegnere capo potrebbe definire il modello base, e poi ogni sviluppatore potrebbe concentrarsi su un singolo algoritmo e scrivere la subclass.
Prima di immergerti in design patterns complessi, concentrati sull’utilizzo delle best practices nell’OOP. Farlo ti renderà un programmatore migliore rispetto a molti altri nel campo dell’AI!

L'articolo Inheritance in Python: la chiave per scrivere codice pulito e collaborativo nel Machine Learning proviene da il blog della sicurezza informatica.

Apple ha rilasciato patch di emergenza per correggere due vulnerabilità zero-day. Secondo l’azienda, questi problemi sono stati sfruttati in attacchi mirati ed “estremamente sofisticati” contro i possessori di iPhone.

Le vulnerabilità sono state scoperte in CoreAudio (CVE-2025-31200 , punteggio CVSS 7,5) e RPAC ( CVE-2025-31201, punteggio CVSS 6,8) i quali interessano iOS, macOS, tvOS, iPadOS e visionOS.

“Apple è consapevole che queste problematiche potrebbero essere sfruttate per attacchi altamente sofisticati contro singoli utenti iOS”, ha affermato Apple in un bollettino sulla sicurezza.

La vulnerabilità CVE-2025-31200 in CoreAudio è stata scoperta dai ricercatori Apple e da quelli di Google Threat Analysis. Questo bug può essere sfruttato per eseguire da remoto del codice su un dispositivo elaborando un flusso audio in un file multimediale dannoso e appositamente preparato.

La vulnerabilità CVE-2025-31201 è stata scoperta dagli stessi specialisti Apple. Questo bug in RPAC consente agli aggressori con accesso in lettura/scrittura di aggirare Pointer Authentication (PAC), una funzionalità di sicurezza iOS progettata per proteggere dalle vulnerabilità della memoria.

Finora, Apple non ha divulgato dettagli su come queste vulnerabilità siano state sfruttate negli attacchi o su chi ne siano stati i bersagli. I problemi sono stati risolti in iOS 18.4.1, iPadOS 18.4.1, tvOS 18.4.1, macOS Sequoia 15.4.1 e visionOS 2.4.1 .

Le vulnerabilità interessano sia i modelli più vecchi che quelli più nuovi dei dispositivi Apple:

• iPhone XS e modelli successivi;
• iPad Pro da 13 pollici, iPad Pro da 12,9 pollici (3a generazione e successive), iPad Pro da 11 pollici (1a generazione e successive), iPad Air di 3a generazione e successive, iPad di 7a generazione e successive e iPad mini di 5a generazione e successive;
• macOS Sequoia;
• Apple TV HD e Apple TV 4K (tutti i modelli);
• Apple Vision Pro.

L'articolo Zero-day su iPhone, Mac e iPad: Apple corre ai ripari con patch d’emergenza proviene da il blog della sicurezza informatica.

Microsoft avverte gli utenti che potrebbero riscontrare una schermata blu di errore e un errore SECURE_KERNEL_ERROR dopo l’installazione degli aggiornamenti di Windows di marzo e aprile. I problemi si verificano dopo l’installazione dell’aggiornamento cumulativo di aprile KB5055523 e dell’aggiornamento di anteprima di marzo KB5053656 che ha interessano solo i dispositivi che eseguono Windows 11 24H2. Dopo aver installato questi aggiornamenti e riavviato il PC, gli utenti interessati riscontrano un arresto anomalo.

“Dopo aver installato l’aggiornamento e riavviato il dispositivo, potresti visualizzare una schermata blu con codice di errore 0x18B, che indica SECURE_KERNEL_ERROR”, afferma Microsoft.

Finché non verrà distribuita una correzione per questo bug tramite Windows Update, l’azienda ha temporaneamente affrontato il problema tramite Known Issue Rollback (KIR), una funzionalità che ripristina gli aggiornamenti problematici distribuiti tramite Windows Update.

Questa correzione verrà automaticamente distribuita a tutti i dispositivi domestici, aziendali e non gestiti dall’IT entro 24 ore. Per velocizzare la distribuzione, Microsoft consiglia agli utenti interessati di riavviare i propri dispositivi.

Per risolvere il problema sui dispositivi Windows aziendali gestiti, gli amministratori di Windows 11 24H2 e Windows Server 2025 devono applicare il Criterio di gruppo KIR KB5053656 250412_03103 .

Vale anche la pena notare che all’inizio di questa settimana Microsoft ha rilasciato aggiornamenti di emergenza per Windows che risolvono un problema diverso che riguarda i criteri di controllo dell’accesso locale nei Criteri di gruppo di Active Directory.

Inoltre, l’azienda ha avvisato gli amministratori di un bug che potrebbe causare la mancata disponibilità dei controller di dominio in Windows Server 2025 dopo un riavvio, con conseguenti errori di servizi e applicazioni.

L'articolo Aggiorna e muori: Windows 11 mostra la schermata Blu Della Morte (BSOD) dopo gli update di Aprile proviene da il blog della sicurezza informatica.

[Charmed Labs] are responsible for bringing numerous open-source hardware products to fruition over the years, and their latest device is an adorably small robotic camera platform called Goby, currently crowdfunding for its initial release. Goby has a few really clever design features and delivers a capable (and hackable) platform for under 100 USD.

Goby embraces its small size, delivering what its creators dub “tinypresence” — or the feeling of being there, but on a very small scale. Cardboard courses, LEGO arenas, or even tabletop gaming scenery hits different when experienced from a first-person perspective. Goby is entirely reprogrammable with nothing more than a USB cable and the Arduino IDE, while costing less than most Arduino starter kits.
Recharging happens by driving over the charger, then pivoting down so the connectors (the little blunt vampire fangs under and to each side of the camera) come into contact with the charger.
One of the physical features we really like is the tail-like articulated caster at the rear. Flexing this pivots Goby up or down (and can even flip Goby completely over), allowing one to pan and tilt the view without needing to mount the camera on a gimbal. It also comes into play for recharging; Goby simply moves over the disc-shaped charger and pivots down to make contact.

At Goby‘s heart is an ESP32-S3 and OmniVision OV2640 camera sensor streaming a live video feed (and driving controls) with WebRTC. Fitting the WebRTC stack onto an ESP32 wasn’t easy, but opens up possibilities beyond just media streaming.

Goby is set up to make launching an encrypted connection as easy as sharing a URL or scanning a QR code. The link is negotiated between bot and client with the initial help of an external server, and once a peer-to-peer connection is established, the server’s job is done and it is out of the picture. [Charmed Labs]’s code for this functionality — named BitBang — is in beta and destined for an open release as well. While BitBang is being used here to make it effortless to access Goby remotely, it’s more broadly intended to make web access for any ESP32-based device easier to implement.

As far as tiny remote camera platforms go, it might not be as small as rebuilding a Hot Wheels car into a micro RC platform, but it’s definitely more accessible and probably cheaper, to boot. Check it out at the Kickstarter (see the first link in this post) and watch it in action in the video, embedded just below the page break.

youtube.com/embed/iuJ_9_ITKFs?…

hackaday.com/2025/04/17/tiny-h…

Running a dairy farm used to be a rather hands-on experience, with the farmer required to be around every few hours to milk the cows, feed them, do all the veterinarian tasks that the farmer can do themselves, and so on. The introduction of milking machines in the early 20th century however began a trend of increased automation whereby a single farmer could handle a hundred cows by the end of the century instead of only a couple. In a recent article in IEEE Spectrum covers the continued progress here is covered, including cows milking themselves, on-demand style as shown in the top image.

The article focuses primarily on Dutch company Lely’s recent robots, which range from said self-milking robots to a manure cleaning robot that looks like an oversized Roomba. With how labor-intensive (and low-margin) a dairy farm is, any level of automation that can improve matters will be welcomed, with so far Lely’s robots receiving a mostly positive response. Since cows are pretty smart, they will happily guide themselves to a self-milking robot when they feel that their udders are full enough, which can save the farmer a few hours of work each day, as this robot handles every task, including the cleaning of the udders prior to milking and sanitizing itself prior to inviting the next cow into its loving embrace.

As for the other tasks, speaking as a genuine Dutch dairy farm girl who was born & raised around cattle (and sheep), the idea of e.g. mucking out stables being taken over by robots is something that raises a lot more skepticism. After all, a farmer’s children have to earn their pocket money somehow, which includes mucking, herding, farm maintenance and so on. Unless those robots get really cheap and low maintenance, the idea of fully automated dairy farms may still be a long while off, but reducing the workload and making cows happier are definitely lofty goals.

Top image: The milking robot that can automatically milk a cow without human assistance. (Credit: Lely)

hackaday.com/2025/04/17/rise-o…

pixelfed.social/p/Fotos.photos…

Diego Herculano

2025-04-17 12:55:16

China

@photography@lemmy.ml
#photography #photo #streetphotography #fotografia #China #360Degrees #35mm #art #travel #press #news #photooftheday #mastodon #PortfolioDay #pixelfed #photojournalism #photodocumentary #beach

Ed ecco a voi Sinistra per Israele (come già noto prezzolata da Netanyahu)

Cronaca. Ieri in un dibattito in Senato si è riunita la cosiddetta “Sinistra per Israele” con Ivan Scalfarotto (Iv), Lucio Malan e Piero Fassino, Sensi e Delrio, Alfredo Bazoli e Walter Verini, Lia Quartapelle e Marianna Madia, Enza Rando e Antonio Nicita, Simona Malpezzi e Sandra Zampa; Marco Carrai, da sempre vicino a Matteo Renzi, e console onorario di Israele e Raffaella Paita, Luciano Nobili, Silvia Fregolent di IV.
L’iniziativa voleva contrastare la mozione contro Israele di Conte del giorno prima che ha visto anche la partecipazione della Shlein.
Fassino, oltre a ricordare ai presenti con orgoglio che viene definito “il sionista di sinistra”, ha ricordato anche “che va bene dire due popoli due Stati, ma che la soluzione ad ora non è praticabile”, dicendo inoltre che molte delle strutture operative di Hamas sono costruite vicino a luoghi come gli ospedali, e dunque risultano “fatali” le vittime civili. Fatali, ha usato questo termine per giustificare le conseguenze genocidiarie delle bombe israeliane. Per la cronaca - leggo da un articolo di oggi sul FQ- “una donna dal pubblico è pure intervenuta per rivendicare il fatto che l’esercito israeliano “avverte sempre dei suoi obiettivi”. Fassino l’ha rassicurata sulle sue posizioni, la sala ha applaudito”.
Cosa dire? Niente di più, se non che nella sala non aleggiava profumo di Chanel, ma di carne umana bruciata.

(Cosimo Minervini)