Du skal bruke følgende datasett med **to funksjoner**:

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())

Hvis du kjører koden nedenfor og ser på det resulterende **spredningsdiagrammet**, vil du se at datasettet **ikke er lineært separerbart**:

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()

Bruk av **kryssvalidering** for å evaluere en enkel logistisk regresjon på dette datasettet:

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}')

Som du kan se, er vanlig logistisk regresjon ikke egnet for denne oppgaven. Bruk av polynomisk regresjon kan bidra til å forbedre modellens ytelse. I tillegg gir bruk av `GridSearchCV` deg mulighet til å finne den optimale `C`-parameteren for bedre nøyaktighet.

Denne oppgaven bruker også `Pipeline`-klassen. Du kan se på den som en **sekvens av forhåndsprosesseringssteg**. Metoden `.fit_transform()` anvender sekvensielt `.fit_transform()` på hvert steg i pipelinen.

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

Behersk de sentrale klassifiseringsalgoritmene som driver moderne maskinlæring. Utforsk hvordan modeller som k-NN, logistisk regresjon, beslutningstrær og random forests gjør prediksjoner, evaluerer nøyaktigheten sin, og forstå når hver modell bør brukes. Bygg ferdigheter til å sammenligne modeller og velge den beste for dine data.

Utforsk hvordan k-nærmeste naboer-algoritmen gjør prediksjoner basert på likhet. Lær å håndtere flere egenskaper, justere parametere og bruke kryssvalidering for å forbedre nøyaktigheten.

Forstå hvordan logistisk regresjon modellerer sannsynligheter og klassifiserer utfall. Øv på implementering, tolkning av beslutningsgrenser og bruk av regularisering for å forhindre overtilpasning.

Lær hvordan beslutningstrær deler data inn i meningsfulle grupper basert på egenskapsverdier. Utforsk hvordan parametere som treets dybde og minimum antall prøver per blad påvirker modellens ytelse og generalisering.

Utforsk hvordan random forest kombinerer flere beslutningstrær for å forbedre nøyaktighet og robusthet. Forstå rollen til tilfeldighet og bruk denne ensemblemetoden på virkelige data.

Vurder modeller ved hjelp av måleparametere som nøyaktighet, presisjon, tilbakekalling og F1-score. Lær å tolke forvirringsmatriser og sammenligne flere klassifikatorer for å identifisere den best presterende modellen.

Utfordring: Klassifisering av uskiljbare data

Løsning