No `sklearn`, a versão de classificação da Random Forest é implementada usando o `RandomForestClassifier`:

Você também calculará a acurácia da validação cruzada utilizando a função `cross_val_score()`:

Ao final, será exibida a **importância de cada atributo**. O atributo `feature_importances_` retorna um array com os escores de importância — esses escores representam o quanto cada atributo contribuiu para **reduzir a impureza de Gini** em todos os nós de decisão onde esse atributo foi utilizado. Em outras palavras, quanto mais um atributo **ajuda a dividir os dados** de forma útil, maior sua **importância**.

No entanto, o atributo fornece apenas os **escores sem os nomes dos atributos**. Para exibir ambos, é possível associá-los utilizando a função `zip()` do Python:

```python
for feature, importance in zip(X.columns, model.feature_importances_):
    print(feature, importance)
```

Isso imprime cada **nome de atributo junto com seu escore de importância**, facilitando a compreensão de quais atributos o modelo mais utilizou.

import unittest
import importlib
import numpy as np


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)


def get_first_differing_index(expected_array, actual_array):
    for i, (val_1, val_2) in enumerate(zip(expected_array, actual_array)):
        if not np.array_equal(val_1, val_2):
            return i, expected_array[i], actual_array[i]

    if len(expected_array) > len(actual_array):
        return len(actual_array), expected_array[len(actual_array)], None
    else:
        return len(expected_array), None, actual_array[len(expected_array)]


class TestUserCode(unittest.TestCase):

    def test_random_forest_is_declared(self):
        import user_code

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

    def test_random_forest_is_fitted_model(self):
        import user_code
        from sklearn.ensemble import RandomForestClassifier

        variable = 'random_forest'
        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, RandomForestClassifier):
            if actual_value.random_state == 42:
                if hasattr(actual_value, 'feature_importances_'):
                    condition = True
                    failure_message = None
                else:
                    failure_message = f"`{variable}` is is not fitted yet."
            else:
                failure_message = f"Expected `{variable}` to have `random_state=42`, but got `{actual_value.random_state}`."
        else:
            failure_message = f"`{variable}` is not a `RandomForestClassifier`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` is a correctly fitted `RandomForestClassifier`.",
            failure_message
        )

    def test_cv_scores_is_declared(self):
        import user_code

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

    def test_cv_scores_is_correct(self):
        import user_code
        import pandas as pd
        from sklearn.ensemble import RandomForestClassifier
        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/titanic.csv')
        X = df.drop('Survived', axis=1)
        y = df['Survived']

        random_forest = RandomForestClassifier(random_state=42).fit(X, y)
        expected_value = cross_val_score(random_forest, X, y, cv=10)

        variable = 'cv_scores'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_value, np.ndarray):
            failure_message = f"`{variable}` is not a `numpy.ndarray`."
        elif len(actual_value) == 0:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value, expected_value):
            condition = True
            failure_message = None
        else:
            idx, expected_element, actual_element = get_first_differing_index(expected_value, actual_value)
            failure_message = f"Expected `{variable}` to contain `{expected_element}` at index {idx}, but got `{actual_element}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct scores.",
            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 Random Forest

Solução

Awesome!

Desafio: Implementando uma Random Forest

Solução