From sales to machine learning.
MSc in Computer Science at the University of Pisa, specializing in Data Science and Business Informatics. I build models that work on real data and explain their decisions, from optimization and NLP to big data and business intelligence.
A fresh start: new city, new field, same determination.
I spent many years in sales: on the phone for brands like Vodafone, Eni and Fastweb, and on the shop floor at GameStop, Foot Locker and others. It taught me to listen, to negotiate and to turn a skeptical customer into a convinced one. But deep down I knew it was not what I wanted to do with my life.
So I changed it. I moved from Bari to Pisa and started again from scratch, to devote myself to my real passion: computer science and machine learning. I earned my BSc in Computer Science at the University of Pisa with a thesis built from scratch in Python: a decision tree that handles categorical attributes natively and splits them into multiple branches, something the best-known machine learning libraries, scikit-learn included, have yet to support.
For my MSc I chose the track where my two worlds meet: Data Science and Business Informatics. The rigor of the models and the ability to explain them to the people who use them: that is what I bring to a team.
Years in sales taught me what many technical profiles miss: explaining complex things simply.
Problem, approach and result, with the numbers from each repository. Everything is open source.
One project at a time. Use the arrows or swipe to browse all eleven →
A custom interior-point solver that beats general-purpose tools by exploiting the structure of the problem.
Constrained Lasso is a core sparse-regression problem, but general-purpose solvers like OSQP and SCS treat it as just another quadratic program.
Derived the quadratic reformulation and KKT conditions, then implemented Mehrotra's predictor-corrector method, reducing each Newton step to a structured positive definite system.
Up to 264.9× faster than CVXPY baselines, with near-identical solutions, on datasets of up to 2,000 features.
My largest project: tabular and temporal data mining on the whole IMDb catalog, from anomalies to explainable predictions.
149,531 heterogeneous IMDb records and 1,134 box-office revenue curves: skewed features, rare classes and patterns hidden in time.
Robust scaling with Yeo-Johnson, consensus anomaly detection with three detectors, imbalanced learning, tree ensembles and a regularized neural network explained with SHAP; DTW clustering, matrix profiles, shapelets and MiniROCKET on the time series.
A 9-notebook, 32-page study: 1,089 anomalies confirmed by consensus, rating models explained feature by feature, and box-office trajectories grouped into distinct commercial lifecycles.
Can the sound of a track explain its genre and its popularity? An end-to-end answer on 114,000 songs.
114,000 tracks spread over 114 overlapping Spotify genres, with popularity that no single audio feature explains.
A hand-built taxonomy from 114 to 10 macro-genres, LOF anomaly detection, K-Means validated by a 4.6M-parameter deep network, tree ensembles, SMOTE and SHAP.
97.5% cluster recovery, 0.90 macro ROC AUC on 10 genres, 18× the R² of linear models and +59% recall on the rare explicit class.
Four generations of NLP on the same half-million reviews, compared fairly.
568,454 Amazon reviews: how far do classic methods go, and what do deep learning and transformers really add?
A balanced study set of 164,074 reviews; Naive Bayes and linear SVM on TF-IDF, a custom 2.66M-parameter CNN-BiLSTM on Word2Vec trained on the corpus, and DistilBERT.
ROC AUC rises from 0.96 to 0.98, with detailed error analysis and precision-recall evaluation for every model.
49 years of global seismic data, processed in a distributed way, without throwing information away.
3.27 million seismic records from 1970 to 2019, with key variables missing in up to 41% of rows.
Regression-based imputation in Spark instead of dropping columns, K-Means on standardized features and on geography, Random Forest magnitude classification with threshold analysis, Folium maps.
A clean catalog of 2,607,588 earthquakes and clusters that isolate deep events down to 735 km and remote, poorly covered regions.
My BSc thesis: a decision tree that splits the way the data actually is.
Popular libraries build binary trees and need categorical data to be encoded into numbers first.
A classifier written from scratch: native categorical attributes, multiway splits, three strategies for numerical data, two impurity criteria and pre-pruning.
Benchmarked against scikit-learn on 10 datasets and 51,840 recorded evaluations, with comparable peak accuracy, higher on two datasets. Documented in a 75-page thesis.
def _fit(self, data: pd.DataFrame, features: list[str], current_depth: int) -> "MixedDecisionTree.Node": """Grow the tree recursively, one multiway split at a time, until a stopping criterion is met.""" node, stop = self._stoppingCriteria(data, features) if stop: return node # choose the attribute with the highest information gain gain_dict = {f: self._getGain(data, f) for f in features} best_split_attribute = max(gain_dict, key=gain_dict.get) remaining_features = [ f for f in features if f != best_split_attribute] root = MixedDecisionTree.Node() root.split_condition = best_split_attribute root.gain = gain_dict[best_split_attribute] root.depth = current_depth # multiway split: one child for every attribute value for value, sub_data in data.groupby(best_split_attribute): child = self._fit(sub_data, remaining_features, current_depth + 1) child.split_value, child.parent = value, root root.children.append(child) return rootdef _getGain(self, data: pd.DataFrame, split_attribute_name: str) -> float: """Information gain of a multiway split on an attribute.""" I_parent = self._get_impurity(data[self.class_name]) # weighted impurity of ALL the children of the split column = data[split_attribute_name] groups = data[self.class_name].groupby(column) weights = groups.size() / len(data) I_child = sum(w * self._get_impurity(labels) for w, (_, labels) in zip(weights, groups)) # clip tiny negative values due to floating-point error return max(I_parent - I_child, 0.0)def _get_impurity(self, attribute: pd.Series) -> float: """Entropy or Gini index of a column of class labels.""" _, counts = np.unique(attribute, return_counts=True) p = counts / counts.sum() if self.criterion == "entropy": return float(-np.sum(p * np.log2(p))) if self.criterion == "gini": return float(1.0 - np.sum(p ** 2)) raise ValueError("criterion must be 'entropy' or 'gini'")Power transformations from theory to inference: on Darwin's classic plant data, my estimate matches the published one.
Many statistical tests assume normal data, but real measurements are often skewed, and the classic Box‑Cox family only accepts positive values.
Implemented the Yeo‑Johnson family in R from its formula, studied its geometry, and estimated λ, μ and σ² by maximum likelihood with the Jacobian term, L‑BFGS‑B and a numerical Hessian.
On Darwin's 15 paired plants, λ = 1.305 as in the original paper: skewness falls from −0.82 to 0.07 and a likelihood-ratio test favors the transformation.
From business requirements to workflows proven correct: an internship modeled in BPMN, translated into Petri nets and verified sound before and after a policy change.
Three roles run an internship and coordinate only through messages. A diagram shows how the process should go; it cannot prove that every run completes.
Modeled the collaboration in BPMN, translated it into a workflow net per role and a composed Petri net, then added a new policy, extending the internship, with its own coordination protocol.
Both composed systems verified sound in WoPeD: every run can complete, ends with no stray tokens and leaves no task dead, before and after the extension.
Four exercises on what happens behind a programming language, from JavaBeans that talk only through events to Python decorators that enforce type hints.
Each exercise asks a language for something its everyday syntax does not give: components wired at run time, tests described by annotations, a type that keeps its own invariant, type hints checked at every call.
A card game of JavaBeans whose rules are vetoes, a test runner that reads the method order from the class file, a Haskell multiset with Eq and Foldable instances, and decorators built on Python's inspect module.
Both RunTests outputs and all three Python logs reproduced byte for byte, the anagram facts verified in Haskell, and 43 game rules passed through the real Swing interface.
A multithreaded supermarket as a working model of an operating system: threads, mutexes and condition variables, two processes talking over a socket, signals to close the day.
Dozens of customers shop, queue and switch checkouts at the same time, while the number of open checkouts has to follow the load: shared state, waiting and coordination, all at once.
Customers and cashiers as POSIX threads sharing state through mutexes and condition variables, and a separate director process that opens and closes checkouts over a Unix‑domain socket, with fork, exec and signals.
A simulation of 50 customers and 6 checkouts with queue migration, graceful and emergency shutdown, and a Bash analyzer that turns the log into per-customer and per-checkout statistics.
The game of this website, built from scratch: a deterministic engine turns every game into a link that anyone can replay, race and verify, with no server.
A static website with no server, no database and no accounts, yet a game people compete on: a rival to race, leaderboards and scores that nobody can make up.
An engine in fixed 1/60 s ticks, with whole-number gravity and a seeded generator: the seed and the inputs replay a game exactly, so a whole game fits in a link and the receiving browser recomputes its score.
Challenge links of about 1,400 characters, a rival replayed in step, verified leaderboards, 8‑bit music synthesized in the browser and 62 automated tests; a three-minute game replays in about 1 ms.
Complete projects with their own case study, just like the ones above: they are here only because the spotlight can’t hold them all.
More projects to the right. Use the arrows or swipe to see them all →
A distributed Kanban platform with a custom JSON protocol, RMI push callbacks and a multicast chat per project.
What makes a title win awards? Clustering, regression and FP‑Growth rules powering an interpretable classifier.
A generic container with its own users and access control, where every item remembers its first owner.
An evaluator for a small functional language, with closures, recursion, dictionaries and both static and dynamic scoping.
The main projects in this area are in Selected work above.
The full picture, in the order that matters most to me: what I studied, what I built, what I learned along the way.
Hands-on machine learning on real, large-scale data. Every project is open source on GitHub.
Designed and built systems and networking software beyond what courses required: a multithreaded client-server collaboration platform in Java (TCP, RMI, UDP multicast), a multi-process supermarket simulator in pure C (POSIX threads, sockets, signals), thread-pool and non-blocking NIO servers, and an interpreter in OCaml. All published open source on GitHub.
Many years in sales, on the phone and on the shop floor, before becoming a computer scientist and data scientist. Every day was a negotiation with real people, real objections and real targets.
What I took from it: listening to people, persuading with clear arguments, explaining complex offers simply and staying effective under pressure. Skills I now bring to data work.
Years of selling taught me to talk to anyone. I bring that to data work: I can turn a model into a story that a manager, a client or a non-technical team can act on.