[PYTHON] Ich habe versucht, die beim maschinellen Lernen verwendeten Bewertungsindizes zu organisieren (Regressionsmodell).

• Artikel von Datenwissenschaftlern aus der Fertigungsindustrie
• Dieses Mal sind die im Regressionsmodell verwendeten Bewertungsindizes organisiert.

Einführung

Dieses Mal habe ich versucht, den Bewertungsindex (Regressionsmodell) des maschinellen Lernens zu organisieren. Wir haben auch die Punkte bei Verwendung jedes Bewertungsindex zusammengefasst.

1. Entscheidungskoeffizient

Der Entscheidungsfaktor $ R ^ 2 $ bewertet die Anpassung des geschätzten Regressionsmodells. Die Formel lautet wie folgt.

\begin{eqnarray}
R^2 = 1 - \sum \frac{(y_i - \hat{y_i})^2}{(y_i - \bar{y})^2}
\end{eqnarray}

$ y_i $: Messwert der $ i $ -ten Stichprobe $ \ hat {y_i} $: Voraussichtlicher Wert der $ i $ -ten Stichprobe $ \ bar {y} $: Durchschnitt der gemessenen Werte

Der Python-Code ist unten.

#Bibliothek zur Punkteberechnung
from sklearn.metrics import r2_score

#true ist der wahre Wert (Messwert), pred ist der vorhergesagte Wert
true = [1.0, 1.5, 2.0, 1.2, 1.8]
pred = [0.8, 1.5, 1.8, 1.3, 2.0]

#Berechnen Sie den Wert des Entscheidungskoeffizienten R2
r2_score(true, pred)

2. MAE MAE (Mean Absolute Error) bewertet die Größe des Fehlers des vorhergesagten Werts. Die Formel lautet wie folgt.

\begin{eqnarray}
MAE = \frac{1}{N} \sum|y_i - \hat{y_i}|
\end{eqnarray}

$ y_i $: Messwert der $ i $ -ten Stichprobe $ \ hat {y_i} $: Voraussichtlicher Wert der $ i $ -ten Stichprobe $ N $: Anzahl der Proben

Der Python-Code ist unten.

#Bibliothek zur Punkteberechnung
from sklearn.metrics import mean_absolute_error

#true ist der wahre Wert (Messwert), pred ist der vorhergesagte Wert
true = [1.0, 1.5, 2.0, 1.2, 1.8]
pred = [0.8, 1.5, 1.8, 1.3, 2.0]

#Berechnen Sie den Wert von MAE
mean_absolute_error(true, pred)

3. MSE In MSE (Mean Squared Error) werden große Fehler hervorgehoben und bewertet. Die Formel lautet wie folgt.

\begin{eqnarray}
MSE = \frac{1}{N} \sum(y_i - \hat{y_i})^2
\end{eqnarray}

$ y_i $: Messwert der $ i $ -ten Stichprobe $ \ hat {y_i} $: Voraussichtlicher Wert der $ i $ -ten Stichprobe $ N $: Anzahl der Proben

Der Python-Code ist unten.

#Bibliothek zur Punkteberechnung
from sklearn.metrics import mean_squared_error

#true ist der wahre Wert (Messwert), pred ist der vorhergesagte Wert
true = [1.0, 1.5, 2.0, 1.2, 1.8]
pred = [0.8, 1.5, 1.8, 1.3, 2.0]

#Berechnen Sie den Wert von MSE
mean_squared_error(true, pred)

4. RMSE In RMSE (Root Mean Squared Error) werden große Fehler hervorgehoben und ausgewertet. Die Formel lautet wie folgt.

\begin{eqnarray}
RMSE = \sqrt{\frac{1}{N} \sum(y_i - \hat{y_i})^2}
\end{eqnarray}

$ y_i $: Messwert der $ i $ -ten Stichprobe $ \ hat {y_i} $: Voraussichtlicher Wert der $ i $ -ten Stichprobe $ N $: Anzahl der Proben

Der Python-Code ist unten.

#Bibliothek zur Punkteberechnung
import numpy as np
from sklearn.metrics import mean_squared_error

#true ist der wahre Wert (Messwert), pred ist der vorhergesagte Wert
true = [1.0, 1.5, 2.0, 1.2, 1.8]
pred = [0.8, 1.5, 1.8, 1.3, 2.0]

#Berechnen Sie den RMSE-Wert
np.sqrt(mean_squared_error(true, pred))

5. MAPE MAPE (Mean Absolute Percentage Error) wertet die Größe des Vorhersagefehlers pro Größe des gemessenen Werts aus. Die Formel lautet wie folgt.

\begin{eqnarray}
MAPE = \frac{1}{N} \sum|\frac{y_i - \hat{y_i}}{y_i}|
\end{eqnarray}

$ y_i $: Messwert der $ i $ -ten Stichprobe $ \ hat {y_i} $: Voraussichtlicher Wert der $ i $ -ten Stichprobe $ N $: Anzahl der Proben

Der Python-Code ist unten.

#Bibliothek zur Punkteberechnung
import numpy as np

#true ist der wahre Wert (Messwert), pred ist der vorhergesagte Wert
true = np.array([1.0, 1.5, 2.0, 1.2, 1.8])
pred = np.array([0.8, 1.5, 1.8, 1.3, 2.0])

#Berechnen Sie den Wert von MAPE
np.mean(np.abs((true - pred) / true)) * 100

6. SMAPE SMAPE (Symmetric Mean Absolute Percentage Error) bewertet die Größe des Vorhersagefehlers pro gemessenem Wert. Die Formel lautet wie folgt.

\begin{eqnarray}
SMAPE = \frac{100}{N} \sum|\frac{2(y_i - \hat{y_i})}{(|y_i|+|\hat{y_i}|)}|
\end{eqnarray}

$ y_i $: Messwert der $ i $ -ten Stichprobe $ \ hat {y_i} $: Voraussichtlicher Wert der $ i $ -ten Stichprobe $ N $: Anzahl der Proben

Der Python-Code ist unten.

#Bibliothek zur Punkteberechnung
import numpy as np

#true ist der wahre Wert (Messwert), pred ist der vorhergesagte Wert
true = np.array([1.0, 1.5, 2.0, 1.2, 1.8])
pred = np.array([0.8, 1.5, 1.8, 1.3, 2.0])

#Berechnen Sie den SMAPE-Wert
100/len(true) * np.sum(2 * np.abs(pred - true) / (np.abs(pred) + np.abs(true)))

Zusammenfassung des Skripts

Organisieren Sie das Skript bisher.

#Bibliothek zur Punkteberechnung
import numpy as np
import pandas as pd
from sklearn.metrics import r2_score
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error

def calculate_scores(true, pred):
    """Berechnen Sie alle Metriken

    Parameters
    ----------
    true : np.array
Gemessener Wert
    pred : np.array
Voraussichtlicher Wert

    Returns
    -------
    scores : pd.DataFrame
Ergebnisse der Zusammenfassung jedes Bewertungsindex
    """
    scores = pd.DataFrame({'R2': r2_score(true, pred),
                          'MAE': mean_absolute_error(true, pred),
                          'MSE': mean_squared_error(true, pred),
                          'RMSE': np.sqrt(mean_squared_error(true, pred)),
                          'MAPE': mape(true, pred),
                          'SMAPE': smape(true, pred)},
                          index = ['scores'])
    return scores

def mape(true, pred):  
    """MAPE berechnen

    Parameters
    ----------
    true : np.array
Gemessener Wert
    pred : np.array
Voraussichtlicher Wert

    Returns
    -------
    np.array :Berechnungsergebnis von mape
    """
    return np.mean(np.abs((true - pred) / true)) * 100

#SMAPE-Berechnung
def smape(true, pred):
    """SMAPE berechnen

    Parameters
    ----------
    true : np.array
Gemessener Wert
    pred : np.array
Voraussichtlicher Wert

    Returns
    -------
    np.array :Berechnung von Smape
    """
    return 100/len(true) * np.sum(2 * np.abs(pred - true) / (np.abs(pred) + np.abs(true)))

def main():
    true = np.array([1.0, 1.5, 2.0, 1.2, 1.8])
    pred = np.array([0.8, 1.5, 1.8, 1.3, 2.0])

    scores = calculate_scores(true, pred)

    print(scores)

if __name__ == "__main__":
    main()

schließlich

Vielen Dank für das Lesen bis zum Ende. Wenn Sie eine Korrekturanfrage haben, würden wir uns freuen, wenn Sie uns kontaktieren könnten.