mlexam-src 0.1.0__py3-none-any.whl

mlexam_src/__init__.py

@@ -0,0 +1 @@
+from .main import GeneratoreCodice

mlexam_src/main.py

@@ -0,0 +1,507 @@
+class GeneratoreCodice:
+    def __init__(self):
+        # Definiamo un dizionario che contiene tutti i tuoi codici pre-compilati e commentati
+        self._archivio_codice = {
+            "linear": """
+# ==========================================
+# REGRESSIONE LINEARE FROM SCRATCH
+# ==========================================
+import numpy as np
+
+class LinearRegressionFromScratch:
+    def __init__(self, lr=0.01, n_iters=1000):
+        self.lr = lr
+        self.n_iters = n_iters
+        self.weights = None
+        self.bias = None
+
+    def fit(self, X, y):
+        n_samples, n_features = X.shape
+        self.weights = np.zeros(n_features)
+        self.bias = 0
+        # Ciclo di ottimizzazione (Gradient Descent)
+        for _ in range(self.n_iters):
+            y_predicted = np.dot(X, self.weights) + self.bias
+            dw = (1 / n_samples) * np.dot(X.T, (y_predicted - y))
+            db = (1 / n_samples) * np.sum(y_predicted - y)
+            self.weights -= self.lr * dw
+            self.bias -= self.lr * dbclass LinearRegression:
+    def __init__(self, learning_rate=1e-2, n_steps=200, n_features=1, lmd=0.01, seed=123):
+        self.seed = seed
+        np.random.seed(self.seed)
+
+        self.learning_rate = learning_rate
+        self.n_steps = n_steps
+        self.theta = np.random.rand(n_features)
+        self.lmd = lmd
+
+        self.lmd_ = np.zeros(n_features)
+        self.lmd_ = np.full(n_features, lmd)
+        self.lmd_[0] = 0
+
+    def fit_fbgd(self, X_train, y_train):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for step in range(0, self.n_steps):
+            preds = np.dot(X_train, self.theta)
+            error = preds - y_train
+            gradient = 1/m * np.dot(X_train.T, error)
+            self.theta = self.theta - self.learning_rate * gradient
+
+            theta_history[step, :] = self.theta.T
+            cost_history[step] = 1/(2*m) * np.dot(error, error.T)
+
+        return cost_history, theta_history
+
+    def fit_regularized_fbgd(self, X_train, y_train):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for step in range(0, self.n_steps):
+            preds = np.dot(X_train, self.theta)
+            error = preds - y_train
+            self.theta = self.theta - self.learning_rate * 1/m * (np.dot(X_train.T, error) + self.lmd_ * self.theta)
+
+            cost_history[step] = 1/(2*m) * (np.dot(error, error.T) + self.lmd * np.dot(self.theta[1:].T, self.theta[1:]))
+            theta_history[step, :] = self.theta.T
+        
+        return cost_history, theta_history
+
+    def fit_sgd(self, X_train, y_train):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for step in range(self.n_steps):
+            random_index = np.random.randint(m)
+            x_i = X_train[random_index]
+            y_i = y_train[random_index]
+
+            pred = np.dot(x_i, self.theta)
+            error = pred - y_i
+            self.theta = self.theta - self.learning_rate * x_i.T * error
+
+            pred = np.dot(X_train, self.theta)
+            error_train = pred - y_train
+            cost_history[step] = 1/(2*m) * np.dot(error_train, error_train.T)
+            theta_history[step, :] = self.theta.T
+
+        return cost_history, theta_history
+
+    def fit_sgd_v2(self, X_train, y_train):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for epoch in range(self.n_steps):
+            for i in range(m):
+                prediction = np.dot(X_train[i], self.theta)
+                error = prediction - y_train[i]
+                self.theta = self.theta - self.learning_rate * X_train[i].T * error
+                theta_history[epoch, :] = self.theta.T
+
+            pred = np.dot(X_train, self.theta)
+            error_train = pred - y_train
+            cost_history[epoch] = 1/(2*m) * np.dot(error_train, error_train.T)
+            theta_history[epoch, :] = self.theta.T
+
+        return cost_history, theta_history
+
+    def fit_mbgd(self, X_train, y_train, batch_size=4):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for step in range(self.n_steps):
+            indices = np.random.choice(m, batch_size)
+            x_b = X_train[indices]
+            y_b = y_train[indices]
+
+            pred_b = np.dot(x_b, self.theta)
+            error_b = pred_b - y_b
+
+            self.theta = self.theta - self.learning_rate * (1 / batch_size) * np.dot(x_b.T, error_b)
+
+            pred_train = np.dot(X_train, self.theta)
+            error_train = pred_train - y_train
+            cost_history[step] = 1 / (2 * m) * np.dot(error_train, error_train.T)
+            theta_history[step, :] = self.theta.T
+
+        return cost_history, theta_history
+
+    def fit_mbgd_v2(self, X_train, y_train, batch_size=4):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for epoch in range(self.n_steps):
+            for i in range(0, m, batch_size):
+                x_b = X_train[i:i+batch_size]
+                y_b = y_train[i:i+batch_size]
+
+                pred_b = np.dot(x_b, self.theta)
+                error_b = pred_b - y_b
+                self.theta = self.theta - self.learning_rate * (1/len(x_b)) * np.dot(x_b.T, error_b)
+
+            pred_train = np.dot(X_train, self.theta)
+            error_train = pred_train - y_train
+            cost_history[epoch] = (1/(2*m)* np.dot(error_train, error_train.T))
+            theta_history[epoch, :] = self.theta.T
+
+        return cost_history, theta_history
+
+    def predict(self, X_test):
+        return np.dot(X_test, self.theta)
+
+---adatta codice
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+
+houses = pd.read_csv('./datasets/houses_portaland_simple.csv')
+display(houses[:10])
+
+print(houses.describe())
+
+houses.drop('Bedroom', axis=1, inplace=True)
+print(houses.head())
+
+houses = houses.sample(frac=1, random_state=123).reset_index(drop=True)
+
+plt.plot(houses.Size, houses.Price, 'r.')
+plt.show()
+
+print(houses.corr())
+
+houses = houses.values
+mean = houses.mean(axis=0)
+std = houses.std(axis=0)
+houses = (houses - mean) / std
+
+x = houses[:, 0]
+y = houses[:, 1]
+plt.plot(x, y, 'r.')
+plt.show()
+
+x = np.c_[np.ones(x.shape[0]), x]
+print(x[:5])
+
+linear = LinearRegression(n_features=x.shape[1], n_steps=1000, learning_rate=0.01)
+
+lineX = np.linspace(x[:, 1].min(), x[:, 1].max(), 100)
+liney = [linear.theta[0] + linear.theta[1]*xx for xx in lineX]
+plt.plot(x[:, 1], y, 'r.', label='Training data')
+plt.plot(lineX, liney, 'b--', label='Current hypothesis')
+plt.legend()
+plt.show()
+
+cost_history, theta_history = linear.fit_fbgd(x, y)
+
+print(f'''Thetas: {*linear.theta,}''')
+print(f'''Final train cost:  {cost_history[-1]:.3f}''')
+
+print(theta_history)
+print("theta_0 (after training): ", theta_history[-1, 0])
+print("theta_1 (after training): ", theta_history[-1, 1])
+
+lineX = np.linspace(x[:, 1].min(), x[:, 1].max(), 100)
+liney = [theta_history[-1, 0] + theta_history[-1, 1]*xx for xx in lineX]
+plt.plot(x[:, 1], y, 'r.', label='Training data')
+plt.plot(lineX, liney, 'b--', label='Final hypothesis')
+plt.legend()
+plt.show()
+
+plt.plot(cost_history, 'g--')
+plt.show()
+
+theta0_vals = np.linspace(-2, 2, 100)
+theta1_vals = np.linspace(-2, 3, 100)
+J_vals = np.zeros((theta0_vals.size, theta1_vals.size))
+
+for t0, theta0 in enumerate(theta0_vals):
+    for t1, theta1 in enumerate(theta1_vals):
+        thetaT = np.array([[theta0], [theta1]])
+        h = x.dot(thetaT.flatten())
+        j = (h - y)
+        J = j.dot(j) / 2 / (len(x))
+        J_vals[t0, t1] = J
+
+J_vals = J_vals.T
+A, B = np.meshgrid(theta0_vals, theta1_vals)
+cp = plt.contourf(A, B, J_vals)
+plt.colorbar(cp)
+plt.plot(theta_history.T[0], theta_history.T[1], 'r--')
+plt.show()
+""",
+
+            "multiple": """
+# ==========================================
+# MULTIPLE LINEAR REGRESSION FROM SCRATCH
+# ==========================================
+import numpy as np
+
+class LinearRegression:
+    def __init__(self, learning_rate=1e-2, n_steps=200, n_features=1, lmd=0.01, seed=123):
+        self.seed = seed
+        np.random.seed(self.seed)
+
+        self.learning_rate = learning_rate
+        self.n_steps = n_steps
+        self.theta = np.random.rand(n_features)
+        self.lmd = lmd
+
+        self.lmd_ = np.zeros(n_features)
+        self.lmd_ = np.full(n_features, lmd)
+        self.lmd_[0] = 0
+
+    def fit_fbgd(self, X_train, y_train):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for step in range(0, self.n_steps):
+            preds = np.dot(X_train, self.theta)
+            error = preds - y_train
+            gradient = 1/m * np.dot(X_train.T, error)
+            self.theta = self.theta - self.learning_rate * gradient
+
+            theta_history[step, :] = self.theta.T
+            cost_history[step] = 1/(2*m) * np.dot(error, error.T)
+
+        return cost_history, theta_history
+
+    def fit_regularized_fbgd(self, X_train, y_train):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for step in range(0, self.n_steps):
+            preds = np.dot(X_train, self.theta)
+            error = preds - y_train
+            self.theta = self.theta - self.learning_rate * 1/m * (np.dot(X_train.T, error) + self.lmd_ * self.theta)
+
+            cost_history[step] = 1/(2*m) * (np.dot(error, error.T) + self.lmd * np.dot(self.theta[1:].T, self.theta[1:]))
+            theta_history[step, :] = self.theta.T
+        
+        return cost_history, theta_history
+
+    def fit_sgd(self, X_train, y_train):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for step in range(self.n_steps):
+            random_index = np.random.randint(m)
+            x_i = X_train[random_index]
+            y_i = y_train[random_index]
+
+            pred = np.dot(x_i, self.theta)
+            error = pred - y_i
+            self.theta = self.theta - self.learning_rate * x_i.T * error
+
+            pred = np.dot(X_train, self.theta)
+            error_train = pred - y_train
+            cost_history[step] = 1/(2*m) * np.dot(error_train, error_train.T)
+            theta_history[step, :] = self.theta.T
+
+        return cost_history, theta_history
+
+    def fit_sgd_v2(self, X_train, y_train):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for epoch in range(self.n_steps):
+            for i in range(m):
+                prediction = np.dot(X_train[i], self.theta)
+                error = prediction - y_train[i]
+                self.theta = self.theta - self.learning_rate * X_train[i].T * error
+                theta_history[epoch, :] = self.theta.T
+
+            pred = np.dot(X_train, self.theta)
+            error_train = pred - y_train
+            cost_history[epoch] = 1/(2*m) * np.dot(error_train, error_train.T)
+            theta_history[epoch, :] = self.theta.T
+
+        return cost_history, theta_history
+
+    def fit_mbgd(self, X_train, y_train, batch_size=4):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for step in range(self.n_steps):
+            indices = np.random.choice(m, batch_size)
+            x_b = X_train[indices]
+            y_b = y_train[indices]
+
+            pred_b = np.dot(x_b, self.theta)
+            error_b = pred_b - y_b
+
+            self.theta = self.theta - self.learning_rate * (1 / batch_size) * np.dot(x_b.T, error_b)
+
+            pred_train = np.dot(X_train, self.theta)
+            error_train = pred_train - y_train
+            cost_history[step] = 1 / (2 * m) * np.dot(error_train, error_train.T)
+            theta_history[step, :] = self.theta.T
+
+        return cost_history, theta_history
+
+    def fit_mbgd_v2(self, X_train, y_train, batch_size=4):
+        m = len(X_train)
+        cost_history = np.zeros(self.n_steps)
+        theta_history = np.zeros((self.n_steps, self.theta.shape[0]))
+
+        for epoch in range(self.n_steps):
+            for i in range(0, m, batch_size):
+                x_b = X_train[i:i+batch_size]
+                y_b = y_train[i:i+batch_size]
+
+                pred_b = np.dot(x_b, self.theta)
+                error_b = pred_b - y_b
+                self.theta = self.theta - self.learning_rate * (1/len(x_b)) * np.dot(x_b.T, error_b)
+
+            pred_train = np.dot(X_train, self.theta)
+            error_train = pred_train - y_train
+            cost_history[epoch] = (1/(2*m)* np.dot(error_train, error_train.T))
+            theta_history[epoch, :] = self.theta.T
+
+        return cost_history, theta_history
+
+    def predict(self, X_test):
+        return np.dot(X_test, self.theta)
+
+
+Regression Metric
+class RegressionMetrics:
+    def __init__(self, model):
+        self.model = model
+
+    def compute_performance (self, y_test, y_pred):
+        mae = (self.mean_absolute_error(y_test, y_pred))
+        mape = self.mean_absolute_percentage_error(y_test, y_pred)
+        mpe = self.mean_percentage_error(y_test, y_pred)
+        mse = self.mean_squared_error(y_test, y_pred)
+        rmse = self.root_mean_squared_error(y_test, y_pred)
+        r2 = self.r_2(y_test, y_pred)
+        return {'mae':mae,'mape': mape,'mpe': mpe,
+                'mse': mse,'rmse': rmse,'r2': r2}
+
+    def mean_absolute_error (self, y_test, y_pred):
+        output_errors= np.abs(y_pred - y_test)
+        return np.average(output_errors)
+
+    def mean_squared_error (self, y_test, y_pred):
+        output_errors= (y_pred - y_test)**2
+        return np.average(output_errors)
+
+    def root_mean_squared_error (self, y_test, y_pred):
+        return np.sqrt(self.mean_squared_error(y_test, y_pred))
+
+    def mean_absolute_percentage_error (self, y_test, y_pred):
+        output_errors = np.abs((y_pred - y_test)/y_test)
+        return np.average(output_errors)*100
+
+    def mean_percentage_error (self, y_test, y_pred):
+        output_errors = (y_pred - y_test)/y_test
+        return np.average(output_errors)*100
+
+    def r_2(self, y_test, y_pred):
+        sst = np.sum ((y_test - y_test.mean())**2) 
+        ssr = np.sum((y_pred-y_test)**2) 
+        r2 = 1-(ssr/sst)
+        return r2
+
+
+INIZIO
+houses = pd.read_csv('./datasets/houses.csv')
+
+display(houses)
+
+
+print(houses.describe())
+
+houses = houses.sample(frac=1, random_state=123).reset_index(drop=True)
+
+x = houses[['GrLivArea', 'LotArea', 'GarageArea', 'FullBath']].values
+y = houses['SalePrice'].values
+
+train_index = round(len(x) * 0.8)
+
+X_train = x[:train_index]
+y_train = y[:train_index]
+
+X_test = x[train_index:]
+y_test = y[train_index:]
+
+mean = X_train.mean(axis=0)
+std = X_train.std(axis=0)
+
+X_train = (X_train - mean) / std
+X_test = (X_test - mean) / std
+
+X_train = np.c_[np.ones(X_train.shape[0]), X_train]
+X_test = np.c_[np.ones(X_test.shape[0]), X_test]
+
+print(len(X_train))
+
+linear = LinearRegression(n_features=X_train.shape[1], n_steps=100, learning_rate=0.05)
+
+cost_history, theta_history = linear.fit_fbgd(X_train, y_train)
+
+print(f'''Thetas: {*linear.theta,}''')
+print(f'''Final train cost:  {cost_history[-1]:.3f}''')
+
+plt.plot(cost_history, 'g--')
+plt.show()
+
+reg_metrics = RegressionMetrics(linear)
+y_pred = linear.predict(X_test)
+
+print(reg_metrics.compute_performance(y_test, y_pred))
+
+linear_true_sgd = LinearRegression(n_features=X_train.shape[1], n_steps=100, learning_rate=0.1)
+
+cost_history_true_sgd, theta_history_true_sgd = linear_true_sgd.fit_sgd(X_train, y_train)
+
+print(f'''Thetas: {*linear_true_sgd.theta,})''')
+print(f''' Final Train cost: {cost_history_true_sgd[-1]: 3f}''')
+
+plt.plot(cost_history_true_sgd, 'g--')
+plt.show()
+
+print(RegressionMetrics(linear_true_sgd).compute_performance(y_test, linear_true_sgd.predict(X_test)))
+
+linear_true_mbgd = LinearRegression(n_features=X_train.shape[1], n_steps=100, learning_rate=0.01)
+
+cost_history_true_mbgd, theta_history_true_mbgd = linear_true_mbgd.fit_mbgd(X_train, y_train, batch_size=16)
+
+print(f'''Thetas: {*linear_true_mbgd.theta,})''')
+print(f''' Final Train cost: {cost_history_true_mbgd[-1]: 3f}''')
+
+plt.plot(cost_history_true_mbgd, 'g--')
+plt.show()
+
+print(RegressionMetrics(linear_true_mbgd).compute_performance(y_test, linear_true_sgd.predict(X_test)))
+"""}
+
+    def dammi_codice(self, tipo_modello):
+        """
+        Restituisce la stringa di codice in base al tipo_modello passato.
+        Se il tipo non esiste, avvisa l'utente.
+        """
+        # Trasformiamo l'input in minuscolo per evitare errori di battitura (es. "SVM" o "svm")
+        chiave = tipo_modello.lower()
+
+        if chiave in self._archivio_codice:
+            return self._archivio_codice[chiave]
+        else:
+            opzioni = ", ".join(self._archivio_codice.keys())
+            return f"# Errore: Modello '{tipo_modello}' non trovato. Scegli tra: {opzioni}"
+
+    def copia_appunti(self, tipo_modello):
+        """Stampa direttamente a schermo il codice richiesto."""
+        print(self.dammi_codice(tipo_modello))

mlexam_src-0.1.0.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: mlexam_src
+Version: 0.1.0
+Summary: I miei appunti di ML from scratch
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+
+# ML Exam Library 🚀
+
+Una libreria Python creata per memorizzare, consultare e recuperare rapidamente codici e algoritmi di Machine Learning implementati **from scratch**.
+
+Questa libreria funge da *cheat-sheet* interattivo: permette di stampare direttamente nel terminale il codice sorgente interamente commentato di diversi modelli, pronto per essere copiato e incollato nei tuoi progetti o script d'esame.
+
+## 📦 Installazione
+
+Una volta pubblicata, puoi installare la libreria localmente tramite `pip`:
+
+```bash
+pip install mlexam_src
+
+#from mlexam_src import GeneratoreCodice
+
+# Inizializza il generatore
+cheat_sheet = GeneratoreCodice()
+
+# 1. Stampa il codice della Regressione Lineare
+cheat_sheet.copia_appunti("linear")
+
+# 2. Stampa il codice della Regressione Logistica
+cheat_sheet.copia_appunti("logistic")

mlexam_src-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+mlexam_src/__init__.py,sha256=QAiJf1ZtMoWmTKCeq1N98WCKlfuEzoV6hmLq-Y7Ayy4,34
+mlexam_src/main.py,sha256=I1DDQc0kr4FyHVWvp9dLfAjC5NISAbYGyfw5qB2pTag,18030
+mlexam_src-0.1.0.dist-info/METADATA,sha256=sajzmc129kV7XhV7dhJLyd9tP3u5DzqS_B-nr7C39qg,1191
+mlexam_src-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mlexam_src-0.1.0.dist-info/top_level.txt,sha256=IDg0aAzNc_qKdXQtwmYgPdjfWTsx6IClMrAtnJK8-8Q,11
+mlexam_src-0.1.0.dist-info/RECORD,,

mlexam_src-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mlexam_src-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mlexam_src