RegressioneLineare.py

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

from sklearn.linear_model import LinearRegression as skLinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from sklearn.preprocessing import PolynomialFeatures

import seaborn as sns

class LinearRegression:

    coef_ = None
    intercep_ = None
    
    ## stiamo ricostruendo la formula per il metodo dei minimi quadrati

    def fit(self, x, y):  ## self sarebbe il this in c++ quindi un puntatore che rimanda alla classe stessa
        x_sum = x.sum()
        y_sum = y.sum()

        xy_sum = (x*y).sum()
        x2_sum = (x*x).sum()

        n = y.shape[0]

        self.coef_ = (n*xy_sum - x_sum*y_sum)/(n*x2_sum - x_sum*x_sum)
        self.intercep_ = (y_sum - self.coef_*x_sum)/y.shape[0]

    def predict(self, x):
        return self.coef_*x + self.intercep_
    
    def MEA(y_true, y_pred):
        return np.abs(y_true - y_pred).sum()/y_true.shape[0]
    
    def MSE(y_true, y_pred):
        return np.power(y_true - y_pred, 2).sum()/y_true.shape[0]
    
    def  root(self, y_true, y_pred):
        return np.square(self.MSE(y_true. y_pred))
    
    def _rss( y_true, y_pred):
        return np.power((y_true - y_pred, 2).sum())
    
    def _sst(y_true):
        return np.power((y_true - y_true.mean(), 2).sum())

    def r2_score(self, y_true, y_pred):
        return 1 - self._rss(y_true, y_pred)/self._sst(y_true)
    
if __name__ == "__main__":

    lr = LinearRegression()

    x_trail = np.array([80, 150, 30, 50, 120, 60, 110, 110])
    y_trail = np.array([16, 30, 12, 10, 24, 18, 20, 25])

    ## nel caso di sikitlearn vuole un array bidimensionale
    x_trail_sik = np.array([[80], [150], [30], [50], [120], [60], [110], [110]])
    y_trail_sik = np.array([[16], [30], [12], [10], [24], [18], [20], [25]])

    ## nota bene che con sikit non dobbiamo scrivere mega formule fa tutto lui
    LR = skLinearRegression()
    LR.fit(x_trail_sik, y_trail_sik)
    print("valori sik: " , LR.coef_, LR.intercep_)
    


    lr.fit(x_trail, y_trail)
    print("predict: " , lr.predict(70))

    ## creiamo un plot
    plt.figure(figsize = (10, 8))
    x_line = np.arange(1, 150)
    y_line = lr.predict(x_line)

    plt.scatter(x_trail, y_trail,  c = "green")
    plt.plot(x_line, y_line, c = "red")
    plt.show()

    y_pred = lr.predict(x_trail)
    ##calcoliamo le metriche cioè le funzioni di costo sempre meglio se piccole

    ## MAE Mean Absolute Error
    print("MEA: ", lr.MEA(y_trail,  y_pred))
    ## MSE Mean Square Error
    print("MSE: ", lr.MSE(y_trail,  y_pred))  ## Non è sulla stessa scala dei nostri dati per questo si usa il quadrato

    lr.root()

    data = [[89, 1995,16], [150, 1998, 30], [30, 2008, 12], [50, 1996, 10], [120, 1994, 24], [60, 2006, 18], [110, 1989, 20], [110, 2000, 25]]
    df = pd.DataFrame(data, columns=['Metri', 'Anno', 'Valore'])

    corr_ = df.corr() ##calcola la matrice di correlazione tra le variabili del DataFrame

    sns.heatmap(corr_,  ## usiamo una heat map per vedere la correlazione tra le variabiliù
                annot=True ) ## annot serve per mostrare i valori all'interno della heatmap
                                   

    plt.show()         ## comunque usiamo matplot per mostrare la heatmap

    ##regressione multipla

    poly = PolynomialFeatures(degree = 2) ##polynomial features serve per creare nuove feature a partire da quelle esistenti, in questo caso crea tutte le combinazioni di grado 2 delle feature esistenti
    poly.fit(x_trail_sik)   ##fit serve per calcolare i parametri necessari 
                            ## trasform le feature esistenti in nuove feature polinomiali
    
    
    x_trail_poly = poly.transform(x_trail_sik) ##trasforma le feature esistenti in nuove feature polinomiali con notazione scientifica
                                               ## PRATICEMNTE OGNI TRIPLETTA DI VALORI VIENE RAPPRESENTATA COME UNA FUNZIONE POLINOMIALE DI GRADO 2, CIOÈ UNA CURVA
    np.set_printoptions(suppress=True) ##suppress serve per evitare la notazione scientifica e mostrare i numeri in modo più leggibile
    print(x_trail_poly)

    degree = [2, 3, 4, 5, 10, 20, 50, 100]  ##usiamo diversi gradi cosi da vedere quale tra questi è il migliore per i nostri dati, cioè quello che passa per il maggior numero di punti
                                            ## per questo usiamo il ciclo for con show per vedere le varie curve create
    X_line = np.arange(1, 150)
    X_line.reshape(-1, 1) ##reshape serve per trasformare l'array in una matrice con una sola colonna, formato che vuole sikit

    ##creiamo un loop per ogni funzione polinomiale
    for d in degree:
        poly = PolynomialFeatures(degree)
        poly.fit_transform(x_trail_sik)

        LR.fit(x_trail_poly, y_trail_sik)

        y_pred_poly = LR.predict(x_trail_poly)

        ## stiamo usando le funzioni di siklearn

        mse = mean_squared_error(y_trail_sik, y_pred_poly)
        r2 = r2_score(y_trail_sik, y_pred_poly)
        msa = mean_absolute_error(y_trail_sik, y_pred_poly)

        X_line_poly = poly.transform(X_line)
        Y_line = LR.predict(X_line_poly)


        print(f"Degree: {d} - R2 Score: {LR.r2_score(y_trail_sik, y_pred_poly)}")