mirror of
https://github.com/CristianCruz0309/Curso_Fundamentos_IA_Machine_Learning.git
synced 2026-08-15 03:00:16 +00:00
913 lines
34 KiB
Plaintext
913 lines
34 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "o1NsPEpBa4ud"
|
|
},
|
|
"source": [
|
|
"# **Clase 1**\n",
|
|
"\n",
|
|
"## Aprendizaje Supervisado - Clasificación"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "VT6cbjCTZ8_5"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"# Paso 1: Importar las bibliotecas necesarias\n",
|
|
"from sklearn.datasets import load_iris\n",
|
|
"from sklearn.model_selection import train_test_split\n",
|
|
"from sklearn.tree import DecisionTreeClassifier\n",
|
|
"from sklearn.metrics import accuracy_score\n",
|
|
"\n",
|
|
"# Paso 2: Cargar el dataset Iris\n",
|
|
"iris = load_iris()\n",
|
|
"X = iris.data # Caracteristicas (largo y ancho de pétalos y sépalos)\n",
|
|
"y = iris.target # Rótulos (especies de flores)\n",
|
|
"\n",
|
|
"# Paso 3: Dividir los datos para entrenamiento y para prueba\n",
|
|
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
|
|
"\n",
|
|
"# Paso 4: Entrenar el modelo\n",
|
|
"model = DecisionTreeClassifier()\n",
|
|
"model.fit(X_train, y_train)\n",
|
|
"\n",
|
|
"# Paso 5: Realizar previsiones y evaluar el modelo\n",
|
|
"y_pred = model.predict(X_test)\n",
|
|
"accuracy = accuracy_score(y_test, y_pred)\n",
|
|
"print(f\"Exactitud del modelo: {accuracy * 100:.2f}%\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "y25Wl-P7bMjB"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"# Paso 1: Importar las bibliotecas necesarias\n",
|
|
"from sklearn.tree import DecisionTreeClassifier\n",
|
|
"from sklearn.neighbors import KNeighborsClassifier\n",
|
|
"from sklearn.model_selection import train_test_split\n",
|
|
"from sklearn.metrics import accuracy_score\n",
|
|
"from sklearn.preprocessing import StandardScaler\n",
|
|
"from sklearn.datasets import load_iris\n",
|
|
"import pandas as pd\n",
|
|
"\n",
|
|
"# Paso 2: Cargar y preparar el dataset Iris\n",
|
|
"dataset = load_iris()\n",
|
|
"df = pd.DataFrame(dataset.data, columns=dataset.feature_names)\n",
|
|
"df['species'] = dataset.target\n",
|
|
"\n",
|
|
"# Paso 3: Normalizar los datos\n",
|
|
"scaler = StandardScaler()\n",
|
|
"X_scaled = scaler.fit_transform(df.drop(columns=['species']))\n",
|
|
"\n",
|
|
"# Paso 4: Dividir los datos en entrenamiento y prueba\n",
|
|
"X_train, X_test, y_train, y_test = train_test_split(X_scaled, df['species'], test_size=0.3, random_state=42)\n",
|
|
"\n",
|
|
"# Paso 5: Entrenar y evaluar el árbol de decisión\n",
|
|
"tree_model = DecisionTreeClassifier()\n",
|
|
"tree_model.fit(X_train, y_train)\n",
|
|
"tree_accuracy = accuracy_score(y_test, tree_model.predict(X_test))\n",
|
|
"print(f\"Exactitud del modelo de Árbol de Decisión: {tree_accuracy * 100:.2f}%\")\n",
|
|
"\n",
|
|
"# Paso 6: Entrenar y evaluar el KNN\n",
|
|
"knn_model = KNeighborsClassifier()\n",
|
|
"knn_model.fit(X_train, y_train)\n",
|
|
"knn_accuracy = accuracy_score(y_test, knn_model.predict(X_test))\n",
|
|
"print(f\"Exactitud del modelo KNN: {knn_accuracy * 100:.2f}%\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "j-gTcWAkgMKQ"
|
|
},
|
|
"source": [
|
|
"## Aprendizaje Supervisado - Regresión"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "HTqkVk2kgXIW"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"# Importando bibliotecas\n",
|
|
"import numpy as np\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"from sklearn.linear_model import LinearRegression\n",
|
|
"from sklearn.model_selection import train_test_split, cross_val_score\n",
|
|
"from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
|
|
"\n",
|
|
"# Creando un conjunto de datos simulados\n",
|
|
"np.random.seed(42)\n",
|
|
"X = 2.5 * np.random.randn(100, 1) + 25 # Tamaño del inmueble (m2)\n",
|
|
"y = 500 + (X * 20) + np.random.randn(100, 1) * 10 # Precio del inmueble (miles de dólares)\n",
|
|
"\n",
|
|
"# Definiendo features (independientes) y labels (dependientes)\n",
|
|
"features = X\n",
|
|
"labels = y\n",
|
|
"\n",
|
|
"# Dividiendo los datos en entrenamiento y prueba\n",
|
|
"X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)\n",
|
|
"\n",
|
|
"# Creando y entrenando el modelo\n",
|
|
"model = LinearRegression()\n",
|
|
"model.fit(X_train, y_train)\n",
|
|
"\n",
|
|
"#Modelo de Regresión lineal\n",
|
|
"# Y = A X + B\n",
|
|
"# Y -> Variable de salida\n",
|
|
"# X -> Tamaño del inmueble\n",
|
|
"# A y B son los coeficientes\n",
|
|
"\n",
|
|
"# Coeficientes de Regresión\n",
|
|
"print(f\"Coeficiente angular (b1): {model.coef_[0][0]:.2f}\")\n",
|
|
"print(f\"Intercepto (b0): {model.intercept_[0]:.2f}\")\n",
|
|
"\n",
|
|
"# Predicciones con los datos de prueba\n",
|
|
"y_pred = model.predict(X_test)\n",
|
|
"\n",
|
|
"# Indicadores de la Evaluación del modelo con los datos de prueba\n",
|
|
"#R² Ajuste de los datos al modelo\n",
|
|
"r2 = r2_score(y_test, y_pred)\n",
|
|
"#MAE (Error Medio Absoluto)\n",
|
|
"mae = mean_absolute_error(y_test, y_pred)\n",
|
|
"#RMSE (Raíz del error Cuadrático Medio)\n",
|
|
"rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
|
|
"\n",
|
|
"print(f\"\\nMétricas de Evaluación:\")\n",
|
|
"print(f\"R² en datos de prueba: {r2:.2f}\")\n",
|
|
"print(f\"Erro Medio Absoluto (MAE): {mae:.2f}\")\n",
|
|
"print(f\"Raíz del Error Cuadrático Medio (RMSE): {rmse:.2f}\")\n",
|
|
"\n",
|
|
"# Evaluación cruzada\n",
|
|
"cv_scores = cross_val_score(model, features, labels, cv=5, scoring='r2')\n",
|
|
"print(f\"\\nPromedio de los puntajes de la validación cruzada: {cv_scores.mean():.2f}\")\n",
|
|
"\n",
|
|
"# Gráfico de la recta de Regresión\n",
|
|
"plt.figure(figsize=(8, 6))\n",
|
|
"plt.scatter(X_test, y_test, color='blue', label='Datos reales')\n",
|
|
"plt.plot(X_test, y_pred, color='red', linewidth=2, label='Regresión Lineal')\n",
|
|
"plt.xlabel(\"Tamaño del Inmueble\")\n",
|
|
"plt.ylabel(\"Precio del Inmueble\")\n",
|
|
"plt.title(\"Regresión Lineal: Precio x Tamaño del Inmueble\")\n",
|
|
"plt.legend()\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "LRndTZuznABT"
|
|
},
|
|
"source": [
|
|
"# **Actividad - Clase 1**"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "MJ74jCXInKMv"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"import numpy as np\n",
|
|
"import pandas as pd\n",
|
|
"from sklearn import datasets\n",
|
|
"from sklearn.model_selection import train_test_split, cross_val_score\n",
|
|
"from sklearn.tree import DecisionTreeClassifier\n",
|
|
"from sklearn.metrics import accuracy_score\n",
|
|
"\n",
|
|
"# Cargar el dataset Iris de la biblioteca sklearn\n",
|
|
"dataset = datasets.load_iris()\n",
|
|
"\n",
|
|
"# Convertir a DataFrame de Pandas para facilitar la manipulación de los datos\n",
|
|
"df = pd.DataFrame(data=dataset.data, columns=dataset.feature_names)\n",
|
|
"df['target'] = dataset.target # Agregar la columna con las clases de las flores\n",
|
|
"\n",
|
|
"# Separar los atributos (X) y las etiquetas (y)\n",
|
|
"X = df.iloc[:, :-1] # Todas las columnas excepto la última\n",
|
|
"y = df['target'] # Última columna, que contiene las clases\n",
|
|
"\n",
|
|
"# Dividir los datos en conjunto de entrenamiento y prueba (80% entrenamiento, 20% prueba)\n",
|
|
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
|
|
"\n",
|
|
"# Crear y entrenar un modelo de Árbol de Decisión\n",
|
|
"model = DecisionTreeClassifier(random_state=42)\n",
|
|
"model.fit(X_train, y_train)\n",
|
|
"\n",
|
|
"# Hacer predicciones en los datos de prueba\n",
|
|
"y_pred = model.predict(X_test)\n",
|
|
"\n",
|
|
"# Evaluar el rendimiento del modelo\n",
|
|
"accuracy = accuracy_score(y_test, y_pred)\n",
|
|
"print(f'Precisión del modelo: {accuracy:.2f}')\n",
|
|
"\n",
|
|
"# Aplicar validación cruzada para mejor evaluación del rendimiento\n",
|
|
"cross_val_scores = cross_val_score(model, X, y, cv=5)\n",
|
|
"print(f'Precisión media en la validación cruzada: {cross_val_scores.mean():.2f}')\n",
|
|
"\n",
|
|
"# Probar con una nueva muestra\n",
|
|
"nueva_muestra = np.array([[5.1, 3.5, 1.4, 0.2]]) # Ejemplo de medidas de una flor\n",
|
|
"prediccion = model.predict(nueva_muestra)\n",
|
|
"print(f'Clase prevista para la nueva muestra: {dataset.target_names[prediccion[0]]}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "5jAzFN36nfL8"
|
|
},
|
|
"source": [
|
|
"# **Clase 2**\n",
|
|
"\n",
|
|
"## Ejemplos de Clasificación y Regresión"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "4tp9L9dHnpL7"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"from sklearn.datasets import fetch_california_housing\n",
|
|
"\n",
|
|
"california = fetch_california_housing()\n",
|
|
"df = pd.DataFrame(california.data, columns=california.feature_names)\n",
|
|
"df['PRICE'] = california.target\n",
|
|
"\n",
|
|
"# Ver las primeras 5 filas de los datos\n",
|
|
"df.head()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "-e69_ZAZo8QH"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"import numpy as np\n",
|
|
"import pandas as pd\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"import seaborn as sns\n",
|
|
"from sklearn.linear_model import LinearRegression\n",
|
|
"from sklearn.model_selection import train_test_split\n",
|
|
"from sklearn.metrics import mean_squared_error, r2_score\n",
|
|
"from sklearn.datasets import fetch_california_housing\n",
|
|
"\n",
|
|
"# Cargar el conjunto de datos\n",
|
|
"california = fetch_california_housing()\n",
|
|
"df = pd.DataFrame(california.data, columns=california.feature_names)\n",
|
|
"df['PRICE'] = california.target\n",
|
|
"\n",
|
|
"# Dividir los datos en datos de entrenamiento y de prueba\n",
|
|
"X = df.drop('PRICE', axis=1)\n",
|
|
"y = df['PRICE']\n",
|
|
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
|
|
"\n",
|
|
"# Entrenar el modelo\n",
|
|
"model = LinearRegression()\n",
|
|
"model.fit(X_train, y_train)\n",
|
|
"\n",
|
|
"# Realizar la prevision\n",
|
|
"y_pred = model.predict(X_test)\n",
|
|
"\n",
|
|
"# Evaluar el modelo\n",
|
|
"mse = mean_squared_error(y_test, y_pred)\n",
|
|
"r2 = r2_score(y_test, y_pred)\n",
|
|
"\n",
|
|
"# Exhibir las métricas\n",
|
|
"print(f'Error Cuadrático Medio (MSE): {mse:.2f}')\n",
|
|
"print(f'Coeficiente de Determinación (R²): {r2:.2f}')\n",
|
|
"\n",
|
|
"# Visualización de los resultados\n",
|
|
"plt.figure(figsize=(10, 6))\n",
|
|
"sns.scatterplot(x=y_test, y=y_pred, alpha=0.6)\n",
|
|
"plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], '--r', linewidth=2) # Línea de referencia\n",
|
|
"plt.xlabel(\"Valores Reales\")\n",
|
|
"plt.ylabel(\"Valores Previstos\")\n",
|
|
"plt.title(\"Regresión Lineal: Valores Reales vs. Previstos\")\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "jDuKdCemqg8a"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"from sklearn.datasets import load_diabetes\n",
|
|
"\n",
|
|
"# Cargar los datos\n",
|
|
"diabetes = load_diabetes()\n",
|
|
"df = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)\n",
|
|
"\n",
|
|
"# Ver las primeras 5 filas de los datos\n",
|
|
"df.head()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "x4kqRlbnrBuK"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"from sklearn.linear_model import LogisticRegression\n",
|
|
"from sklearn.model_selection import train_test_split\n",
|
|
"from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"\n",
|
|
"# Cargar los datos\n",
|
|
"diabetes = load_diabetes()\n",
|
|
"df = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)\n",
|
|
"df['OUTCOME'] = diabetes.target\n",
|
|
"\n",
|
|
"# Transformar la variable target en binaria (clasificación)\n",
|
|
"df['OUTCOME'] = (df['OUTCOME'] > df['OUTCOME'].median()).astype(int) # 1 cuando es superior a la mediana, y 0 cuando es inferior\n",
|
|
"\n",
|
|
"# Dividir los datos en datos de entrenamiento y datos de prueba\n",
|
|
"X = df.drop('OUTCOME', axis=1)\n",
|
|
"y = df['OUTCOME']\n",
|
|
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
|
|
"\n",
|
|
"# Entrenar el modelo\n",
|
|
"model = LogisticRegression(max_iter=1000) # Aumentando las iteraciones para evitar warnings\n",
|
|
"model.fit(X_train, y_train)\n",
|
|
"\n",
|
|
"# Realizar la Previsión\n",
|
|
"y_pred = model.predict(X_test)\n",
|
|
"\n",
|
|
"# Evaluar el modelo\n",
|
|
"accuracy = accuracy_score(y_test, y_pred)\n",
|
|
"print(f'Exactitud del Modelo: {accuracy * 100:.2f}%')\n",
|
|
"\n",
|
|
"# Matriz de Confusión\n",
|
|
"cm = confusion_matrix(y_test, y_pred)\n",
|
|
"disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['No Diabético', 'Diabético'])\n",
|
|
"disp.plot(cmap=plt.cm.Blues)\n",
|
|
"plt.title(\"Matriz de Confusión - Diagnóstico de Diabetes\")\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "w4rB2bbpxN7C"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"from sklearn.datasets import fetch_california_housing\n",
|
|
"from sklearn.model_selection import train_test_split, GridSearchCV\n",
|
|
"from sklearn.tree import DecisionTreeRegressor\n",
|
|
"\n",
|
|
"# Cargar dataset\n",
|
|
"X, y = fetch_california_housing(return_X_y=True)\n",
|
|
"\n",
|
|
"# Dividir en datos de entrenamiento y datos de prueba\n",
|
|
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
|
|
"\n",
|
|
"# Definir los hiperparámetros para optimizarlos\n",
|
|
"param_grid = {\n",
|
|
" 'max_depth': [3, 5, 7, 10],\n",
|
|
" 'min_samples_split': [2, 5, 10],\n",
|
|
" 'min_samples_leaf': [1, 2, 4]\n",
|
|
"}\n",
|
|
"\n",
|
|
"# Aplicar GridSearchCV para encontrar los mejores hiperparámetros\n",
|
|
"grid_search = GridSearchCV(DecisionTreeRegressor(), param_grid, cv=5, scoring='neg_mean_squared_error')\n",
|
|
"grid_search.fit(X_train, y_train)\n",
|
|
"\n",
|
|
"# GridSearchCV -> Realiza la búsqueda de los mejores hiperparámetros combinando todos los valores de hiperparámetros\n",
|
|
"# Métrica de evaluación -> Error Cuadrático Medio Negativo\n",
|
|
"print(f'Mejores parámetros: {grid_search.best_params_}')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"id": "sEAcrFpL2f_a"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"# Importar bibliotecas\n",
|
|
"import pandas as pd\n",
|
|
"from sklearn.datasets import load_diabetes\n",
|
|
"from sklearn.model_selection import train_test_split\n",
|
|
"from sklearn.ensemble import RandomForestRegressor\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"\n",
|
|
"# Cargar el dataset Diabetes\n",
|
|
"diabetes = load_diabetes()\n",
|
|
"X = diabetes.data # Variables independientes\n",
|
|
"y = diabetes.target # Variable dependiente\n",
|
|
"\n",
|
|
"# Dividir los datos para entrenamiento y para prueba (70% treino, 30% teste)\n",
|
|
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
|
|
"\n",
|
|
"# Crear y entrenar el modelo RandomForestRegressor\n",
|
|
"model = RandomForestRegressor()\n",
|
|
"model.fit(X_train, y_train)\n",
|
|
"\n",
|
|
"# Obtener la importancia de los atributos\n",
|
|
"importances = model.feature_importances_\n",
|
|
"feature_names = diabetes.feature_names\n",
|
|
"\n",
|
|
"# Crear un gráfico de barras para visualizar la importancia de los atributos\n",
|
|
"plt.figure(figsize=(10, 6))\n",
|
|
"plt.barh(feature_names, importances)\n",
|
|
"plt.title(\"Importancia de los Atributos\")\n",
|
|
"plt.xlabel(\"Importancia\")\n",
|
|
"plt.ylabel(\"Atributo\")\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"colab": {
|
|
"background_save": true
|
|
},
|
|
"id": "149LHIAXS0r9"
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"import numpy as np\n",
|
|
"import pandas as pd\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"import seaborn as sns\n",
|
|
"from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor\n",
|
|
"from sklearn.model_selection import train_test_split\n",
|
|
"from sklearn.metrics import mean_squared_error, r2_score\n",
|
|
"from sklearn.datasets import fetch_california_housing\n",
|
|
"\n",
|
|
"# Cargar el conjunto de datos\n",
|
|
"california = fetch_california_housing()\n",
|
|
"df = pd.DataFrame(california.data, columns=california.feature_names)\n",
|
|
"df['PRICE'] = california.target\n",
|
|
"\n",
|
|
"# Dividir los datos en entrenamiento y prueba\n",
|
|
"X = df.drop('PRICE', axis=1)\n",
|
|
"y = df['PRICE']\n",
|
|
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
|
|
"\n",
|
|
"# Crear y entrenar los modelos ensemble (Ensamblados)\n",
|
|
"rf_model = RandomForestRegressor(n_estimators=200, max_depth=10, random_state=42)\n",
|
|
"gb_model = GradientBoostingRegressor(n_estimators=200, learning_rate=0.05, max_depth=5, random_state=42)\n",
|
|
"rf_model.fit(X_train, y_train)\n",
|
|
"gb_model.fit(X_train, y_train)\n",
|
|
"\n",
|
|
"# Realizar previsiones\n",
|
|
"y_pred_rf = rf_model.predict(X_test)\n",
|
|
"y_pred_gb = gb_model.predict(X_test)\n",
|
|
"\n",
|
|
"# Evaluar los modelos\n",
|
|
"mse_rf = mean_squared_error(y_test, y_pred_rf)\n",
|
|
"r2_rf = r2_score(y_test, y_pred_rf)\n",
|
|
"mse_gb = mean_squared_error(y_test, y_pred_gb)\n",
|
|
"r2_gb = r2_score(y_test, y_pred_gb)\n",
|
|
"\n",
|
|
"# Exhibir métricas\n",
|
|
"print(f\"Random Forest - MSE: {mse_rf:.2f}, R²: {r2_rf:.2f}\")\n",
|
|
"print(f\"Gradient Boosting - MSE: {mse_gb:.2f}, R²: {r2_gb:.2f}\")\n",
|
|
"\n",
|
|
"# Visualizar los resultados\n",
|
|
"plt.figure(figsize=(12, 5))\n",
|
|
"plt.subplot(1, 2, 1)\n",
|
|
"sns.scatterplot(x=y_test, y=y_pred_rf, alpha=0.6)\n",
|
|
"plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], '--r', linewidth=2)\n",
|
|
"plt.xlabel(\"Valores Reales\")\n",
|
|
"plt.ylabel(\"Valores Previstos\")\n",
|
|
"plt.title(\"Random Forest\")\n",
|
|
"\n",
|
|
"plt.subplot(1, 2, 2)\n",
|
|
"sns.scatterplot(x=y_test, y=y_pred_gb, alpha=0.6, color='green')\n",
|
|
"plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], '--r', linewidth=2)\n",
|
|
"plt.xlabel(\"Valores Reales\")\n",
|
|
"plt.ylabel(\"Valores Previstos\")\n",
|
|
"plt.title(\"Gradient Boosting\")\n",
|
|
"\n",
|
|
"plt.show()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# **Clase 3**\n",
|
|
"## Aprendizaje No Supervisado - Clustering"
|
|
],
|
|
"metadata": {
|
|
"id": "-l7fn1ZChaHb"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"from sklearn.datasets import load_iris\n",
|
|
"import pandas as pd\n",
|
|
"from sklearn.cluster import KMeans\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"\n",
|
|
"# Cargar Dataset\n",
|
|
"iris = load_iris()\n",
|
|
"X = iris.data\n",
|
|
"\n",
|
|
"# Aplicar K-Means\n",
|
|
"kmeans = KMeans(n_clusters=3, random_state=42)\n",
|
|
"clusters = kmeans.fit_predict(X)\n",
|
|
"\n",
|
|
"# Visualizar los clusters\n",
|
|
"plt.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis')\n",
|
|
"plt.title(\"Agrupando con K-Means\")\n",
|
|
"plt.xlabel(\"Caracteristica 1\")\n",
|
|
"plt.ylabel(\"Caracteristica 2\")\n",
|
|
"plt.show()"
|
|
],
|
|
"metadata": {
|
|
"id": "IZ-lniPxhZcf"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"from sklearn.datasets import load_iris\n",
|
|
"import scipy.cluster.hierarchy as sch\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"from sklearn.preprocessing import StandardScaler\n",
|
|
"\n",
|
|
"# Cargar el dataset Iris\n",
|
|
"iris = load_iris()\n",
|
|
"X = iris.data\n",
|
|
"\n",
|
|
"# Normalizar los datos para mejorar el desempeño del clustering\n",
|
|
"scaler = StandardScaler()\n",
|
|
"X_scaled = scaler.fit_transform(X)\n",
|
|
"\n",
|
|
"# Crear el dendrograma\n",
|
|
"plt.figure(figsize=(10, 5))\n",
|
|
"sch.dendrogram(sch.linkage(X_scaled, method='ward'))\n",
|
|
"plt.title(\"Dendrograma del Agrupamiento Jerárquico\")\n",
|
|
"plt.xlabel(\"Muestras\")\n",
|
|
"plt.ylabel(\"Distancia Eucliadiana\")\n",
|
|
"plt.show()"
|
|
],
|
|
"metadata": {
|
|
"id": "mHXkc4rXsVZS"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"from sklearn.cluster import AgglomerativeClustering\n",
|
|
"\n",
|
|
"# Aplicar Hierarchical Clustering definiendo 3 grupos\n",
|
|
"hc = AgglomerativeClustering(n_clusters=3, metric='euclidean', linkage='ward')\n",
|
|
"clusters = hc.fit_predict(X_scaled)\n",
|
|
"\n",
|
|
"# Visualizar los clusters\n",
|
|
"plt.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis')\n",
|
|
"plt.title(\"Agrupando con Hierarchical Clustering\")\n",
|
|
"plt.xlabel(\"Caracteristica 1\")\n",
|
|
"plt.ylabel(\"Caracteristica 2\")\n",
|
|
"plt.show()"
|
|
],
|
|
"metadata": {
|
|
"id": "zc2n_rRpss05"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# Aprendizaje No Supervisado - PCA"
|
|
],
|
|
"metadata": {
|
|
"id": "8cyJGHKJykxo"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"from sklearn.decomposition import PCA\n",
|
|
"from sklearn.datasets import load_iris\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"from sklearn.preprocessing import StandardScaler\n",
|
|
"\n",
|
|
"# Cargar el dataset Iris\n",
|
|
"iris = load_iris()\n",
|
|
"X = iris.data\n",
|
|
"y = iris.target # Etiquetas de las especies de flores\n",
|
|
"\n",
|
|
"# Normalizar los datos para mejorar el desempeño\n",
|
|
"scaler = StandardScaler()\n",
|
|
"X_scaled = scaler.fit_transform(X)\n",
|
|
"\n",
|
|
"# Aplicar PCA para reducir de 4 a dos dimensiones\n",
|
|
"pca = PCA(n_components=2)\n",
|
|
"X_pca = pca.fit_transform(X_scaled)\n",
|
|
"\n",
|
|
"# Visualizar los datos reducidos\n",
|
|
"plt.figure(figsize=(8, 6))\n",
|
|
"plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis', alpha=0.7)\n",
|
|
"plt.xlabel(\"Componente Principal 1\")\n",
|
|
"plt.ylabel(\"Componente Principal 2\")\n",
|
|
"plt.title(\"Reducción de la Dimensionalidad con PCA\")\n",
|
|
"plt.colorbar(label=\"Especies de Flores\")\n",
|
|
"plt.show()"
|
|
],
|
|
"metadata": {
|
|
"id": "aiOR1kTIyoRN"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"print(pca.explained_variance_ratio_)\n",
|
|
"print(f\"Varianza acumulada: {sum(pca.explained_variance_ratio_):.2f}\")"
|
|
],
|
|
"metadata": {
|
|
"id": "e4USH46X0mQM"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"source": [
|
|
"# **Clase 4**\n",
|
|
"## Procesamiento de imágenes"
|
|
],
|
|
"metadata": {
|
|
"id": "DZSZUimH5gu2"
|
|
}
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"import cv2\n",
|
|
"import numpy as np\n",
|
|
"import matplotlib.pyplot as plt\n",
|
|
"from google.colab import files\n",
|
|
"\n",
|
|
"# Realizar upload de la Imagen\n",
|
|
"uploaded = files.upload()\n",
|
|
"image_path = list(uploaded.keys())[0]\n",
|
|
"\n",
|
|
"# Cargar la imagen en escala de grises\n",
|
|
"imagen = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)\n",
|
|
"\n",
|
|
"# Mostrar la imagen original y la matriz correspondiente\n",
|
|
"plt.figure(figsize=(15,8))\n",
|
|
"\n",
|
|
"plt.subplot(1, 2, 1)\n",
|
|
"plt.imshow(imagen, cmap=\"gray\")\n",
|
|
"plt.title(\"Imagen en tonos de gris\")\n",
|
|
"plt.axis(\"off\")\n",
|
|
"\n",
|
|
"plt.subplot(1, 2, 2)\n",
|
|
"plt.imshow(imagen, cmap=\"gray\")\n",
|
|
"plt.title(\"Matriz de Pixeles\")\n",
|
|
"for i in range(0, imagen.shape[0], 30):\n",
|
|
" for j in range(0, imagen.shape[1], 30):\n",
|
|
" plt.text(j, i, str(imagen[i, j]), color=\"red\", fontsize=6, ha='center', va='center')\n",
|
|
"\n",
|
|
"plt.show()"
|
|
],
|
|
"metadata": {
|
|
"id": "dHyh8vyA5ch1"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"from tensorflow.keras.models import Sequential\n",
|
|
"from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense\n",
|
|
"\n",
|
|
"# Crear un modelo CNN simple\n",
|
|
"modelo = Sequential([\n",
|
|
" Conv2D(32, (3,3), activation='relu', input_shape=(64, 64, 3)), # Capa convolucional\n",
|
|
" MaxPooling2D(pool_size=(2,2)), # Capa de pooling\n",
|
|
" Flatten(), # Aplanando para la capa densa\n",
|
|
" Dense(128, activation='relu'), # Capa totalmente conectada\n",
|
|
" Dense(3, activation='softmax') # Salida para 3 clases\n",
|
|
"])\n",
|
|
"\n",
|
|
"modelo.summary() # Exhibe la arquitectura de la red"
|
|
],
|
|
"metadata": {
|
|
"id": "h1x0gW-E-7FF"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"from tensorflow.keras.applications import MobileNetV2\n",
|
|
"from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions\n",
|
|
"import numpy as np\n",
|
|
"import cv2\n",
|
|
"from google.colab import files\n",
|
|
"from PIL import Image\n",
|
|
"\n",
|
|
"# Fazer upload de imagen\n",
|
|
"uploaded = files.upload()\n",
|
|
"imagen_path = list(uploaded.keys())[0] # Toma el nombre del archivo enviado\n",
|
|
"\n",
|
|
"# Cargar la imagen usando OpenCV\n",
|
|
"imagen = cv2.imread(imagen_path)\n",
|
|
"imagen_rgb = cv2.cvtColor(imagen, cv2.COLOR_BGR2RGB)\n",
|
|
"\n",
|
|
"# Cargar el modelo MobileNetV2 pre-entrenado\n",
|
|
"modelo = MobileNetV2(weights=\"imagenet\")\n",
|
|
"\n",
|
|
"# Pre-procesar la imagen para el formato esperado por el modelo\n",
|
|
"imagen_redimensionada = cv2.resize(imagen_rgb, (224, 224))\n",
|
|
"imagen_array = np.expand_dims(imagen_redimensionada, axis=0)\n",
|
|
"imagen_array = preprocess_input(imagen_array)\n",
|
|
"\n",
|
|
"# Fazer a previsão\n",
|
|
"previsiones = modelo.predict(imagen_array)\n",
|
|
"label = decode_predictions(previsiones)\n",
|
|
"print(\"Objeto identificado:\", label[0][0][1]) # Exhibe la clase identificada"
|
|
],
|
|
"metadata": {
|
|
"id": "t2-jTo-eD2CI"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"from sklearn.feature_extraction.text import CountVectorizer\n",
|
|
"\n",
|
|
"# Conjunto de frases\n",
|
|
"frases = [\"Yo amo viajar para Japón\", \"Viajar es increíble\", \"Quiero conocer Japón\"]\n",
|
|
"\n",
|
|
"# Creando el modelo BoW\n",
|
|
"vectorizer = CountVectorizer()\n",
|
|
"X = vectorizer.fit_transform(frases)\n",
|
|
"\n",
|
|
"# Exhibir matriz resultante\n",
|
|
"print(vectorizer.get_feature_names_out())\n",
|
|
"print(X.toarray())"
|
|
],
|
|
"metadata": {
|
|
"id": "LeC0BU4nJq_y"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"from transformers import pipeline\n",
|
|
"\n",
|
|
"# Cargar un modelo de generación de texto\n",
|
|
"generador = pipeline(\"text-generation\", model=\"gpt2\")\n",
|
|
"\n",
|
|
"# Definir el prompt\n",
|
|
"prompt = \"Cuál es la mejor época para visitar Japón?\"\n",
|
|
"\n",
|
|
"# Generar una respuesta ajustando los parámetros para evitar repeticiones\n",
|
|
"respuesta = generador(\n",
|
|
" prompt,\n",
|
|
" max_length=50, # Aumentar un poco la longitud\n",
|
|
" temperature=0.1, # Controla la aleatoriedad\n",
|
|
" top_p=0.9, # Realiza el muestreo con un núcleo (nucleus sampling)\n",
|
|
" top_k=10, # Restringe la elección al top 50 de palabras con mayor probabilidad\n",
|
|
" repetition_penalty=1.2 # Penaliza repeticiones\n",
|
|
")\n",
|
|
"\n",
|
|
"# Exhibir la respuesta formateada\n",
|
|
"print(respuesta[0]['generated_text'])"
|
|
],
|
|
"metadata": {
|
|
"id": "fuSqfSMCg0y-"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"source": [
|
|
"import numpy as np\n",
|
|
"import gymnasium as gym\n",
|
|
"\n",
|
|
"# Inicializar el entorno FrozenLake\n",
|
|
"# El agente necesita cruzar un lago congelado sin caer en los agujeros\n",
|
|
"env = gym.make(\"FrozenLake-v1\", is_slippery=True)\n",
|
|
"\n",
|
|
"# Definir los hiperparámetros del Q-Learning\n",
|
|
"alpha = 0.8 # Tasa de aprendizaje: cuánto aprende el agente de nueva información\n",
|
|
"gamma = 0.95 # Factor de descuento: cuán importantes son las recompensas futuras en comparación con las inmediatas\n",
|
|
"epsilon = 1.0 # Probabilidad inicial de explorar acciones aleatorias\n",
|
|
"epsilon_decay = 0.999 # Reduce gradualmente la exploración a medida que el agente aprende\n",
|
|
"epsilon_min = 0.01 # Límite mínimo de exploración para garantizar que el agente aún explore un poco\n",
|
|
"num_episodes = 20000 # Número total de intentos de aprendizaje (episodios)\n",
|
|
"\n",
|
|
"# Crear la tabla Q (Q-table) con ceros\n",
|
|
"# Las filas representan los estados y las columnas representan las acciones\n",
|
|
"q_table = np.zeros((env.observation_space.n, env.action_space.n))\n",
|
|
"\n",
|
|
"# Iniciar el entrenamiento del agente\n",
|
|
"for episode in range(num_episodes):\n",
|
|
" # Reiniciar el entorno en cada episodio\n",
|
|
" state, _ = env.reset()\n",
|
|
" done = False\n",
|
|
"\n",
|
|
" while not done:\n",
|
|
" # Elegir una acción usando la estrategia epsilon-greedy\n",
|
|
" # Con probabilidad 'epsilon', elegimos una acción aleatoria (exploración)\n",
|
|
" # De lo contrario, elegimos la mejor acción conocida hasta el momento (explotación)\n",
|
|
" if np.random.rand() < epsilon:\n",
|
|
" action = env.action_space.sample() # Explorar una acción aleatoria\n",
|
|
" else:\n",
|
|
" action = np.argmax(q_table[state]) # Explorar la acción con mayor valor en la Q-table\n",
|
|
"\n",
|
|
" # Ejecutar la acción elegida en el entorno\n",
|
|
" next_state, reward, done, truncated, _ = env.step(action)\n",
|
|
"\n",
|
|
" # Actualizar la Q-table con la fórmula de aprendizaje por refuerzo\n",
|
|
" # Q(s, a) = Q(s, a) + alpha * (recompensa + descuento * max(Q(s', a')) - Q(s, a))\n",
|
|
" best_next_action = np.max(q_table[next_state]) # Mejor acción en el siguiente estado\n",
|
|
" q_table[state, action] += alpha * (reward + gamma * best_next_action - q_table[state, action])\n",
|
|
"\n",
|
|
" # Avanzar al siguiente estado\n",
|
|
" state = next_state\n",
|
|
"\n",
|
|
" # Reducir la tasa de exploración gradualmente, sin superar el mínimo definido\n",
|
|
" if epsilon > epsilon_min:\n",
|
|
" epsilon *= epsilon_decay\n",
|
|
"\n",
|
|
"# Evaluar el rendimiento del agente entrenado\n",
|
|
"# Aquí, probamos 1000 episodios para verificar cuántas veces logra cruzar el lago con éxito\n",
|
|
"successes = 0\n",
|
|
"for episode in range(1000):\n",
|
|
" state, _ = env.reset()\n",
|
|
" done = False\n",
|
|
" while not done:\n",
|
|
" # El agente ahora solo elige la mejor acción aprendida (sin exploración aleatoria)\n",
|
|
" action = np.argmax(q_table[state])\n",
|
|
" state, reward, done, truncated, _ = env.step(action)\n",
|
|
" if done and reward == 1.0:\n",
|
|
" successes += 1 # Contabilizar los éxitos\n",
|
|
"\n",
|
|
"# Mostrar el resultado final\n",
|
|
"print(f\"El agente logró cruzar el lago con éxito en {successes} de 1000 episodios.\")"
|
|
],
|
|
"metadata": {
|
|
"id": "n7g_V-DL7aZ9"
|
|
},
|
|
"execution_count": null,
|
|
"outputs": []
|
|
}
|
|
],
|
|
"metadata": {
|
|
"colab": {
|
|
"provenance": [],
|
|
"toc_visible": true
|
|
},
|
|
"kernelspec": {
|
|
"display_name": "Python 3",
|
|
"name": "python3"
|
|
},
|
|
"language_info": {
|
|
"name": "python"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 0
|
|
} |