Come funziona ComoLake di Micromegas e Fondazione Ets?
L'articolo proviene da #StartMag e viene ricondiviso sulla comunità Lemmy @Informatica (Italy e non Italy 😁)
I quotidiani Fatto e Domani - che pizzicarono Barberio - oggi pizzicano all’unisono Butti post Barberio: ecco come sarà organizzata (e startmag.it/innovazione/come-f…
Informatica (Italy e non Italy 😁) reshared this.
reshared this
SIRIA. La vendetta dei jihadisti contro le donne alawite: rapite e uccise
@Notizie dall'Italia e dal mondo
"Ci torturavano", racconta Rabab, una rapita scampata alla morte. «Uno parlava con un accento straniero, l’altro con uno di Idlib. Ci odiavano perché eravamo alawite". Il regime di Ahmad Sharaa non interviene
L'articolo SIRIA. La vendetta dei jihadisti contro
Notizie dall'Italia e dal mondo reshared this.
D20-shaped Quasicrystal Makes High-Strength Alloy Printable
When is a crystal not a crystal? When it’s a quasi-crystal, a paradoxical form of metal recently found in some 3D printed metal alloys by [A.D. Iams et al] at the American National Institute for Standards and Technology (NIST).
As you might remember from chemistry class, crystals are made up of blocks of atoms (usually called ‘unit cells’) that fit together in perfect repetition — baring dislocations, cracks, impurities, or anything else that might throw off a theoretically perfect crystal structure. There are only so many ways to tessellate atoms in 3D space; 230 of them, to be precise. A quasicrystal isn’t any of them. Rather than repeat endlessly in 3D space, a quasicrystal never repeats perfectly, like a 3D dimensional Penrose tile. The discovery of quasicrystals dates back to the 1980s, and was awarded a noble prize in 2011.
Quasicrystals aren’t exactly common in nature, so how does 3D printing come into this? Well, it turns out that, quite accidentally, a particular Aluminum-Zirconium alloy was forming small zones of quasicrystals (the black spots in the image above) when used in powder bed fusion printing. Other high strength-alloys tended to be very prone to cracking, to the point of usability, and this Al-Zr alloy, discovered in 2017, was the first of its class.
You might imagine that the non-regular structure of a quasicrystal wouldn’t propagate cracks as easily as a regular crystal structure, and you would be right! The NIST researchers obviously wanted to investigate why the printable alloy had the properties it does. When their crystallographic analysis showed not only five-fold, but also three-fold and two-fold rotational symmetry when examined from different angles, the researchers realized they had a quasicrystal on their hands. The unit cell is in the form of a 20-sided icosahedron, providing the penrose-style tiling that keeps the alloy from cracking.
You might say the original team that developed the alloy rolled a nat-20 on their crafting skill. Now that we understand why it works, this research opens up the doors for other metallic quasi-crystals to be developed on purpose, in aluminum and perhaps other alloys.
We’ve written about 3D metal printers before, and highlighted a DIY-able plastic SLS kit, but the high-power powder-bed systems needed for aluminum aren’t often found in makerspaces. If you’re building one or know someone who is, be sure to let us know.
Cyber gang ransomware: a guidare la minaccia sono fattori economici e geopolitici
@Informatica (Italy e non Italy 😁)
La nuova indagine di Twin4Cyber e della divisione cyber security di Maticmind fotografa gli attacchi delle cyber gang ransomware, dove il cyber risk è una variabile critica di sicurezza nazionale e competitività economica. Ecco come affrontare una
Informatica (Italy e non Italy 😁) reshared this.
Meta, la fuga di dati, i licenziamenti e le cattive abitudini cyber: quale lezione
@Informatica (Italy e non Italy 😁)
A fine febbraio Meta ha annunciato di avere licenziato una ventina di dipendenti rei di avere divulgato informazioni riservate. C’è da chiedersi quanto Meta possa assolversi davanti a questo tipo di leak
L'articolo Meta, la fuga di dati, i
Informatica (Italy e non Italy 😁) reshared this.
Implementare processi di security: prassi e standard per adeguarsi a DORA
@Informatica (Italy e non Italy 😁)
Il DORA impone nuove sfide, ma anche grandi opportunità per rafforzare la resilienza digitale nel settore finanziario. L’adozione integrata di framework internazionali come ISO/IEC 27001, COBIT e NIST CSF rappresenta un supporto concreto all’implementazione
Informatica (Italy e non Italy 😁) reshared this.
Da capro espiatorio, alla fratellanza, al ghetto: la storia dei palestinesi in Libano
@Notizie dall'Italia e dal mondo
Negli anni successivi alla guerra civile, i palestinesi sono stati dipinti, nei discorsi politici e mediatici, come i principali colpevoli del conflitto. Mentre questa ostilità è salita a livelli senza precedenti, le sue origini sono
Notizie dall'Italia e dal mondo reshared this.
freezonemagazine.com/articoli/…
Alla Società storica dell’Oklahoma: mi chiamo Grady McClarty. Ho settant’anni e sono direttore generale in pensione della Wolfcamp Chevrolet di Midland, in Texas, dove ho passato la maggior parte della mia vita. Scrivo in risposta alla richiesta, ricevuta da una delle vostre archiviste, Marguerite Talkingthunder, di registrare un mio racconto orale sulla “grande fuga del
Gli hacker colpiscono Hertz, cosa sappiamo sul furto dei dati dei clienti (dalle patenti alle carte di credito)
@Informatica (Italy e non Italy 😁)
Maxi attacco hacker a uno dei player del comparto dell'autonoleggio, già in difficoltà per aver scommesso - sbagliando - sull'auto elettrica. Finiti nelle mani dei pirati informatici dati
Informatica (Italy e non Italy 😁) reshared this.
Era un po' di tempo che non usavo sistemi Linux su Desktop, ma oggi dopo qualche tentativo con Fedora mi sono installato invece Open Suse Tumbleweed con Gnome. Ha riconosciuto l'hardware e semplificato l'installazione più di quanto sia riuscita a fare Fedora.
In passato ho usato sia queste distribuzioni che altre Debian-based, tra cui Ubuntu, che ora però vuole abbandonare il progetto GNU, e questa cosa secondo me non è bellissima, se non altro perché ci costringe a reimparare molte cose un'altra volta.
Tralasciando questi particolari, mi stupisco che Linux non venga adottato più spesso, soprattutto dagli utenti domestici: l'interfaccia con GNOME è leggerissima, semplice, installare software è letteralmente un gioco da ragazzi.
Credo che nel nostro continente dovremmo usarlo di più, e forse le circostanze attuali con gli Stati Uniti in qualche modo potrebbero anche spingere le cose in questa direzione. Chissà?
Io lo tengo installato - che non si sa mai - e lo userò di tanto in tanto, magari per le dirette su Youtube e per mostrare che si può tranquillamente lavorare anche con Linux.
C'è molto di quello che mi serve, ma purtroppo non tutto: alcuni software che uso per video e foto, e che girano solo su Windows / Macintosh, sono ancora imprescindibili.
Ma io sono un caso davvero particolare.
Avete quel vecchio PC in soffitta o in cantina che non sapete come utilizzare? Date una chance a Linux, magari vi stupirà!
#linux #suse #softwarelibero #ubuntu #debian #oldware #lealternative
Il Tridente likes this.
CDN friendica reshared this.
Simon Perry likes this.
@Il Tridente tutti tendiamo a "snobbarla" un po' per gli utilizzo standard, perché...beh, tanto c'è Ubuntu che fa tutto in maniera più semplice (così si pensa, almeno).
Ma funziona benissimo!
ma chi cazzo si crede? il padre eterno?
Track Your Circuits: A Locomotive PCB Badge
This fun PCB from [Nick Brown] features a miniature railroad implemented with 0805-sized LEDs. With an eye towards designing his own fun interactive PCB badge, the Light-Rail began its journey. He thoroughly documented his process, from shunting various late-night ideas together to tracking down discrepancies between the documentation of a part and the received part.
The challenges didn’t stop at just the organic layout of all those LEDs. He decided to use Rust for this project, which entailed writing his own driver for the seven-segment displays as well as creating a tone library for the onboard buzzer. As with all projects, unexpected challenges popped up along the way. One issue with how the oscillator was hooked up meant he wasn’t able to use the ATmega32U4, which was the brains of the entire railroad. After some experimenting, he came up with a clever hack: using a pogo pin jig to connect the clock where it needed to go while programming the board.
Be sure to check out all the details of this journey in his build log. If you love interactive badges also check out some of the other creative boards we’ve featured.
Direttiva NIS 2 per la sicurezza delle infrastrutture critiche: quando e a chi si applica, le sanzioni
@Informatica (Italy e non Italy 😁)
La Direttiva NIS 2 nasce da una profonda revisione della NIS e segna un altro importante passo verso la piena definizione della strategia cyber europea, predisponendo adeguate risposte coordinate e
Informatica (Italy e non Italy 😁) reshared this.
freezonemagazine.com/articoli/…
In queste ultime settimane ho letto diversi libri che ripercorrono vite familiari reali, romanzi che lavorano sulla memoria collettiva e quella individuale, storie di persone comuni che si sono trovate a subire gli sconvolgimenti degli ingranaggi della Storia, senza alcuna possibilità di sfuggirle. Ho conosciuto, tramite le vicende di Rubens e Eunice Paiva in Sono […]
L'articolo Alena Mornštajnová
In
Inheritance in Python: la chiave per scrivere codice pulito e collaborativo nel Machine Learning
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.
Zero-day su iPhone, Mac e iPad: Apple corre ai ripari con patch d’emergenza
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.
Aggiorna e muori: Windows 11 mostra la schermata Blu Della Morte (BSOD) dopo gli update di Aprile
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.
Tiny, Hackable Telepresence Robot for under $100? Meet Goby
[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.
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?…
Rise of the Robots: How Robots Are Changing Dairy Farms
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)
A Blacksmith Shows Us How To Choose An Anvil
No doubt many readers have at times wished to try their hand at blacksmithing, but it’s fair to say that acquiring an anvil represents quite the hurdle. For anyone not knowing where to turn there’s a video from [Black Bear Forge], in which he takes us through a range of budget options.
He starts with a sledgehammer, the simplest anvil of all, which we would agree makes a very accessible means to do simple forge work. He shows us a rail anvil and a couple of broken old anvils, before spending some time on a cheap Vevor anvil and going on to some much nicer more professional ones. It’s probably the Vevor which is the most interesting of the ones on show though, not because it is particularly good but because it’s a chance to see up close one of these very cheap anvils.
Are they worth taking the chance? The one he’s got has plenty of rough parts and casting flaws, an oddly-sited pritchel and a hardy hole that’s too small. These anvils are sometimes referred to as “Anvil shaped objects”, and while this one could make a reasonable starter it’s not difficult to see why it might not be the best purchase. It’s a subject we have touched on before in our blacksmithing series, so we’re particularly interested to see his take on it.
youtube.com/embed/ZJFFCp6-wKs?…
Designing an FM Drum Synth from Scratch
How it started: a simple repair job on a Roland drum machine. How it ended: a scratch-built FM drum synth module that’s completely analog, and completely cool.
[Moritz Klein]’s journey down the analog drum machine rabbit hole started with a Roland TR-909, a hybrid drum machine from the mid-80s that combined sampled sounds with analog synthesis. The unit [Moritz] picked up was having trouble with the decay on the kick drum, so he spread out the gloriously detailed schematic and got to work. He breadboarded a few sections of the kick drum circuit to aid troubleshooting, but one thing led to another and he was soon in new territory.
The video below is on the longish side, with the first third or so dedicated to recreating the circuits used to create the 909’s iconic sound, slightly modifying some of them to simplify construction. Like the schematic that started the whole thing, this section of the video is jam-packed with goodness, too much to detail here. But a few of the gems that caught our eye were the voltage-controlled amplifier (VCA) circuit that seems to make appearances in multiple places in the circuit, and the dead-simple wave-shaper circuit, which takes some of the harmonics out of the triangle wave oscillator’s output with just a couple of diodes and some resistors.
Once the 909’s kick and toms section had been breadboarded, [Moritz] turned his attention to adding something Roland hadn’t included: frequency modulation. He did this by adding a second, lower-frequency voltage-controlled oscillator (VCO) and using that to modulate the drum section. That resulted in a weird, metallic sound that can be tuned to imitate anything from a steel drum to a bell. He also added a hi-hat and cymbal section by mixing the square wave outputs on the VCOs through a funky XOR gate made from discrete components and a high-pass filter.
There’s a lot of information packed into this video, and by breaking everything down into small, simple blocks, [Moritz] makes it easy to understand analog synths and the circuits behind them.
youtube.com/embed/Xbl1xwFR3eg?…
Inheritance in Python: la chiave per scrivere codice pulito e collaborativo nel Machine Learnin
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 Learnin proviene da il blog della sicurezza informatica.
#Libano, fuoco sulla Resistenza
Libano, fuoco sulla Resistenza
Nonostante sia ufficialmente in vigore un cessate il fuoco dallo scorso novembre, in Libano stanno proseguendo le operazioni militari ingiustificate da parte di Israele e con il totale appoggio degli Stati Uniti.www.altrenotizie.org
Scuola di Liberalismo 2025: Alberto Mingardi – Luigi Einaudi e il liberalismo per l’uomo comune
@Politica interna, europea e internazionale
Alberto Mingardi è Professore Associato di “Storia delle dottrine politiche” all’Università IULM di Milano e, oltre a ciò, ricopre il ruolo di Presidential Fellow in Political Theory presso la Chapman University e
Politica interna, europea e internazionale reshared this.
USA: Google deve adottare un approccio rispettoso dei diritti dopo che il tribunale ha dichiarato monopolista la sua funzione AdTech
Rispondendo alla sentenza di un tribunale statunitense che ha dichiarato illegale il monopolio pubblicitario online di Google, Agnès Callamard, Segretaria generale di Amnesty International, ha dichiarato:
"Una rottura del monopolio di Google nel rispetto dei diritti umani potrebbe essere un primo passo importante verso un mondo online rispettoso dei diritti umani. Erodendo il dominio di una singola azienda e indebolendo il controllo di Google sui nostri dati, si crea uno spazio che deve essere colmato da attori impegnati a tutelare i diritti umani."
reshared this
Max su Poliverso 🇪🇺🇮🇹
in reply to simona • •@simona
Finché c'è una stazione di polizia, una caserma, un carcere, lì c'è lo stato.
simona
in reply to Max su Poliverso 🇪🇺🇮🇹 • •