Neste desafio, será utilizado o **conjunto de dados Titanic**, que contém informações sobre os passageiros do Titanic, incluindo idade, sexo, tamanho da família e outros dados. O objetivo é prever se um passageiro sobreviveu ou não.

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

Para implementar a Árvore de Decisão, pode-se utilizar o `DecisionTreeClassifier` da biblioteca `sklearn`:

Sua tarefa é construir uma Árvore de Decisão e encontrar os melhores valores para `max_depth` e `min_samples_leaf` utilizando busca em grade.

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

Domine os principais algoritmos de classificação que impulsionam o aprendizado de máquina moderno. Explore como modelos como k-NN, regressão logística, árvores de decisão e florestas aleatórias fazem previsões, avalie sua precisão e compreenda quando utilizar cada um. Desenvolva habilidades para comparar modelos e escolher o mais adequado para seus dados.

Descubra como o algoritmo dos k-vizinhos mais próximos realiza previsões com base na similaridade. Aprenda a lidar com múltiplas variáveis, ajustar parâmetros e aplicar validação cruzada para aprimorar a precisão.

Compreender como a regressão logística modela probabilidades e classifica resultados.
Prática de implementação, interpretação de fronteiras de decisão e aplicação de regularização para evitar overajuste.

Aprenda como as árvores de decisão dividem os dados em grupos significativos com base nos valores das características. Explore como parâmetros como profundidade da árvore e número mínimo de amostras por folha afetam o desempenho do modelo e a generalização.

Explore como as florestas aleatórias combinam múltiplas árvores de decisão para melhorar a precisão e a robustez. Compreenda o papel da aleatoriedade e aplique este método de ensemble a dados do mundo real.

Avaliação de modelos utilizando métricas como acurácia, precisão, recall e F1-score. Interpretação de matrizes de confusão e comparação de múltiplos classificadores para identificar o modelo de melhor desempenho.

Desafio: Implementando uma Árvore de Decisão

Solução

Awesome!

Desafio: Implementando uma Árvore de Decisão

Solução