En este desafío, utilizarás el **conjunto de datos Titanic**, que contiene información sobre los pasajeros del Titanic, incluyendo su edad, sexo, tamaño de la familia y más. El objetivo es predecir si un pasajero sobrevivió o no.

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 el Árbol de Decisión, puedes utilizar `DecisionTreeClassifier` de `sklearn`:

Construcción de un árbol de decisión y búsqueda de los mejores valores para `max_depth` y `min_samples_leaf` mediante búsqueda en cuadrícula.

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

Domina los algoritmos de clasificación fundamentales que impulsan el aprendizaje automático moderno. Explora cómo modelos como k-NN, regresión logística, árboles de decisión y bosques aleatorios realizan predicciones, evalúan su precisión y comprende cuándo utilizar cada uno. Desarrolla las habilidades para comparar modelos y seleccionar el más adecuado para tus datos.

Descubra cómo el algoritmo de los k vecinos más cercanos realiza predicciones basadas en la similitud. Aprenda a manejar múltiples características, ajustar parámetros y aplicar validación cruzada para mejorar la precisión.

Comprender cómo la regresión logística modela probabilidades y clasifica resultados.
Practicar la implementación, la interpretación de fronteras de decisión y la aplicación de regularización para prevenir el sobreajuste.

Aprenda cómo los árboles de decisión dividen los datos en grupos significativos según los valores de las características. Explore cómo parámetros como la profundidad del árbol y el número mínimo de muestras por hoja afectan el rendimiento y la generalización del modelo.

Explora cómo los bosques aleatorios combinan múltiples árboles de decisión para mejorar la precisión y la robustez. Comprende el papel de la aleatoriedad y aplica este método de conjunto a datos del mundo real.

Evaluación de modelos utilizando métricas como exactitud, precisión, exhaustividad y puntuación F1.
Interpretación de matrices de confusión y comparación de múltiples clasificadores para identificar el modelo de mejor desempeño.

Desafío: Implementación de un Árbol de Decisión

Solución