![\"Árbol](\"resources/decision_tree.png\")
"
]
@@ -123,13 +125,13 @@
"id": "7aec7f51-1d4d-490c-9749-b72f47277cab",
"metadata": {},
"source": [
- "El aprendizaje del árbol de decisiones emplea una estrategia de **divide y vencerás** mediante la realización de una búsqueda codiciosa para identificar los puntos de división óptimos dentro de un árbol. Este proceso de división se repite de forma recursiva de arriba hacia abajo hasta que todos o la mayoría de los registros se hayan clasificado bajo etiquetas de clase específicas.\n",
+ "El proceso de aprendizaje en los árboles de decisión implementa una estrategia de **divide y vencerás**, ejecutando una búsqueda codiciosa para determinar los mejores puntos de división dentro de un árbol. Este mecanismo de partición se aplica de manera recursiva, de arriba hacia abajo, hasta que se logra clasificar todos o la mayoría de los registros bajo categorías específicas.\n",
"\n",
- "Que todos los puntos de datos se clasifiquen o no como conjuntos homogéneos depende en gran medida de la complejidad del árbol de decisión.\n",
+ "La capacidad del árbol para clasificar los datos en grupos homogéneos está directamente relacionada con su complejidad.\n",
"\n",
- "Los árboles más pequeños tienden a generar nodos hoja puros, es decir, puntos de datos en una sola clase.\\\n",
- "Sin embargo, a medida que un árbol crece en tamaño, se vuelve cada vez más difícil mantener esta pureza y, por lo general, da como resultado que haya muy pocos datos dentro de un subárbol determinado.\\\n",
- "Cuando esto ocurre, se conoce como fragmentación de datos y, a menudo, puede resultar en **overfitting o sobreajuste**."
+ "Los árboles más compactos suelen producir nodos hoja homogéneos, donde los datos pertenecen a una única categoría.\\\n",
+ "Sin embargo, conforme el árbol se expande, mantener esta homogeneidad se torna más complicado, resultando a menudo en la presencia de muy pocos datos dentro de un subárbol específico.\\\n",
+ "Este fenómeno, conocido como fragmentación de datos, puede llevar a un **overfitting o sobreajuste** del modelo, donde este se ajusta excesivamente a los datos de entrenamiento, perdiendo capacidad de generalización."
]
},
{
@@ -142,13 +144,14 @@
"source": [
"![\"Árbol](\"resources/decision_tree_geology.png\")
\n",
"\n",
- "Como resultado, los árboles de decisión tienen preferencia por los árboles pequeños, lo cual es consistente con el principio de parsimonia en la Navaja de Occam. Es decir, \"las entidades no deben multiplicarse más allá de la necesidad\". Dicho de otra manera, los árboles de decisión deben agregar complejidad solo si es necesario, ya que la explicación más simple suele ser la mejor. Para reducir la complejidad y evitar el sobreajuste, generalmente se emplea la **poda (pruning)**.\n",
+ "Como resultado, los árboles de decisión muestran una tendencia a favorecer estructuras más compactas, lo cual resuena con el principio de parsimonia, comúnmente asociado a la Navaja de Occam. Este principio sostiene que \"no se deben multiplicar las entidades más allá de lo necesario\". En términos de árboles de decisión, esto implica que solo se debería incrementar la complejidad del modelo cuando es estrictamente necesario, ya que, generalmente, las explicaciones más sencillas resultan ser las más adecuadas.\n",
"\n",
- "La poda es un proceso que elimina las ramas que se dividen en características con poca importancia. Luego, el ajuste del modelo se puede evaluar mediante el proceso de validación cruzada.\n",
+ "Para limitar la complejidad y prevenir el sobreajuste, se recurre a menudo a la técnica de **poda (pruning)**.\\\n",
+ "La poda es un proceso que se encarga de eliminar aquellas ramas del árbol que se basan en atributos de importancia menor. Posteriormente, la eficacia del modelo ajustado puede ser evaluada a través de la validación cruzada.\n",
"\n",
- "**¿Qué pasaría si utilizamos varios árboles de decisión para predecir un resultado?**\n",
+ "**¿Qué ocurriría si empleáramos múltiples árboles de decisión para realizar una predicción?**\n",
"\n",
- "Otra forma en que los árboles de decisión pueden mantener su precisión es mediante la formación de un conjunto a través de un algoritmo de **Random Forest**. Este clasificador predice resultados más precisos, particularmente cuando los árboles individuales no están correlacionados entre sí."
+ "Una manera de mejorar la precisión de los árboles de decisión es mediante la creación de un conjunto de estos a través del algoritmo de Random Forest. Este enfoque permite obtener predicciones más exactas, especialmente cuando los árboles que componen el bosque no están correlacionados entre sí."
]
},
{
@@ -200,8 +203,8 @@
"metadata": {},
"outputs": [],
"source": [
- "data = pd.read_csv(\"files/rocas.csv\")\n",
- "data.head()"
+ "rocas = pd.read_csv(\"files/rocas.csv\")\n",
+ "rocas.sample(6)"
]
},
{
@@ -209,7 +212,8 @@
"id": "70576e7e-0feb-44b1-8c34-79cc5d3b2b68",
"metadata": {},
"source": [
- "Ahora, seleccionamos las litologías de `Granodiorita` y `Andesita`:"
+ "Ahora, seleccionaremos las litologías de `Basalto` y `Riolita`:\n",
+ "> Usaremos el método `isin`, filtrando aquellas filas que pertenezcan a las clases `basalt` o `rhyolite`."
]
},
{
@@ -219,8 +223,8 @@
"metadata": {},
"outputs": [],
"source": [
- "data = data[(data[\"Nombre\"] == \"Granodiorita\") | (data[\"Nombre\"] == \"Andesita\")].reset_index(drop=True)\n",
- "data.head()"
+ "data = rocas[rocas[\"Nombre\"].isin([\"basalt\", \"rhyolite\"])].reset_index(drop=True)\n",
+ "data.sample(6)"
]
},
{
@@ -228,7 +232,8 @@
"id": "e0f28a7f-e559-456d-8ee2-6ec351278cc8",
"metadata": {},
"source": [
- "Crearemos una nueva columna llamada `Roca` y asignaremos un valor numérico que representará el tipo de litología: 0 para `Granodiorita` y 1 para `Andesita`:"
+ "Crearemos una nueva columna llamada `target` y asignaremos un valor numérico a cada tipo de litología:\n",
+ "> Los valores serán 0 para `basalt` y 1 para `rhyolite`."
]
},
{
@@ -238,9 +243,14 @@
"metadata": {},
"outputs": [],
"source": [
- "data[\"Roca\"] = 0 # Todos los valores en Roca = 0\n",
- "data.loc[data[data[\"Nombre\"] == \"Andesita\"].index, \"Roca\"] = 1 # Valores de Andesita en Roca = 1\n",
- "data"
+ "# Creamos una columna llamada target de valor 0\n",
+ "data[\"target\"] = 0 \n",
+ "\n",
+ "# Los datos de riolito en esta columna van a valer 1\n",
+ "data.loc[data[data[\"Nombre\"] == \"rhyolite\"].index, \"target\"] = 1\n",
+ "\n",
+ "# Mostramos la tabla\n",
+ "data.sample(6)"
]
},
{
@@ -250,7 +260,7 @@
"source": [
"Luego de hacer la transformación de datos, separamos las columnas de la siguiente forma:\n",
"- `X` : contiene la información numérica de concentraciones geoquímicas, usada para entrenar y probar el modelo.\n",
- "- `y` : contiene la información de la columna `Roca`, la variable a predecir.\n",
+ "- `y` : contiene la información de la columna `target`, la variable a predecir.\n",
"\n",
"Usaremos el atributo `values` del DataFrame para convertir la información en arreglos de Numpy:"
]
@@ -262,8 +272,8 @@
"metadata": {},
"outputs": [],
"source": [
- "X = data.iloc[:, 1:-1].values\n",
- "y = data[\"Roca\"].values"
+ "X = data.iloc[:, 1:-1] # Columnas de features\n",
+ "y = data[\"target\"] # Columna objetivo"
]
},
{
@@ -273,19 +283,16 @@
"metadata": {},
"outputs": [],
"source": [
- "# Variables independientes (features)\n",
- "print(X)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "6368d87c-34b8-4884-8b99-ccbfceff19e4",
- "metadata": {},
- "outputs": [],
- "source": [
- "# Variable de interés (target)\n",
- "print(y)"
+ "# Mostramos los features del modelo\n",
+ "print(\"Features:\")\n",
+ "print(\"----------\")\n",
+ "print(X.values)\n",
+ "print(\"\")\n",
+ "\n",
+ "# Mostramos el target del modelo\n",
+ "print(\"Target:\")\n",
+ "print(\"----------\")\n",
+ "print(y.values)"
]
},
{
@@ -293,7 +300,9 @@
"id": "7579e5db-5f2b-443c-b6cf-d09fcb3ff6dc",
"metadata": {},
"source": [
- "Una vez separado los datos, procedemos a separar la data de entrenamiento y de prueba usando la función `train_test_split`, el parámetro `test_size=0.10` representa la fracción de la data que será asignada al conjunto de prueba."
+ "Una vez separado los datos, procedemos a separar la data de entrenamiento y de prueba usando la función `train_test_split`:\n",
+ "> El parámetro `test_size=0.25` representa la fracción de la data que será asignada al conjunto de prueba.\\\n",
+ "> También asignaremos un valor a `random_state` para que el resultado sea reproducible."
]
},
{
@@ -303,7 +312,12 @@
"metadata": {},
"outputs": [],
"source": [
- "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)"
+ "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)\n",
+ "\n",
+ "print(f\"Tamaño de X_train: {X_train.shape}\")\n",
+ "print(f\"Tamaño de X_test: {X_test.shape}\")\n",
+ "print(f\"Tamaño de y_train: {y_train.shape}\")\n",
+ "print(f\"Tamaño de y_test: {y_test.shape}\")"
]
},
{
@@ -312,7 +326,7 @@
"metadata": {},
"source": [
"Ahora, crearemos el modelo y lo entrenaremos usando la data de entrenamiento:\n",
- "> El parámetro `criterion=\"gini\"` establece el criterio de división de los nodos y `max_depth=3` establece la profundidad del árbol de decisión."
+ "> El parámetro `criterion=\"gini\"` hace referencia a la impureza de Gini que establece el criterio de división de los nodos y `max_depth=2` establece la profundidad del árbol de decisión."
]
},
{
@@ -322,7 +336,7 @@
"metadata": {},
"outputs": [],
"source": [
- "model = DecisionTreeClassifier(criterion=\"gini\", max_depth=3)"
+ "model = DecisionTreeClassifier(criterion=\"gini\", max_depth=2)"
]
},
{
@@ -332,11 +346,13 @@
"tags": []
},
"source": [
- "**¿Qué es la impureza de Gini?**\n",
- "\n",
- "**CART** es una abreviatura de **árboles de clasificación y regresión (classification and regression trees)** y fue introducido por Leo Breiman.\\\n",
- "Por lo general, este algoritmo hace uso de la **impureza de Gini** para identificar el atributo ideal para la división.\\\n",
- "La impureza de Gini mide la frecuencia con la que se clasifica incorrectamente un atributo elegido al azar. Cuando se evalúa usando la impureza de Gini, un valor más bajo es más ideal. "
+ "> **¿Qué es la impureza de Gini?**\n",
+ ">\n",
+ "> La impureza de Gini es un criterio utilizado para evaluar la calidad de una división en los nodos de un árbol de decisión dentro del contexto de los **árboles de clasificación y regresión (CART)**, un modelo introducido por Leo Breiman.\n",
+ "> \n",
+ "> Este índice mide qué tan a menudo un elemento seleccionado al azar sería identificado incorrectamente si se le etiquetase de acuerdo con la distribución de etiquetas en el conjunto. En otras palabras, evalúa la probabilidad de que un atributo sea clasificado erróneamente si se escoge al azar según la distribución observada en el subconjunto.\n",
+ "> \n",
+ "> Un valor de impureza de Gini de 0 indica la pureza perfecta, es decir, todos los casos en el nodo pertenecen a una sola clase, mientras que valores más altos indican mayor mezcla de clases dentro del nodo. En la práctica, al construir un árbol de decisión CART, el objetivo es minimizar la impureza de Gini al elegir el mejor atributo para dividir los datos en cada paso, buscando aquellos puntos de división que resulten en subconjuntos lo más homogéneos posible respecto a la variable objetivo."
]
},
{
@@ -344,7 +360,7 @@
"id": "5b0fa4e2-e6c0-4b70-afb1-b761ccfb7217",
"metadata": {},
"source": [
- "Procedemos ahora a entrenar el modelo:"
+ "Procederemos ahora a entrenar el modelo:"
]
},
{
@@ -363,12 +379,23 @@
"id": "c9f3925b-2abe-4f82-a41a-3532bfe9c83d",
"metadata": {},
"source": [
- "Una vez entrenado el modelo, mediremos su exactitud usando la función `accuracy_score`:\n",
- "> La **exactitud** representa la cantidad de predicciones que fueron correctas.\\\n",
+ "Una vez entrenado el modelo, evaluaremos su precisión usando la función `accuracy_score`:\n",
+ "> La **precisión (accuracy)** representa la cantidad de predicciones que fueron correctas.\\\n",
"> El parámetro `y_true` representa la data que se busca obtener y `y_pred` es la predicción realizada por el modelo.\\\n",
"> Para predecir valores con el modelo, tenemos que usar el método `predict`."
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c1158aa9-8132-444e-9deb-2fa02ec4dd05",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y_train_pred = model.predict(X_train) # Predicción del modelo con X_train\n",
+ "y_test_pred = model.predict(X_test) # Predicción del modelo con X_test"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -376,8 +403,17 @@
"metadata": {},
"outputs": [],
"source": [
- "print(f\"Accuracy Score - Entrenamiento: {accuracy_score(y_true=y_train, y_pred=model.predict(X_train)):.1%}\")\n",
- "print(f\"Accuracy Score - Prueba: {accuracy_score(y_true=y_test, y_pred=model.predict(X_test)):.1%}\")"
+ "print(f\"Accuracy Score - Entrenamiento: {accuracy_score(y_true=y_train, y_pred=y_train_pred):.1%}\")\n",
+ "print(f\"Accuracy Score - Prueba: {accuracy_score(y_true=y_test, y_pred=y_test_pred):.1%}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a182c8f0-c00e-42b0-bb60-21d4e559b972",
+ "metadata": {},
+ "source": [
+ "El modelo de arbol de decisión ha obtenido una alta precisión (más del 99%) para discriminar muestras de basalto y riolita.\\\n",
+ "Al tener precisión alta tanto en el entrenamiento como en la prueba, podemos concluir que no existe sobreajuste."
]
},
{
@@ -407,17 +443,7 @@
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
- "from sklearn.tree import export_text, plot_tree # Funciones para graficar el árbol de decisión"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "b760ecff-39dc-44dc-9caf-c136d50cc83a",
- "metadata": {},
- "outputs": [],
- "source": [
- "data.head(1)"
+ "from sklearn.tree import export_text, plot_tree # Funciones para graficar el árbol de decisión"
]
},
{
@@ -436,8 +462,8 @@
"metadata": {},
"outputs": [],
"source": [
- "# Columnas de la matriz X\n",
- "x_cols = list(data.iloc[:, 1:-1].columns)\n",
+ "# Almacenamos los nombres de las columnas de X\n",
+ "x_cols = list(X.columns)\n",
"print(x_cols)"
]
},
@@ -474,9 +500,9 @@
"metadata": {},
"outputs": [],
"source": [
- "fig = plt.figure(figsize=(16, 10))\n",
+ "fig = plt.figure(figsize=(10, 6))\n",
"\n",
- "plot_tree(model, feature_names=x_cols, class_names=[\"Granodiorita\", \"Andesita\"], filled=True)\n",
+ "plot_tree(model, feature_names=x_cols, class_names=[\"Basalto\", \"Riolita\"], filled=True)\n",
"\n",
"plt.show()"
]
@@ -507,7 +533,7 @@
"metadata": {},
"source": [
"La **importancia de atributos** nos ayuda a determinar qué variables son las más importantes para entrenar el modelo.\\\n",
- "Observamos que la columna `SiO2` tiene una importancia muy alta comparada con el resto de columnas.\\\n",
+ "Observamos que la columna `SiO2` tiene una importancia muy alta (más del 99%) comparada con el resto de columnas.\\\n",
"Algunas columnas son irrelevantes para el entrenamiento del modelo.\n",
"***"
]
diff --git a/notebooks/pg301a_variograma.ipynb b/notebooks/pg301a_variograma.ipynb
index 601e5e5..5e4822f 100644
--- a/notebooks/pg301a_variograma.ipynb
+++ b/notebooks/pg301a_variograma.ipynb
@@ -361,7 +361,7 @@
"- `Porosidad` : porosidad en fracción (%)\n",
"- `Permeabilidad` : permeabilidad en mDarcy\n",
"\n",
- "Ahora, separeremos la información en dos DataFrames de acuerdo al tipo de Facies:"
+ "Ahora, separaremos la información en dos DataFrames de acuerdo al tipo de Facies:"
]
},
{
@@ -763,8 +763,8 @@
"ax1.plot(lag, por_lt_gamma, \".\", color=\"green\", label=\"Lutita\", markersize=16)\n",
"ax1.plot([0, 2000], [1., 1.], color=\"black\")\n",
"\n",
- "ax1.set_xlabel(r\"Separación $\\bfh$, (m)\", fontsize=18)\n",
- "ax1.set_ylabel(r\"$\\gamma\\bf(h)$\", fontsize=20)\n",
+ "ax1.set_xlabel(r\"Separación $fh$, (m)\", fontsize=18)\n",
+ "ax1.set_ylabel(r\"$\\gamma f(h)$\", fontsize=20)\n",
"ax1.set_title(\"Variograma Isotrópico - Porosidad NSCORE\", fontsize=20)\n",
"ax1.set_xlim([0, 700])\n",
"ax1.set_ylim([0, 2.])\n",
@@ -777,8 +777,8 @@
"ax2.plot(lag, perm_lt_gamma, \".\", color=\"green\", label=\"Lutita\", markersize=16)\n",
"ax2.plot([0, 2000], [1., 1.], color = 'black')\n",
"\n",
- "ax2.set_xlabel(r\"Separación $\\bfh$, (m)\", fontsize=18)\n",
- "ax2.set_ylabel(r\"$\\gamma\\bf(h)$\", fontsize=20)\n",
+ "ax2.set_xlabel(r\"Separación $fh$, (m)\", fontsize=18)\n",
+ "ax2.set_ylabel(r\"$\\gamma f(h)$\", fontsize=20)\n",
"ax2.set_title(\"Variograma Isotrópico - Permeabilidad NSCORE\", fontsize=20)\n",
"ax2.set_xlim([0, 700])\n",
"ax2.set_ylim([0, 2.])\n",
diff --git a/notebooks/pg301b_variograma1d.ipynb b/notebooks/pg301b_variograma1d.ipynb
index 30a8bed..43e0c51 100644
--- a/notebooks/pg301b_variograma1d.ipynb
+++ b/notebooks/pg301b_variograma1d.ipynb
@@ -159,8 +159,10 @@
"metadata": {},
"outputs": [],
"source": [
+ "# Seleccionamos el taladro DH010 de la tabla assay y analizaremos los valores de CU_pct\n",
"data = pd.read_csv(\"files/assay.csv\")[[\"ID\", \"FROM\", \"TO\", \"CU_pct\"]]\n",
- "data = data[data[\"ID\"] == \"DH010\"].drop(columns=[\"ID\"]).reset_index(drop=True)"
+ "data = data[data[\"ID\"] == \"DH010\"].drop(columns=[\"ID\"]).reset_index(drop=True)\n",
+ "data.head()"
]
},
{
diff --git a/notebooks/pg303_geoespacial.ipynb b/notebooks/pg303_geoespacial.ipynb
index 28a20a4..cdff7b3 100644
--- a/notebooks/pg303_geoespacial.ipynb
+++ b/notebooks/pg303_geoespacial.ipynb
@@ -46,7 +46,7 @@
"1. [Shapely](pg303a_shapely.ipynb)\n",
"2. [Geopandas](pg303b_geopandas.ipynb)\n",
"3. [Rioxarray](pg303c_rioxarray.ipynb)\n",
- "4. [Leafmap (en desarrollo)](pg303d_leafmap.ipynb)\n",
+ "4. [Leafmap](pg303d_leafmap.ipynb)\n",
"\n",
"***"
]
diff --git a/notebooks/pg303a_shapely.ipynb b/notebooks/pg303a_shapely.ipynb
index ee4ca76..981e0af 100644
--- a/notebooks/pg303a_shapely.ipynb
+++ b/notebooks/pg303a_shapely.ipynb
@@ -123,7 +123,7 @@
"Si hablamos de información vectorial, hablamos de datos geográficos simbolizados a través de puntos, líneas o polígonos.\\\n",
"Cada uno de estos objetos geométricos puede tener información asociada a diferentes valores de atributos.\n",
"\n",
- "La información ráster, por otra parte, consiste en una matriz de celdas en la cual se asigna un valor de atributo a cada una de estas celdas.\\\n",
+ "La información ráster, por otra parte, consiste en una matriz de celdas (imágenes) en la cual se asigna un valor de atributo a cada una de estas celdas.\\\n",
"El tamaño de cada celda en el mundo real representa la resolución espacial del ráster.\n",
"***"
]
@@ -308,7 +308,7 @@
"metadata": {},
"outputs": [],
"source": [
- "LineString([[0, 0], [1, 1], [1, 0]])"
+ "LineString([[0, 0], [1, 1], [1.5, 0]])"
]
},
{
@@ -326,7 +326,7 @@
"metadata": {},
"outputs": [],
"source": [
- "linea = LineString([[0, 0], [1, 1], [1, 0]])\n",
+ "linea = LineString([[0, 0], [1, 1], [1.5, 0]])\n",
"linea.length"
]
},
@@ -550,7 +550,8 @@
"outputs": [],
"source": [
"X = A.intersection(B)\n",
- "type(X)"
+ "print(type(X))\n",
+ "X"
]
},
{
@@ -859,6 +860,16 @@
"A.intersects(B)"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cdd1955c-9b48-4537-8c57-4f933d07f4c1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "A.intersection(B)"
+ ]
+ },
{
"cell_type": "markdown",
"id": "046ac1aa-b9d9-47ba-8307-6615cfccbb51",
@@ -885,7 +896,9 @@
"metadata": {},
"outputs": [],
"source": [
- "poligono.centroid"
+ "centroide = poligono.centroid\n",
+ "print(f\"Coordenadas del centroide: X: {centroide.x}, Y: {centroide.y}\")\n",
+ "centroide"
]
},
{
diff --git a/notebooks/pg303b_geopandas.ipynb b/notebooks/pg303b_geopandas.ipynb
index 4e2223f..ea36e02 100644
--- a/notebooks/pg303b_geopandas.ipynb
+++ b/notebooks/pg303b_geopandas.ipynb
@@ -354,7 +354,7 @@
"outputs": [],
"source": [
"# Figura principal\n",
- "fig, ax = plt.subplots(figsize=(10, 10))\n",
+ "fig, ax = plt.subplots(figsize=(6, 6))\n",
"\n",
"# Polígonos de los países\n",
"gdf.plot(ax=ax, color=\"green\")\n",
@@ -363,6 +363,11 @@
"ax.set_xlim(-90, -30)\n",
"ax.set_ylim(-60, 15)\n",
"\n",
+ "# Texto\n",
+ "ax.set_title(\"Sudamérica\")\n",
+ "ax.set_xlabel(\"Longitud (°)\")\n",
+ "ax.set_ylabel(\"Latitud (°)\")\n",
+ "\n",
"# Grilla\n",
"ax.grid(lw=0.5, color=\"black\", alpha=0.5)\n",
"\n",
@@ -566,10 +571,10 @@
"metadata": {},
"outputs": [],
"source": [
- "fig, ax = plt.subplots(figsize=(15, 12))\n",
+ "fig, ax = plt.subplots(figsize=(12, 8), subplot_kw={\"aspect\":1})\n",
"\n",
"gdf[\"geometry\"].plot(ax=ax, color=\"lightgreen\", edgecolor=\"black\")\n",
- "gdf[\"centroid\"].plot(ax=ax, color=\"red\", marker=\".\", markersize=10)\n",
+ "gdf[\"centroid\"].plot(ax=ax, color=\"red\", marker=\".\", markersize=8)\n",
"\n",
"plt.show()"
]
@@ -716,7 +721,7 @@
"outputs": [],
"source": [
"# Figura principal\n",
- "fig, ax = plt.subplots(figsize=(8, 10))\n",
+ "fig, ax = plt.subplots(figsize=(5, 8))\n",
"\n",
"# Polígonos de los países\n",
"gdf.plot(ax=ax, color=\"lightgreen\", edgecolor=\"black\")\n",
@@ -729,8 +734,10 @@
"# Grilla\n",
"ax.grid(lw=0.5, color=\"black\", alpha=0.5)\n",
"\n",
- "# Título\n",
- "ax.set_title(\"Sismos registrados en Perú (Mw$\\geq$5.0)\", fontsize=16)\n",
+ "# Texto\n",
+ "ax.set_title(\"Sismos registrados en Perú (Mw$\\geq$5.0)\", fontsize=12)\n",
+ "ax.set_xlabel(\"Longitud (°)\")\n",
+ "ax.set_ylabel(\"Latitud (°)\")\n",
"\n",
"plt.show()"
]
@@ -749,6 +756,16 @@
" inplace=True)"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9692eaf1-352d-4827-b118-cfc0eb52f65f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sismos.head()"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -756,7 +773,7 @@
"metadata": {},
"outputs": [],
"source": [
- "# Guardando del GeoDataFrame de sismos\n",
+ "# Guardando el GeoDataFrame en un shapefile llamado \"sismos\"\n",
"sismos.to_file(\"files/sismos\")"
]
},
diff --git a/notebooks/pg303c_rioxarray.ipynb b/notebooks/pg303c_rioxarray.ipynb
index 42737bd..0a1679c 100644
--- a/notebooks/pg303c_rioxarray.ipynb
+++ b/notebooks/pg303c_rioxarray.ipynb
@@ -106,14 +106,13 @@
"### **¿Qué es Rioxarray?**\n",
"***\n",
"\n",
- "Rioxarray es una librería de Python utilizada en el análisis de datos geoespaciales.\\\n",
- "Basándose en la librería xarray, proporciona una estructura de datos etiquetada y multidimensional llamada `DataArray`. \n",
+ "Rioxarray es una librería de Python que proporciona una estructura de datos etiquetada y multidimensional llamada `DataArray`, que proviene de la librería `Xarray`, para el manejo de sistemas de referencia de coordenadas (CRS) y transformaciones geoespaciales.\n",
"\n",
- "Rioxarray extiende las capacidades de xarray al agregar funcionalidades específicas para trabajar con datos geoespaciales, como la capacidad de leer y escribir archivos raster en diferentes formatos, realizar operaciones espaciales como recortar y re-muestrear datos, y calcular índices y estadísticas comunes utilizadas en el análisis geoespacial.\n",
+ "> Xarray es una biblioteca de código abierto que facilita la manipulación y análisis de datos multidimensionales, como los que se encuentran en las ciencias atmosféricas, oceanografía, y, por supuesto, geología y geofísica.\n",
"\n",
- "Está librería ha sido diseñada para simplificar el análisis y la manipulación de datos geoespaciales multidimensionales, como imágenes satelitales, datos de sensores remotos y conjuntos de datos climáticos.\n",
+ "Rioxarray cuenta con funcionalidades específicas para trabajar con datos geoespaciales, como la capacidad de leer y escribir archivos raster en diferentes formatos, realizar operaciones espaciales como reproyectar, recortar y re-muestrear datos, y calcular índices y estadísticas comunes utilizadas en el análisis geoespacial.\n",
"\n",
- "Algunas de las características clave de rioxarray incluyen también la compatibilidad con una amplia gama de formatos de archivo geoespaciales, la capacidad de reproyectar y transformar datos espaciales, el soporte para operaciones algebraicas y lógicas en datos georreferenciados, y la integración con otras bibliotecas de análisis de datos populares, como NumPy y Pandas."
+ "Está librería ha sido diseñada para simplificar el análisis y la manipulación de datos geoespaciales multidimensionales, como imágenes satelitales, datos de sensores remotos y conjuntos de datos climáticos."
]
},
{
@@ -142,7 +141,8 @@
"### **Abriendo un raster en Python**\n",
"***\n",
"\n",
- "Para abrir un raster dentro de Python usando rioxarray, empezaremos importando las librerías necesarias:"
+ "Para abrir un raster dentro de Python usando rioxarray, empezaremos usando la función `open_rasterio` de `rioxarray`:\n",
+ "> Usaremos un raster llamado `peru_60.tiff`, que contiene un modelo digital de elevación (DEM) del Perú en baja resolución (60 arco-segundos)."
]
},
{
@@ -154,16 +154,7 @@
},
"outputs": [],
"source": [
- "import rioxarray as riox"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "dddd0b0d-7b3d-46df-8454-94ef972b2e0a",
- "metadata": {},
- "source": [
- "Ahora, colocaremos la ruta de nuestro raster y usaremos la función `open_rasterio` para abrirlo:\n",
- "> Usaremos el raster llamado `peru_60.tiff`, que contiene un modelo digital de elevación del Perú en baja resolución (60 arco-segundos)."
+ "from rioxarray import open_rasterio"
]
},
{
@@ -178,11 +169,11 @@
"# Ruta del archivo raster\n",
"ruta = \"files/peru_60.tiff\"\n",
"\n",
- "# Abrir el raster utilizando rioxarray\n",
- "raster = riox.open_rasterio(ruta)\n",
+ "# Abrimos el raster utilizando rioxarray\n",
+ "raster = open_rasterio(ruta)\n",
"\n",
- "# Mostrar información del raster\n",
- "print(raster)"
+ "# Mostramos información del raster\n",
+ "raster"
]
},
{
@@ -191,11 +182,9 @@
"metadata": {},
"source": [
"Podemos leer algunas de las características principales de este raster como:\n",
- "- La cantidad de bandas o canales: 1 para la elevación (en una imagen a color el RGB presenta de 3 a 4 bandas)\n",
+ "- `band`: la cantidad de bandas o canales, solo una para la elevación (en una imagen a color el RGB presenta de 3 a 4 bandas)\n",
"- La extensión del raster en píxeles: 1110 de ancho x 840 de largo\n",
- "- La cantidad total de píxeles: 932400\n",
- "- Las coordenadas de los píxeles en el espacio, que se encuentran en coordenadas geográficas (WGS84)\n",
- "- Y las estadísticas de los valores de elevación, como la altura máxima (5427) y mínima (-4779) registradas con esta resolución"
+ "- La cantidad total de píxeles: 932400"
]
},
{
@@ -216,7 +205,36 @@
"outputs": [],
"source": [
"# Acceder a los datos del raster (banda 0)\n",
- "raster.values[0]"
+ "print(raster.values[0])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d170be2-fc34-441d-b464-6d00100bc6c3",
+ "metadata": {},
+ "source": [
+ "Para calcular la elevación máxima y mínima del DEM (omitiendo valores vacíos, si es que hubieran), usaremos `nanmin` y `nanmax`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "57e88eb8-5f4a-483e-b5e2-9f95cc52af1b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "66765351-272a-4eee-8167-315901af1deb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(f\"Profundidad mínima: {np.nanmin(raster.values[0]):.2f} metros\")\n",
+ "print(f\"Profundidad máxima: {np.nanmax(raster.values[0]):.2f} metros\")"
]
},
{
@@ -236,7 +254,7 @@
},
"outputs": [],
"source": [
- "raster.coords"
+ "print(raster.coords)"
]
},
{
@@ -266,8 +284,7 @@
"id": "0b276e92-60ad-42ce-b016-b8f69c34626c",
"metadata": {},
"source": [
- "Este código `EPSG:4326` representa el sistema de coordenadas geográfico WGS84, que usa unidades de grados sexagesimales.\n",
- "***"
+ "Este código `EPSG:4326` representa el sistema de coordenadas geográfico WGS84, que usa unidades de grados sexagesimales."
]
},
{
@@ -301,7 +318,7 @@
"outputs": [],
"source": [
"DEM = raster.values[0]\n",
- "DEM"
+ "print(DEM)"
]
},
{
@@ -335,7 +352,7 @@
"outputs": [],
"source": [
"# Figura principal\n",
- "fig, ax = plt.subplots(figsize=(10, 5))\n",
+ "fig, ax = plt.subplots(figsize=(8, 4))\n",
"\n",
"# Histograma\n",
"ax.hist(DEM.flatten(), edgecolor=\"black\", color=\"lightgreen\", bins=100, alpha=0.8)\n",
@@ -378,7 +395,7 @@
"fig, ax = plt.subplots(figsize=(9, 6))\n",
"\n",
"# Imagen\n",
- "ax.imshow(DEM, cmap=\"terrain\")\n",
+ "ax.imshow(DEM, cmap=\"gray\")\n",
"\n",
"# Texto\n",
"ax.set_title(\"Modelo digital de elevación\", fontsize=15)\n",
diff --git a/notebooks/pg303d_leafmap.ipynb b/notebooks/pg303d_leafmap.ipynb
index 4808df4..4233160 100644
--- a/notebooks/pg303d_leafmap.ipynb
+++ b/notebooks/pg303d_leafmap.ipynb
@@ -146,7 +146,7 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 1,
"id": "3870958f-eeb2-4835-8aa9-94f6b3200e7a",
"metadata": {
"tags": []
@@ -199,7 +199,7 @@
"outputs": [],
"source": [
"m = leafmap.Map(center=(-9, -75), zoom=5, width=950, height=500, google_map=\"TERRAIN\")\n",
- "m.add_raster(\"files/dem/peru_bedrock_60.tiff\")\n",
+ "m.add_raster(\"files/peru_60.tiff\")\n",
"m"
]
},
@@ -232,7 +232,7 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 4,
"id": "cdd47cd6-bcbf-4081-b55f-87a0e17630aa",
"metadata": {
"tags": []
@@ -244,12 +244,112 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 5,
"id": "1a37d11d-a332-4438-92b3-c913055dce3b",
"metadata": {
"tags": []
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "| \n", + " | pop_est | \n", + "continent | \n", + "name | \n", + "iso_a3 | \n", + "gdp_md_est | \n", + "geometry | \n", + "
|---|---|---|---|---|---|---|
| 0 | \n", + "920938 | \n", + "Oceania | \n", + "Fiji | \n", + "FJI | \n", + "8374.0 | \n", + "MULTIPOLYGON (((180.00000 -16.06713, 180.00000... | \n", + "
| 1 | \n", + "53950935 | \n", + "Africa | \n", + "Tanzania | \n", + "TZA | \n", + "150600.0 | \n", + "POLYGON ((33.90371 -0.95000, 34.07262 -1.05982... | \n", + "
| 2 | \n", + "603253 | \n", + "Africa | \n", + "W. Sahara | \n", + "ESH | \n", + "906.5 | \n", + "POLYGON ((-8.66559 27.65643, -8.66512 27.58948... | \n", + "
| 3 | \n", + "35623680 | \n", + "North America | \n", + "Canada | \n", + "CAN | \n", + "1674000.0 | \n", + "MULTIPOLYGON (((-122.84000 49.00000, -122.9742... | \n", + "
| 4 | \n", + "326625791 | \n", + "North America | \n", + "United States of America | \n", + "USA | \n", + "18560000.0 | \n", + "MULTIPOLYGON (((-122.84000 49.00000, -120.0000... | \n", + "