I denne udfordring skal du bruge **Titanic-datasættet**, som indeholder information om passagerer på Titanic, herunder deres alder, køn, familiestørrelse og mere. Målet er at forudsige, om en passager overlevede eller ej.

import pandas as pd

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

For at implementere Decision Tree kan du bruge `DecisionTreeClassifier` fra `sklearn`:

Din opgave er at opbygge et Decision Tree og finde den bedste `max_depth` og `min_samples_leaf` ved hjælp af grid search.

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_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 = {'max_depth': [1, 2, 3, 4, 5, 6, 7], 'min_samples_leaf': [1, 2, 4, 6]}

        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.tree import DecisionTreeClassifier

        param_grid = {'max_depth': [1, 2, 3, 4, 5, 6, 7], 'min_samples_leaf': [1, 2, 4, 6]}

        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,
                                   DecisionTreeClassifier) and actual_value.param_grid == param_grid and actual_value.cv is 10
            failure_message = f"Expected `{variable}` to be a `GridSearchCV` with `estimator=DecisionTreeClassifier()`, `param_grid={param_grid}`, and `cv=10`, 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.8316978776529339

        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 centrale klassifikationsalgoritmer, der driver moderne maskinlæring. Udforsk hvordan modeller som k-NN, logistisk regression, beslutningstræer og random forests foretager forudsigelser, evaluerer deres nøjagtighed, og forstå hvornår hver model bør anvendes. Opbyg færdigheder til at sammenligne modeller og vælge den bedste til dine data.

Opdag, hvordan k-nærmeste naboer-algoritmen foretager forudsigelser baseret på lighed. Lær at håndtere flere egenskaber, justere parametre og anvende krydsvalidering for at forbedre nøjagtigheden.

Forstå, hvordan logistisk regression modellerer sandsynligheder og klassificerer udfald. Øv implementering, fortolkning af beslutningsgrænser og anvendelse af regularisering for at forhindre overfitting.

Lær, hvordan beslutningstræer opdeler data i meningsfulde grupper baseret på featureværdier. Udforsk, hvordan parametre som trædybde og minimum antal prøver per blad påvirker modellens ydeevne og generalisering.

Undersøg, hvordan random forests kombinerer flere beslutningstræer for at forbedre nøjagtighed og robusthed. Forstå betydningen af tilfældighed og anvend denne ensemble-metode på virkelige data.

Evaluering af modeller ved hjælp af metrikker såsom nøjagtighed, præcision, recall og F1-score. Lær at fortolke forvekslingsmatrixer og sammenligne flere klassifikatorer for at identificere den bedst præsterende model.

Udfordring: Implementering af et Beslutningstræ

Løsning

Awesome!

Udfordring: Implementering af et Beslutningstræ

Løsning