Sie werden den folgenden Datensatz mit **zwei Merkmalen** verwenden:

import pandas as pd

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/circles.csv')
print(df.head())

Wenn Sie den folgenden Code ausführen und das resultierende **Streudiagramm** betrachten, werden Sie feststellen, dass der Datensatz **nicht linear trennbar** ist:

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/circles.csv')
plt.scatter(df['X1'], df['X2'], c=df['y'])
plt.show()

Verwendung von **Cross-Validation** zur Bewertung einer einfachen logistischen Regression auf diesen Daten:

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b71ff7ac-3932-41d2-a4d8-060e24b00129/circles.csv')
X = df[['X1', 'X2']]
y = df['y']

X = StandardScaler().fit_transform(X)
lr = LogisticRegression().fit(X, y)

y_pred = lr.predict(X)
plt.scatter(df['X1'], df['X2'], c=y_pred)
plt.show()

print(f'Cross-validation accuracy: {cross_val_score(lr, X, y).mean():.2f}')

Wie Sie sehen, ist die reguläre logistische Regression für diese Aufgabe nicht geeignet. Die Verwendung von polynomialer Regression kann die Modellleistung verbessern. Zusätzlich ermöglicht der Einsatz von `GridSearchCV`, den optimalen `C`-Parameter für eine höhere Genauigkeit zu finden.

Diese Aufgabe verwendet außerdem die Klasse `Pipeline`. Sie kann als **Abfolge von Vorverarbeitungsschritten** betrachtet werden. Die Methode `.fit_transform()` wendet `.fit_transform()` nacheinander auf jeden Schritt in der Pipeline an.

import typing
import unittest
import importlib


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):

    def test_pipe_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'pipe'),
            "The `pipe` variable is declared.",
            "Expected the `pipe` variable to be declared."
        )

    def test_pipe_contains_polynomial_and_scaler(self):
        import user_code
        from sklearn.preprocessing import StandardScaler, PolynomialFeatures
        from sklearn.pipeline import Pipeline

        expected_value = [PolynomialFeatures(include_bias=False), StandardScaler()]

        variable = 'pipe'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, Pipeline):
            if isinstance(actual_value.steps, list):
                if len(actual_value.steps) != len(expected_value):
                    failure_message = f'Expected the number of steps of the `pipe` to be `{len(expected_value)}`, but got `{len(actual_value.steps)}`.'
                else:
                    try:
                        steps = [obj for _, obj in actual_value.steps]
                        condition = all(
                            steps[i].get_params() == expected_value[i].get_params() for i in range(len(steps)))
                    except TypeError:
                        steps = actual_value.steps
                        condition = False

                    failure_message = f"Expected the steps of the `{variable}` to be `{expected_value}`, but got `{steps}`."
            else:
                failure_message = "The argument of the `Pipeline` is not a `list`."
        else:
            failure_message = f"`{variable}` is not a `Pipeline`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains correct steps.",
            failure_message
        )

    def test_param_grid_is_declared(self):
        import user_code

        _dynamic_test(
            self,
            hasattr(user_code, 'param_grid'),
            "The `param_grid` variable is declared.",
            "Expected `param_grid` to be declared."
        )

    def test_param_grid_is_correct(self):
        import user_code
        expected_value = {'C': [0.01, 0.1, 1, 10, 100]}

        variable = 'param_grid'
        actual_value = getattr(user_code, variable, None)
        if actual_value is None:
            condition = False
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, dict):
            condition = actual_value == expected_value
            failure_message = f"Expected `{variable}` to contain `{expected_value}`, but got `{actual_value}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `dict`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct values.",
            failure_message
        )

    def test_grid_cv_is_declared(self):
        import user_code

        variable = 'grid_cv'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_grid_cv_is_correct(self):
        import user_code
        from sklearn.model_selection import GridSearchCV
        from sklearn.linear_model import LogisticRegression

        param_grid = {'C': [0.01, 0.1, 1, 10, 100]}

        variable = 'grid_cv'
        actual_value = getattr(user_code, variable, None)
        if actual_value is None:
            condition = False
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, GridSearchCV):
            condition = isinstance(actual_value.estimator, LogisticRegression) and actual_value.param_grid == param_grid and actual_value.cv is None
            failure_message = f"Expected `{variable}` to be a `GridSearchCV` with `estimator=LogisticRegression()`, `param_grid={param_grid}`, and `cv=None`, but got `estimator={actual_value.estimator}`, `param_grid={actual_value.param_grid}`, and `cv={actual_value.cv}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `GridSearchCV`."

        _dynamic_test(
            self,
            condition,
            "`grid_cv` is a `GridSearchCV` with `estimator=lr`, `param_grid=param_grid`, and `cv=None`.",
            failure_message
        )

    def test_best_score_is_correct(self):
        import user_code
        expected_value = 0.9120000000000001

        variable = 'best_score'
        actual_value = getattr(user_code, variable, None)
        if actual_value is None:
            condition = False
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, float):
            condition = actual_value == expected_value
            failure_message = f"Expected `{variable}` to contain `{expected_value}`, but got `{actual_value}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `float`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` is correct.",
            failure_message
        )


if __name__ == '__main__':
    unittest.main()

test_main.py

Beherrschen Sie die grundlegenden Klassifikationsalgorithmen, die moderne Machine-Learning-Anwendungen antreiben. Erforschen Sie, wie Modelle wie k-NN, logistische Regression, Entscheidungsbäume und Random Forests Vorhersagen treffen, deren Genauigkeit bewerten und verstehen, wann welches Modell eingesetzt wird. Entwickeln Sie die Fähigkeiten, Modelle zu vergleichen und das beste für Ihre Daten auszuwählen.

Erfahren Sie, wie der k-nächste-Nachbarn-Algorithmus Vorhersagen auf Basis von Ähnlichkeiten trifft. Umgang mit mehreren Merkmalen, Parametereinstellung und Anwendung von Kreuzvalidierung zur Verbesserung der Genauigkeit.

Verstehen, wie die logistische Regression Wahrscheinlichkeiten modelliert und Ergebnisse klassifiziert. Anwendung der Implementierung, Interpretation von Entscheidungsgrenzen und Einsatz von Regularisierung zur Vermeidung von Overfitting.

Erfahren Sie, wie Entscheidungsbäume Daten anhand von Merkmalswerten in sinnvolle Gruppen unterteilen. Untersuchen Sie, wie Parameter wie Baumtiefe und minimale Stichprobengröße pro Blatt die Modellleistung und Generalisierung beeinflussen.

Erkunden, wie Random Forests mehrere Entscheidungsbäume kombinieren, um Genauigkeit und Robustheit zu verbessern.
Die Rolle des Zufalls verstehen und diese Ensemble-Methode auf reale Daten anwenden.

Bewertung von Modellen anhand von Metriken wie Genauigkeit, Präzision, Recall und F1-Score. Interpretation von Konfusionsmatrizen und Vergleich mehrerer Klassifikatoren zur Identifikation des leistungsstärksten Modells.

Herausforderung: Klassifizierung Untrennbarer Daten

Lösung