En este desafío, se proporciona el conocido conjunto de datos de viviendas, pero esta vez únicamente con la característica `'age'`.

import pandas as pd

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b22d1166-efda-45e8-979e-6c3ecfc566fc/houses_poly.csv')
print(df.head())

A continuación, se creará un diagrama de dispersión para estos datos:

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/b22d1166-efda-45e8-979e-6c3ecfc566fc/houses_poly.csv')
X = df['age']
y = df['price']
plt.scatter(X, y, alpha=0.4)
plt.show()

Una línea recta es una mala aproximación aquí: los precios aumentan tanto para casas muy nuevas como para casas muy antiguas. Una parábola modela mejor esta tendencia; eso es lo que se construirá en este desafío.

import unittest
import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression


# Codefinity helper for dynamic names
def _dynamic_test(test_case, condition, ok_msg, fail_msg):
    if condition:
        test_case._testMethodName = ok_msg
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = fail_msg
        test_case.fail(fail_msg)


class TestUserCode(unittest.TestCase):

    # 1. X contains only "age"
    def test_X_contains_age(self):
        import user_code

        cond = False
        try:
            X = user_code.X
            cond = isinstance(X, pd.DataFrame) and list(X.columns) == ["age"]
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "X is correctly assigned from the 'age' column.",
            "Expected X = df[['age']]."
        )

    # 2. PolynomialFeatures used correctly
    def test_X_poly_preprocessing(self):
        import user_code

        cond = False
        try:
            X = user_code.X
            n = user_code.n
            X_poly = user_code.X_poly

            # Re-create expected transformation
            poly = PolynomialFeatures(n)
            expected = poly.fit_transform(X)

            cond = (
                isinstance(X_poly, np.ndarray)
                and X_poly.shape == expected.shape
                and np.allclose(X_poly, expected)
            )
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "X_poly is correctly generated using PolynomialFeatures.",
            "Expected X_poly = poly.fit_transform(X)."
        )

    # 3. Model is LinearRegression and is fitted
    def test_model_fitted(self):
        import user_code

        cond = False
        try:
            model = user_code.model
            cond = isinstance(model, LinearRegression) and hasattr(model, "coef_")
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "The model is a fitted LinearRegression instance.",
            "Expected model = LinearRegression() and model.fit()."
        )

    # 4. X_new reshaped to 2D array
    def test_X_new_shape(self):
        import user_code

        cond = False
        try:
            X_new = user_code.X_new
            cond = isinstance(X_new, np.ndarray) and len(X_new.shape) == 2 and X_new.shape[1] == 1
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "X_new is correctly reshaped to (-1, 1).",
            "Expected X_new = np.linspace(...).reshape(-1, 1)."
        )

    # 5. X_new_poly transformed correctly
    def test_X_new_poly_transform(self):
        import user_code

        cond = False
        try:
            X_new = user_code.X_new
            X_new_poly = user_code.X_new_poly
            poly = user_code.poly

            expected = poly.transform(X_new)

            cond = (
                isinstance(X_new_poly, np.ndarray)
                and np.allclose(X_new_poly, expected)
            )
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "X_new_poly is correctly transformed using the fitted poly instance.",
            "Expected X_new_poly = poly.transform(X_new)."
        )

    # 6. Check print statements logic (intercept_ and coef_)
    def test_params_printed(self):
        cond = False
        try:
            with open("user_code.py", "r") as f:
                src = f.read().replace(" ", "")
            cond = "model.intercept_" in src and "model.coef_" in src
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "Model intercept and coefficients are printed.",
            "Expected printing model.intercept_ and model.coef_."
        )


if __name__ == "__main__":
    unittest.main()

test_code.py

Domina los algoritmos fundamentales del aprendizaje supervisado e impleméntalos utilizando Scikit-learn. Explora la regresión lineal y polinómica para la predicción de precios, y avanza hacia la clasificación mediante k-NN, Regresión Logística y Árboles de Decisión. Aprende a evaluar modelos mediante validación cruzada, gestionar el sobreajuste con regularización y optimizar hiperparámetros. Construye sistemas predictivos robustos y define límites de decisión complejos para tareas de clasificación multiclase.

Desafío: Evaluación del Modelo

Solución

Desafío: Evaluación del Modelo

Solución