In `sklearn`, the classification version of Random Forest is implemented using the `RandomForestClassifier`:

You will also calculate the cross-validation accuracy using the `cross_val_score()` function:

In the end, you'll print the **importance of each feature**. The `feature_importances_` attribute returns an array of importance scores - these scores represent how much each feature contributed to **reducing Gini impurity** across all the decision nodes where that feature was used. In other words, the more a feature **helps split the data** in a useful way, the higher its **importance**.

However, the attribute only gives the **scores without feature names**. To display both, you can pair them using Python's `zip()` function:

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

This prints each **feature name along with its importance score**, making it easier to understand which features the model relied on most.

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

Master the core classification algorithms that power modern machine learning. Explore how models like k-NN, logistic regression, decision trees, and random forests make predictions, evaluate their accuracy, and understand when to use each. Build the skills to compare models and choose the best one for your data.

Discover how the k-nearest neighbors algorithm makes predictions based on similarity. Learn to handle multiple features, tune parameters, and apply cross-validation to improve accuracy.

Understand how logistic regression models probabilities and classifies outcomes. Practice implementing it, interpreting decision boundaries, and applying regularization to prevent overfitting.

Learn how decision trees split data into meaningful groups based on feature values. Explore how parameters like tree depth and minimum samples per leaf affect model performance and generalization.

Explore how random forests combine multiple decision trees to improve accuracy and robustness. Understand the role of randomness and apply this ensemble method to real-world data.

Evaluate models using metrics such as accuracy, precision, recall, and F1-score. Learn to interpret confusion matrices and compare multiple classifiers to identify the best-performing model.

Challenge: Implementing a Random Forest

解答