Fundamentos de estadística inferencial

1

Estadística Inferencial para Ciencia de Datos e IA

2

Componentes Básicos de la Estadística

3

Distribución Normal: Conceptos y Ejemplos Prácticos

4

Tipos de Muestreo y Teorema del Límite Central

5

Funciones de muestra en Python: aleatorio y sistemático

6

Muestreo Estratificado: Creación y Aplicación en Python

Quiz: Fundamentos de estadística inferencial

Estadísticos y cálculos

7

Cálculo de la Media Muestral y Conceptos de Estadística Básica

8

Diferencias entre varianza y desviación estándar muestral y poblacional

9

Varianza y Desviación Estándar Automatizadas en Python

10

Intervalos de Confianza en Estadística y Ciencia de Datos

11

Cálculo de Intervalos de Confianza paso a paso

12

Cálculo y visualización de intervalos de confianza en Python

Quiz: Estadísticos y cálculos

Pruebas de hipótesis y validación

13

Pruebas de Hipótesis en Ciencia de Datos e Inteligencia Artificial

14

Pruebas de Hipótesis: Test-Student, Pearson y ANOVA

15

Errores Tipo I y II en Pruebas de Hipótesis

16

Pruebas de Hipótesis con Python: Distribución t de Student

17

Análisis de Correlación y ANOVA en Python

18

Técnica de Bootstrapping para Muestras Pequeñas

19

Bootstrapping y Remuestreo en Python: Automatización Práctica

20

Validación Cruzada en Modelos de Inteligencia Artificial

21

Automatización de Validación Cruzada en Python para Modelos Predictivos

Quiz: Pruebas de hipótesis y validación

Cierre del curso

22

Estadística para Ciencia de Datos y Machine Learning

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Automatización de Validación Cruzada en Python para Modelos Predictivos

21/22
Recursos

¿Cómo manejar la validación cruzada en Python?

La validación cruzada es una herramienta poderosa para verificar qué tan preciso es tu modelo de machine learning. En esta guía, te explicaremos cómo automatizar este proceso utilizando Python. Asegúrate de tener tu notebook de preferencia listo, ya sea Jupyter Notebook o Google Colab, donde se realizará el código.

¿Cómo configurar tus librerías y datos?

Lo primero es importar las librerías necesarias para tu análisis. Necesitarás pandas y numpy para manipulación de datos, así como módulos para importar archivos desde tu dispositivo local, especialmente si usas Google Colab. Aquí te mostramos cómo configurarlo:

import pandas as pd
import numpy as np
from google.colab import files

uploaded = files.upload()
data_path = 'cancerdata.csv'
data = pd.read_csv(data_path)
print(data.head())

En este ejemplo, utilizamos un archivo de Kaggle acerca de cáncer de mama, fundamental para nuestras predicciones, que descargamos y cargamos al notebook.

¿Cómo definir las variables para tu modelo?

Es esencial identificar y separar tus variables predictoras (X) de la variable objetivo (Y). Normalmente, las variables X son numéricas y la Y es categórica. Para identificarlo adecuadamente:

X = data.iloc[:, 2:].values  # Variables numéricas desde la tercera columna
Y = data.iloc[:, 1].values   # Diagnóstico que puede ser maligno (M) o benigno (B)
print(X[:5])
print(np.unique(Y, return_counts=True))

Aquí, clasificamos las variables para asegurar que nuestros datos se importen correctamente y cuenten con una representación equilibrada de cada categoría.

¿Cómo dividir los datos para entrenamiento y prueba?

Antes de entrenar el modelo, es importante realizar una división entre datos de entrenamiento y de prueba. Para esto, se utiliza la librería Scikit-learn:

from sklearn.model_selection import train_test_split

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3, random_state=4)

Esta división permite evaluar el modelo en un conjunto de datos que no ha visto durante el entrenamiento, simulando así un escenario más realista.

¿Cómo construir y evaluar tu modelo con Scikit-learn?

Vamos a utilizar un árbol de decisión para esta tarea. Una vez configurado, evaluaremos su rendimiento con métricas de precisión:

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier(random_state=4)
model.fit(X_train, Y_train)
accuracy = model.score(X_test, Y_test)
print(f"Model Accuracy: {accuracy*100:.2f}%")

Los resultados indicarán qué tan bien tu modelo puede predecir la variable objetivo.

¿Qué es la validación cruzada y cómo implementarla?

La validación cruzada tipo K-Folds es un método que estructura los datos de forma que se utilicen múltiples divisiones de entrenamiento y prueba. Esto previene el sobreajuste y ofrece un promedio confiable de rendimiento:

from sklearn.model_selection import cross_val_score, KFold

kf = KFold(n_splits=10, random_state=4, shuffle=True)
cv_results = cross_val_score(model, X, Y, cv=kf)
print(f"Cross-validation mean accuracy: {cv_results.mean()*100:.2f}%")

Este proceso utiliza varias divisiones para calcular un promedio y ofrece una evaluación más robusta de la capacidad predictiva del modelo.

En resumen, este flujo de trabajo no solo permite evaluar la precisión de tu modelo inicial, sino que también te proporciona una validación exhaustiva mediante técnicas avanzadas, asegurando que tu modelo esté bien calibrado antes de implementarlo en situaciones reales. Sigue perfeccionando tus habilidades de machine learning, ya que herramientas como esta son clave para desarrollar modelos predictivos precisos y confiables.

Aportes 33

Preguntas 5

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Los árboles de decisión te dejan con una decisión difícil (#jajajajajaja no jodas#)… Un árbol profundo con muchas hojas se ajustará demasiado porque cada predicción proviene de datos históricos de solo las pocas casas en su hoja. Pero un árbol poco profundo con pocas hojas tendrá un desempeño deficiente porque no logra capturar tantas distinciones en los datos sin procesar.

Incluso las técnicas de modelado más sofisticadas de la actualidad se enfrentan a esta tensión entre el ajuste insuficiente y el ajuste excesivo. Sin embargo, muchos modelos tienen ideas inteligentes que pueden conducir a un mejor rendimiento. Veremos el bosque aleatorio como ejemplo.

El bosque aleatorio usa muchos árboles y hace una predicción promediando las predicciones de cada árbol componente. Por lo general, tiene una precisión predictiva mucho mejor que un árbol de decisión único y funciona bien con los parámetros predeterminados. Si continúa modelando, puede aprender más modelos con un rendimiento aún mejor, pero muchos de ellos son sensibles para obtener los parámetros correctos.

from sklearn.ensemble import RandomForestClassifier
modelo = RandomForestClassifier()
modelo.fit(train_X, train_y)
resultado = modelo.score(test_X, test_y)
print(resultado) 

Con este codigo obtendran valores cercanos al 96% o 97%.

Comunidad! Les comparto los apuntes que tome de esta clase en Deepnote. Tambien lo complemente con otros artículos y videos disponibles en internet.

Hola, no sé muy bien porqué pero al descargar el dataset desde Kaggle me aparecía una columna al final que creo que no aparece en la clase:

Por este motivo me daba un error al intentar imprimir el resultado. Lo solucione excluyendo esta columna de la variable X:

X = df.iloc[:,2:32]

Si alguien más tiene este problema espero que esto les pueda ayudar. 😃

La validación cruzada es muy potente cuando usamos hiperparámetros en nuestros modelos, ya que aumenta la precisión considerablemente. Sin embargo es buena práctica balancear los datos, ya que en la vida real pasa siempre que tenemos una clase mayoritaria.
La evalución con una matriz de decisión es sumamente importante para detetectar falsos positivos y faltos negativos en nuestro modelo.

overfitting: hold-out vs cross-validation

El overfitting sucede cuando tu modelo se vuelve muy exacto al predecir datos con los que fue entrenado y no puede generalizar, cuando se le presentan nuevas muestras que nunca ha visto.
Este problema se soluciona con 2 técnicas:
hold-out: partir el dataset en una proporción para el entrenamiento y otra para las pruebas.
cross-validation: al igual que el de atrás se hacen particiones para el training y el test, pero en este caso se llevan a cabo varias pruebas con diferentes particiones, haciendo más eficiente este método que el anterior.
Esta clase me gusto mucho ya que abarcan estos dos métodos para evitar el overfitting.
les recomiendo esta lectura:
https://medium.com/@eijaz/holdout-vs-cross-validation-in-machine-learning-7637112d3f8f

y DEBEN ver este buen video de DOTCSV donde explica el problema del overfitting:
https://www.youtube.com/watch?v=7-6X3DTt3R8

El dataframe tiene como ultima columna datos no numericos, asi que si sigues los pasos de la profesora el modelo va darte un error, para arreglarlo simplemente pon en la declaracion de x:

X = df.iloc[:,2:(df.shape[1]-1)]

Combinando el aporte de Felix para balancear los datos y el aporte de Alfonso para crear un bosque de árboles y no un único árbol obtengo un Score del 99.45%

Es genial cómo aplicando varios conceptos los modelos son mucho mejores y eso que no apliqué hiperparametros.

Faltaría un ejemplo balanceado los datos, dado que en el mundo real las cosas no son como en Kaggle (Ejemplos limpios)

Un aporte un poco purista. Silvia dice “accuracy” y “precisión”, como si fueran lo mismo. Sin embargo, estos conceptos no son lo mismo. Mientras que accuracy (traducción: exactitud) significa qué tan cercano es un modelo a la realidad, precision (traducción: precisión) se refiere a que tan similares son un conjunto de datos. En este caso, la validación cruzada busca analizar qué tan “precisos” y no “accurate” o exactos son un conjunto de datos.

Estos fueron los míos y fueron resultados muy buenos:
[0.89473684 0.9122807 0.87719298 0.9122807 0.9122807 0.98245614
0.9122807 0.96491228 0.92982456 0.92857143]
0.9226817042606517

En el nuevo csv de Kaggle añaden una columna ‘Unnamed:32’ si bien pueden hacer un drop de ella pues solo contiene valores NaN, también podrían no contar la ultima columna.

X = df.iloc[:, 2:-1]
Y = df.iloc[:,1]
Los resultados de la validación cruzada ![](https://static.platzi.com/media/user_upload/image-1b82bd3c-65ca-4ff4-afd9-509a844c0f5f.jpg)
Les comparto el código para importar el dataset directo del sitio, sin necesidad de descargar nada, usando la api de kaggle: ```js import kagglehub # url Kaggle: https://www.kaggle.com/datasets/uciml/breast-cancer-wisconsin-data # Download latest version path = kagglehub.dataset_download("uciml/breast-cancer-wisconsin-data") print("Path to dataset files:", path) df = pd.read_csv(path + "/data.csv") df.head() ```import kagglehub# url Kaggle: <https://www.kaggle.com/datasets/uciml/breast-cancer-wisconsin-data#> Download latest versionpath = kagglehub.dataset\_download("uciml/breast-cancer-wisconsin-data") print("Path to dataset files:", path) df = pd.read\_csv(path + "/data.csv")df.head()
buena clase, entendido todo!
Ejercicio: ![](https://static.platzi.com/media/user_upload/image-42f7a21f-3a23-41e8-94f7-ab8eddf4f123.jpg)

Esta clase se acerca un poco a machine learning. Excepto con la parte de validacion cruzada que esta interesante. Aqui comparto mis resultados:
![](

Sílvia muchas gracias por compartir tus conocimientos, me aclararon muchas cosas que tenía pendientes

Mis resultados:

Estos son mis resultados: \[0.94736842 0.9122807 0.9122807 0.9122807 0.89473684 0.98245614 0.9122807 0.98245614 0.96491228 0.92857143] 0.9349624060150376

Siento que necesito repasar más estos conceptos y aplicaciones, ya que del todo no me han quedado claros, de igual manera excelente clase!

Creo que de las clases más interesantes que he tenido hasta ahora jejee

Si, mis valores son cercanos al 100%:[0.94736842 0.9122807 0.85964912 0.94736842 0.9122807 0.98245614
0.9122807 0.94736842 0.92982456 0.92857143]
0.9279448621553884, mi modelo también está validado

Mis resultados:
[0.94736842 0.9122807 0.87719298 0.9122807 0.92982456 0.98245614
0.9122807 0.98245614 0.92982456 0.92857143]
0.9314536340852131

Aunque son muy buenos los resultados, un accuracy >=90% nos habla sobre la presencia de overfit, lo que indica que el modelo no es capaz de generalizar, esto representa un problema si en un futuro al modelo se le presentan datos nuevos.

Tuve muy buenos resultados y de verdad me motiva a estudiar más
[0.98245614 0.9122807 0.9122807 0.96491228 0.92982456 0.96491228
0.9122807 0.98245614 0.98245614 0.89285714]

Mis resultados

[0.9122807  0.9122807  0.89473684 0.94736842 0.94736842 0.98245614
 0.9122807  0.94736842 0.94736842 0.94642857]
0.9349937343358394

Mis resulados de la clase

[0.94736842 0.9122807  0.87719298 0.94736842 0.9122807  0.98245614
 0.9122807  0.96491228 0.92982456 0.94642857]
0.9332393483709274

Resumen de la clase

  • En Python, se puede utilizar la librería “Scikit-learn” para implementar la validación cruzada. La clase “KFold” de esta librería se utiliza para dividir los datos en “folds” y luego se puede utilizar el método “cross_val_score” para entrenar y evaluar el modelo en cada fold.

  • Por ejemplo, si se quiere hacer una validación cruzada K-fold con k=5 en un modelo de regresión lineal, se puede utilizar el siguiente código:

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score

# Crear el objeto del modelo
model = LinearRegression()

# Crear el objeto de validación cruzada K-fold
kfold = KFold(n_splits=5, shuffle=True, random_state=0)

# Evaluar el modelo utilizando validación cruzada
scores = cross_val_score(model, X, y, cv=kfold)

# Imprimir los resultados
print("Accuracy: %.2f%% (%.2f%%)" % (scores.mean()*100, scores.std()*100))

  • En este ejemplo, X es el conjunto de datos de entrada y y es el conjunto de datos objetivo. El parámetro “n_splits” es el número de divisiones a realizar, el parámetro “shuffle” indica si los datos deben ser mezclados antes de ser divididos, y el parámetro “random_state” es utilizado para establecer una semilla aleatoria.

La función cross_val_score devuelve un array con las puntuaciones obtenidas en cada fold, y se pueden calcular estadísticas como la media y la desviación estándar para evaluar el rendimiento del modelo.

Mi aporte como quedó:

#imprimir los promedios de los 10 primeros registros con la validacion cruzada y que luego imprima un promedio global
from sklearn.model_selection import cross_val_score

resultados = cross_val_score(modelo,x,y,cv = KFold_validacion)# con KFOLD se ponderan los promedios
print("Los promedios se desglosan así:", resultados) 
print("Se imprime el promedio general:", resultados.mean())#media o promedio

Los promedios se desglosan así: [0.94736842 0.9122807 0.9122807 0.94736842 0.89473684 0.96491228
0.9122807 0.94736842 0.92982456 0.94642857]
Se imprime el promedio general: 0.931484962406015

Hola Comunidad, les comparto mis resultados:
[0.92982456 0.9122807 0.87719298 0.96491228 0.89473684 0.98245614
0.9122807 0.94736842 0.94736842 0.91071429]
0.9279135338345865

Si quieren entender mejor el parametro Random State, les dejo este link de stackoverflow que lo explica muy bien: https://stackoverflow.com/questions/67186677/why-random-state-differs-in-test-train-split-of-scikit-learn

Los míos 😃
[0.96491228 0.9122807 0.87719298 0.94736842 0.94736842 0.98245614
0.89473684 0.96491228 0.94736842 0.92857143]
0.93671679197995

Mis resultados:

[0.89473684 0.9122807 0.87719298 0.94736842 0.89473684 0.98245614
0.89473684 0.94736842 0.92982456 0.89285714]

0.9173558897243106

Estos son mis resultados, un poco mas bajo el promedio pero bueno igual

[0.9122807 0.9122807 0.89473684 0.94736842 0.9122807 0.96491228
0.9122807 0.96491228 0.94736842 0.91071429]
0.9279135338345865