{ "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": { "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 }