![\"logo\"](\"../images/cacheme.png\")
\n",
10 | "![\"logo\"](\"../images/aeropython_logo.png\"){kind=logo}
"
11 | ]
12 | },
13 | {
14 | "cell_type": "markdown",
15 | "metadata": {},
16 | "source": [
17 | "---"
18 | ]
19 | },
20 | {
21 | "cell_type": "markdown",
22 | "metadata": {},
23 | "source": [
24 | "# ¿Cómo seguir con Python?"
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {},
30 | "source": [
31 | "_A continuación, pretendemos dar algunas ideas sobre cómo seguir aprendiendo Python y sus posibles herramientas orientas a ciencia e ingeniería. \n",
32 | "También, hablaremos del ecosistema Python, de su comunidad y de cómo involucrarse y establecer contacto con otras personas interesadas en este lenguaje de programación.\n",
33 | "Por último, pondremos distintos enlaces a diferentes canales. _"
34 | ]
35 | },
36 | {
37 | "cell_type": "markdown",
38 | "metadata": {},
39 | "source": [
40 | "## Algunos libros y enlaces"
41 | ]
42 | },
43 | {
44 | "cell_type": "markdown",
45 | "metadata": {},
46 | "source": [
47 | "#### Introducción a Python\n",
48 | "\n",
49 | "* [\"Automate the Boring Stuff with Python\" by Al Sweigart](http://automatetheboringstuff.com/) \n",
50 | "(Free to read under a Creative Commons license) \n",
51 | "* [Recopilatorio de recursos \"Grupo de Iniciación de Python Madrid\"](https://python-madrid.github.io/learn-doc/)"
52 | ]
53 | },
54 | {
55 | "cell_type": "markdown",
56 | "metadata": {},
57 | "source": [
58 | "#### Ciencia, Ingeniería, Data Science\n",
59 | "* [\"Effective Computation in Physics\" by Anthony Scopatz, Kathryn Huff](http://shop.oreilly.com/product/0636920033424)\n",
60 | "* [\"Python Data Science Handbook\" by Jake VanderPlas](http://shop.oreilly.com/product/0636920034919) \n",
61 | "(contenido disponible en [GitHub](https://github.com/jakevdp/PythonDataScienceHandbook))"
62 | ]
63 | },
64 | {
65 | "cell_type": "markdown",
66 | "metadata": {},
67 | "source": [
68 | "## Ecosistema Python"
69 | ]
70 | },
71 | {
72 | "cell_type": "markdown",
73 | "metadata": {},
74 | "source": [
75 | "![\"logo\"](\"../images/tshirt_quote.jpg\")
"
76 | ]
77 | },
78 | {
79 | "cell_type": "markdown",
80 | "metadata": {},
81 | "source": [
82 | "#### Webs interesantes\n",
83 | "* [Python Software Foundation](https://www.python.org/)\n",
84 | "* [Pybonacci](http://www.pybonacci.org/)"
85 | ]
86 | },
87 | {
88 | "cell_type": "markdown",
89 | "metadata": {},
90 | "source": [
91 | "#### Comunidades interesantes y/o cercanas\n",
92 | "* [Python España](https://www.es.python.org/)\n",
93 | "* [Python Alicante](https://www.meetup.com/python_alc/)\n",
94 | "* [Cacheme](https://cacheme.org/)\n",
95 | "* [AeroPython](https://github.com/AeroPython)\n",
96 | "* [PyLadies Madrid](https://www.meetup.com/PyLadiesMadrid/)\n",
97 | "* [Otras comunidades](https://www.es.python.org/pages/comunidades.html)"
98 | ]
99 | },
100 | {
101 | "cell_type": "markdown",
102 | "metadata": {},
103 | "source": [
104 | "#### Pythonistas relevantes en Twitter\n",
105 | "https://twitter.com/AeroPython/lists/relevant-pythonistas"
106 | ]
107 | },
108 | {
109 | "cell_type": "markdown",
110 | "metadata": {},
111 | "source": [
112 | "#### Grupos de Telegram\n",
113 | "\n",
114 | "* Python España\n",
115 | "* Python Alicante\n",
116 | "* Python Científico\n",
117 | "* AeroPython"
118 | ]
119 | },
120 | {
121 | "cell_type": "markdown",
122 | "metadata": {},
123 | "source": [
124 | "###### Juan Luis Cano, Álex Sáez, Mabel Delgado"
125 | ]
126 | },
127 | {
128 | "cell_type": "markdown",
129 | "metadata": {},
130 | "source": [
131 | "---\n",
132 | "_Las siguientes celdas contienen configuración del Notebook_\n",
133 | "\n",
134 | "_Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como [seguro](http://ipython.org/ipython-doc/dev/notebook/security.html)_\n",
135 | "\n",
136 | " File > Trusted Notebook"
137 | ]
138 | },
139 | {
140 | "cell_type": "code",
141 | "execution_count": 8,
142 | "metadata": {},
143 | "outputs": [
144 | {
145 | "data": {
146 | "text/html": [
147 | "/* This template is inspired in the one used by Lorena Barba\n",
148 | "in the numerical-mooc repository: https://github.com/numerical-mooc/numerical-mooc\n",
149 | "We thank her work and hope you also enjoy the look of the notobooks with this style */\n",
150 | "\n",
151 | "\n",
152 | "\n",
153 | "\n",
291 | "\n"
307 | ],
308 | "text/plain": [
309 | "\n",
10 | ""
11 | ]
12 | },
13 | {
14 | "cell_type": "markdown",
15 | "metadata": {},
16 | "source": [
17 | "---"
18 | ]
19 | },
20 | {
21 | "cell_type": "markdown",
22 | "metadata": {},
23 | "source": [
24 | "# Pandas: Funciones rolling y operaciones con DataFrames"
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {},
30 | "source": [
31 | "En este notebook trabajaremos sobre los mismos datos que la introducción a pandas. Veremos como usar el método rolling para obtener resultados como la media móvil, la desviación típica móvil... Además veremos como agrupar los datos usando `groupby` y cómo pivotar tablas."
32 | ]
33 | },
34 | {
35 | "cell_type": "markdown",
36 | "metadata": {},
37 | "source": [
38 | "## Cargando los datos"
39 | ]
40 | },
41 | {
42 | "cell_type": "code",
43 | "execution_count": null,
44 | "metadata": {},
45 | "outputs": [],
46 | "source": []
47 | },
48 | {
49 | "cell_type": "code",
50 | "execution_count": null,
51 | "metadata": {},
52 | "outputs": [],
53 | "source": [
54 | "# carga de los datos: data_all\n",
55 | "# columnas: [0, 1, 3, 4, 5, 6, 8, 10, 11, 12, 13]\n",
56 | "# ['dir', 'date', 'name', 'precip', 'pmax', 'pmin', 'mag_max', 'tmax', 'tmed', 'tmin', 'mag_med']"
57 | ]
58 | },
59 | {
60 | "cell_type": "markdown",
61 | "metadata": {},
62 | "source": [
63 | "Para acordarnos de cómo parsear las fechas: http://strftime.org/
"
64 | ]
65 | },
66 | {
67 | "cell_type": "code",
68 | "execution_count": null,
69 | "metadata": {},
70 | "outputs": [],
71 | "source": [
72 | "# dejamos en data sólo alicante/alacant"
73 | ]
74 | },
75 | {
76 | "cell_type": "markdown",
77 | "metadata": {},
78 | "source": [
79 | "### Funciones \"rolling\" "
80 | ]
81 | },
82 | {
83 | "cell_type": "markdown",
84 | "metadata": {},
85 | "source": [
86 | "Ya sabemos obtener representaciones gráficas de nuestros de datos. Visualicemos, por ejemplo, la evolución de la temperatura media a lo largo de los años 2015 y 2016:"
87 | ]
88 | },
89 | {
90 | "cell_type": "code",
91 | "execution_count": null,
92 | "metadata": {},
93 | "outputs": [],
94 | "source": [
95 | "# temperatua media en el 205-2016"
96 | ]
97 | },
98 | {
99 | "cell_type": "markdown",
100 | "metadata": {},
101 | "source": [
102 | "Se puede apreciar la oscilación a lo largo del año. Sin embargo, las variaciones locales de temperatura de determinados días \"ensucian\" nuestra representación. Una opción es \"suavizar\" la curva utilizando una media móvil"
103 | ]
104 | },
105 | {
106 | "cell_type": "markdown",
107 | "metadata": {},
108 | "source": [
109 | "Pandas proporciona métodos para calcular magnitudes como medias móviles usando el método `rolling`:"
110 | ]
111 | },
112 | {
113 | "cell_type": "code",
114 | "execution_count": null,
115 | "metadata": {},
116 | "outputs": [],
117 | "source": [
118 | "# calcular la media de la columna tmed"
119 | ]
120 | },
121 | {
122 | "cell_type": "code",
123 | "execution_count": null,
124 | "metadata": {},
125 | "outputs": [],
126 | "source": [
127 | "# media centrada (semanal/mensual/trimestral)"
128 | ]
129 | },
130 | {
131 | "cell_type": "code",
132 | "execution_count": null,
133 | "metadata": {},
134 | "outputs": [],
135 | "source": [
136 | "# pintar media centrada (semanal/mensual/trimestral)"
137 | ]
138 | },
139 | {
140 | "cell_type": "markdown",
141 | "metadata": {},
142 | "source": [
143 | "## Creando agrupaciones "
144 | ]
145 | },
146 | {
147 | "cell_type": "markdown",
148 | "metadata": {},
149 | "source": [
150 | "En muchas ocasiones queremos realizar agrupaciones de datos en base a determinados valores como son fechas, o etiquetas (por ejemplo, datos que pertenecen a un mismo ensayo o lugar)."
151 | ]
152 | },
153 | {
154 | "cell_type": "code",
155 | "execution_count": null,
156 | "metadata": {},
157 | "outputs": [],
158 | "source": [
159 | "# agrupar por estación metereológica"
160 | ]
161 | },
162 | {
163 | "cell_type": "code",
164 | "execution_count": null,
165 | "metadata": {},
166 | "outputs": [],
167 | "source": [
168 | "# media"
169 | ]
170 | },
171 | {
172 | "cell_type": "code",
173 | "execution_count": null,
174 | "metadata": {},
175 | "outputs": [],
176 | "source": [
177 | "# media y desviación estándar"
178 | ]
179 | },
180 | {
181 | "cell_type": "markdown",
182 | "metadata": {},
183 | "source": [
184 | "### Creando agrupaciones: analizando el mes típico"
185 | ]
186 | },
187 | {
188 | "cell_type": "markdown",
189 | "metadata": {},
190 | "source": [
191 | "En muchas ocasiones queremos realizar agrupaciones de datos en base a determinados valores como son fechas, o etiquetas (por ejemplo, datos que pertenecen a un mismo ensayo o lugar).\n",
192 | "\n",
193 | "En este caso, imaginemos que nos interesa obtener una representación del \"mes típico\" o \"día típico\""
194 | ]
195 | },
196 | {
197 | "cell_type": "markdown",
198 | "metadata": {},
199 | "source": [
200 | "Podemos agrupar nuestros datos utilizando `groupby`:"
201 | ]
202 | },
203 | {
204 | "cell_type": "code",
205 | "execution_count": null,
206 | "metadata": {},
207 | "outputs": [],
208 | "source": [
209 | "# agruparemos por año y mes: creemos dos columnas nuevas"
210 | ]
211 | },
212 | {
213 | "cell_type": "code",
214 | "execution_count": null,
215 | "metadata": {},
216 | "outputs": [],
217 | "source": [
218 | "# creamos la agrupación"
219 | ]
220 | },
221 | {
222 | "cell_type": "code",
223 | "execution_count": null,
224 | "metadata": {},
225 | "outputs": [],
226 | "source": [
227 | "# podemos ver los grupos que se han creado"
228 | ]
229 | },
230 | {
231 | "cell_type": "markdown",
232 | "metadata": {},
233 | "source": [
234 | "Con estos grupos podemos hacer hacer varias cosas:\n",
235 | "\n",
236 | "* Acceder a sus datos individualmente (por ejemplo, comprobar qué pasó cada día de marzo de 2016) \n",
237 | "* Realizar una reducción de datos, para comparar diversos grupos (por, ejemplo caracterizar el tiempo de cada mes a lo largo de los años)"
238 | ]
239 | },
240 | {
241 | "cell_type": "code",
242 | "execution_count": null,
243 | "metadata": {},
244 | "outputs": [],
245 | "source": [
246 | "# accedemos a un grupo"
247 | ]
248 | },
249 | {
250 | "cell_type": "code",
251 | "execution_count": null,
252 | "metadata": {},
253 | "outputs": [],
254 | "source": [
255 | "# hacemos una agregación de los datos:"
256 | ]
257 | },
258 | {
259 | "cell_type": "markdown",
260 | "metadata": {},
261 | "source": [
262 | "### Pivotando tablas"
263 | ]
264 | },
265 | {
266 | "cell_type": "markdown",
267 | "metadata": {},
268 | "source": [
269 | "En ocasiones podemos querer ver nuestros datos de forma diferente o necesitamos organizarlos así para utilizar determinadas funciones de `pandas`. Una necesidad típica es la de pivotar una tabla.\n",
270 | "\n",
271 | " Imagina que queremos acceder a los mismos datos que en el caso anterior, pero que ahora queremos ver los años en las filas y para cada variable (TMAX, TMED...) los calores de cada mes en una columna. ¿Cómo lo harías?"
272 | ]
273 | },
274 | {
275 | "cell_type": "code",
276 | "execution_count": null,
277 | "metadata": {},
278 | "outputs": [],
279 | "source": [
280 | "# dejar los años como índices y ver la media mensual en cada columna"
281 | ]
282 | },
283 | {
284 | "cell_type": "markdown",
285 | "metadata": {},
286 | "source": [
287 | "La línea anterior no es sencilla y no se escribe de una sola vez sin errores (sobre todo si estás empezando). Esto es una ejemplo de que `pandas` es una librería potente, pero que lleva tiempo aprender. Pasarás muchas horas peleando contra problemas de este tipo, pero afortunadamente mucha gente lo ha pasado mal antes y su experiencia ha quedado plasmada en cientos de **preguntas de `stack overflow`** y en la **documentación de `pandas`**"
288 | ]
289 | },
290 | {
291 | "cell_type": "code",
292 | "execution_count": null,
293 | "metadata": {},
294 | "outputs": [],
295 | "source": []
296 | },
297 | {
298 | "cell_type": "markdown",
299 | "metadata": {},
300 | "source": [
301 | "#### Otro ejemplo"
302 | ]
303 | },
304 | {
305 | "cell_type": "code",
306 | "execution_count": null,
307 | "metadata": {},
308 | "outputs": [],
309 | "source": []
310 | },
311 | {
312 | "cell_type": "code",
313 | "execution_count": null,
314 | "metadata": {},
315 | "outputs": [],
316 | "source": [
317 | "# seleccionando sólo una estación"
318 | ]
319 | },
320 | {
321 | "cell_type": "code",
322 | "execution_count": null,
323 | "metadata": {},
324 | "outputs": [],
325 | "source": [
326 | "# agrupando por estación y mes"
327 | ]
328 | },
329 | {
330 | "cell_type": "code",
331 | "execution_count": null,
332 | "metadata": {},
333 | "outputs": [],
334 | "source": [
335 | "# pivotando para que el mes sea el índice"
336 | ]
337 | },
338 | {
339 | "cell_type": "code",
340 | "execution_count": null,
341 | "metadata": {},
342 | "outputs": [],
343 | "source": [
344 | "# pintándolo"
345 | ]
346 | },
347 | {
348 | "cell_type": "markdown",
349 | "metadata": {},
350 | "source": [
351 | "### Visualizaciones especiales"
352 | ]
353 | },
354 | {
355 | "cell_type": "markdown",
356 | "metadata": {},
357 | "source": [
358 | "#### scatter"
359 | ]
360 | },
361 | {
362 | "cell_type": "code",
363 | "execution_count": null,
364 | "metadata": {},
365 | "outputs": [],
366 | "source": [
367 | "# scatter_matrix"
368 | ]
369 | },
370 | {
371 | "cell_type": "markdown",
372 | "metadata": {},
373 | "source": [
374 | "#### lag_plot "
375 | ]
376 | },
377 | {
378 | "cell_type": "code",
379 | "execution_count": null,
380 | "metadata": {},
381 | "outputs": [],
382 | "source": []
383 | },
384 | {
385 | "cell_type": "code",
386 | "execution_count": null,
387 | "metadata": {},
388 | "outputs": [],
389 | "source": []
390 | },
391 | {
392 | "cell_type": "markdown",
393 | "metadata": {},
394 | "source": [
395 | "---\n",
396 | "\n",
397 | "Hemos aprendido:\n",
398 | "* A utilizar las funciones rolling\n",
399 | "* A agrupar datos de un DataFrame utilizando sus columnas:\n",
400 | " - A agrupar con más de una variable\n",
401 | " - A acceder a distintos grupos\n",
402 | " - A obtener una reducción de datos para cada grupo\n",
403 | "* A salvar nuestros datos\n",
404 | "* A utilizar algunas representaciones especiales"
405 | ]
406 | },
407 | {
408 | "cell_type": "markdown",
409 | "metadata": {},
410 | "source": [
411 | "###### Juan Luis Cano, Alejandro Sáez, Mabel Delgado"
412 | ]
413 | },
414 | {
415 | "cell_type": "markdown",
416 | "metadata": {},
417 | "source": [
418 | "---\n",
419 | "_Las siguientes celdas contienen configuración del Notebook_\n",
420 | "\n",
421 | "_Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como [seguro](http://ipython.org/ipython-doc/dev/notebook/security.html)_\n",
422 | "\n",
423 | " File > Trusted Notebook"
424 | ]
425 | },
426 | {
427 | "cell_type": "code",
428 | "execution_count": null,
429 | "metadata": {},
430 | "outputs": [],
431 | "source": [
432 | "# esta celda da el estilo al notebook"
433 | ]
434 | }
435 | ],
436 | "metadata": {
437 | "anaconda-cloud": {},
438 | "kernelspec": {
439 | "display_name": "Python 3",
440 | "language": "python",
441 | "name": "python3"
442 | },
443 | "language_info": {
444 | "codemirror_mode": {
445 | "name": "ipython",
446 | "version": 3
447 | },
448 | "file_extension": ".py",
449 | "mimetype": "text/x-python",
450 | "name": "python",
451 | "nbconvert_exporter": "python",
452 | "pygments_lexer": "ipython3",
453 | "version": "3.6.4"
454 | }
455 | },
456 | "nbformat": 4,
457 | "nbformat_minor": 1
458 | }
459 |
--------------------------------------------------------------------------------
/notebooks_vacios/0001_Introduccion.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Curso de introducción al análisis y modelado de datos con Python \n",
8 | "\n",
9 | "\n",
10 | ""
11 | ]
12 | },
13 | {
14 | "cell_type": "markdown",
15 | "metadata": {},
16 | "source": [
17 | "---"
18 | ]
19 | },
20 | {
21 | "cell_type": "markdown",
22 | "metadata": {},
23 | "source": [
24 | "# Introducción"
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {},
30 | "source": [
31 | "A continuación, haremos una rápida introducción al lenguaje Python y al intérprete IPython, así como a Jupyter Notebook, la herramienta que vamos a usar en este curso.\n",
32 | "Detallaremos cuáles son las bondades de Python frente a otros lenguajes, y veremos como ejecutar un script y cuáles son los tipos y estructuras básicas de este lenguaje.\n",
33 | "\n",
34 | "**¡Comenzamos!**\n",
35 | "\n",
36 | "---"
37 | ]
38 | },
39 | {
40 | "cell_type": "markdown",
41 | "metadata": {},
42 | "source": [
43 | "![](\"../images/logo_python_letras.png\"){kind=logo}
\n",
10 | ""
11 | ]
12 | },
13 | {
14 | "cell_type": "markdown",
15 | "metadata": {},
16 | "source": [
17 | "---"
18 | ]
19 | },
20 | {
21 | "cell_type": "markdown",
22 | "metadata": {},
23 | "source": [
24 | "# Scikit-Learn: Introducción y Problema de Clasificación."
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {},
30 | "source": [
31 | "En los últimos tiempos se habla mucho de _machine learning_, _deep learning_, _reinforcement learning_, muchas más cosas que contienen la palabra _learning_ y, por supuesto, _Big Data_. Todo ello motivado por los avances en capacidad de cálculo de los últimos años, y la popularización de lenguajes de alto nivel, que han permitido entrar de lleno en la fiebre de hacer que las máquinas aprendan. \n",
32 | "\n",
33 | "En esta clase veremos una breve introducción al machine learning, y aprenderemos a utilizar el paquete `scikit-learn` de Python, con el objetivo de crear modelos predictivos a partir de nuestros datos de una manera rápida y sencilla. En concreto, veremos cómo resolver el problema de clasificación."
34 | ]
35 | },
36 | {
37 | "cell_type": "markdown",
38 | "metadata": {},
39 | "source": [
40 | "## ¿En qué consiste el machine learning?"
41 | ]
42 | },
43 | {
44 | "cell_type": "markdown",
45 | "metadata": {},
46 | "source": [
47 | "El machine learning es una rama de la inteligencia artificial, cuyo objetivo es desarrollar técnicas para enseñar a las máquinas a llevar a cabo ciertas tareas, mostrándoles previamente algunos ejemplos y cómo o cómo no llevar a cabo la tarea de forma exitosa. Por lo tanto, se busca crear programas capaces de generalizar comportamientos a partir de una información suministrada en forma de ejemplos, aprendiendo de ellos, y sin que hayan sido programados a mano punto a punto y detalle a detalle para realizar exitosamente esa tarea.\n",
48 | "\n",
49 | "Los diferentes algoritmos de aprendizaje automático, se agrupan en dos grandes grupos:\n",
50 | "\n",
51 | "* **Aprendizaje supervisado**, cuando tengo datos _etiquetados_, es decir: conozco la variable a predecir de un cierto número de observaciones. Pasándole esta información al algoritmo, este será capaz de predecir dicha variable cuando reciba observaciones nuevas. Por lo tanto, se produce una función que establece una correspondencia entre las entradas y las salidas deseadas del sistema. \n",
52 | "Además, dentro de este grupo, tendremos dos tipos de problemas dependiendo de la naturaleza de la variable a predecir:\n",
53 | " - **Clasificación**, si la variable a predecir es discreta o categórica (sí/no, color de ojos, etc)\n",
54 | " - **Regresión**, si la variable a predecir es continua.\n",
55 | "\n",
56 | " \n",
57 | "* **Aprendizaje no supervisado**, cuando no tenemos datos _etiquetados_ y por tanto no tengo ninguna información _a priori_ sobre las categorías de esos ejemplos. Por lo tanto, en este caso, los algoritmos deben ser capaces de descubrir patrones en los datos y agruparlos. Si bien, tendremos que manualmente inspeccionar el resultado después y ver qué sentido podemos darle a esos grupos.\n",
58 | "Dentro de este grupo podemos distinguir:\n",
59 | " - **Clustering**, agrupamiento automáticos de objetos similares en sets..\n",
60 | " - **Reducción de la dimensionalidad**, reducir el número de variables aleatorias a considerar.\n",
61 | "\n",
62 | "En función de la naturaleza de nuestro problema, `scikit-learn` proporciona una gran variedad de algoritmos que podemos elegir.\n",
63 | "\n",
64 | ""
65 | ]
66 | },
67 | {
68 | "cell_type": "markdown",
69 | "metadata": {},
70 | "source": [
71 | "## ¿Qué es scikit-learn?"
72 | ]
73 | },
74 | {
75 | "cell_type": "markdown",
76 | "metadata": {},
77 | "source": [
78 | "`scikit-learn` es una libreria que nos proporciona un conjunto de algoritmos de machine learning, que incluyen regresión, clasificación, reducción de la dimensionalidad y clustering.\n",
79 | "\n",
80 | "Se articula sobre la librería `NumPy` y `SciPy` y nos permite enfrentarnos a la resolución de estos problemas a través de un a APi limpia y bien hecha. En ese sentido, se trabaja igual que con SciPy, es decir, se importan explícitamente los módulos que se necesitan de la librería.\n",
81 | "\n",
82 | "Hay que indicar que no está especialmente diseñada para datasets super grandes, pero hay cada vez más mejoras en ese área. "
83 | ]
84 | },
85 | {
86 | "cell_type": "code",
87 | "execution_count": 1,
88 | "metadata": {},
89 | "outputs": [
90 | {
91 | "data": {
92 | "text/html": [
93 | ""
94 | ],
95 | "text/plain": [
96 | "Tenemos que hacer este `reshape` para transformar nuestro vector en una matriz de columnas. Rara vez tendremos que repetir este paso, puesto que en la práctica siempre tendremos varias variables.
"
207 | ]
208 | },
209 | {
210 | "cell_type": "code",
211 | "execution_count": null,
212 | "metadata": {},
213 | "outputs": [],
214 | "source": []
215 | },
216 | {
217 | "cell_type": "markdown",
218 | "metadata": {},
219 | "source": [
220 | "El siguiente paso es ajustar nuestro modelo."
221 | ]
222 | },
223 | {
224 | "cell_type": "code",
225 | "execution_count": null,
226 | "metadata": {},
227 | "outputs": [],
228 | "source": []
229 | },
230 | {
231 | "cell_type": "markdown",
232 | "metadata": {},
233 | "source": [
234 | "Y una vez hecho esto, ya podemos calcular predicciones para los mismos datos"
235 | ]
236 | },
237 | {
238 | "cell_type": "code",
239 | "execution_count": null,
240 | "metadata": {},
241 | "outputs": [],
242 | "source": []
243 | },
244 | {
245 | "cell_type": "markdown",
246 | "metadata": {},
247 | "source": [
248 | "Ahora, lo que vamos a hacer es calcular un tipo de error asocido a esta predicción, usando el módulo `sklearn.metrics`:"
249 | ]
250 | },
251 | {
252 | "cell_type": "code",
253 | "execution_count": null,
254 | "metadata": {},
255 | "outputs": [],
256 | "source": []
257 | },
258 | {
259 | "cell_type": "code",
260 | "execution_count": null,
261 | "metadata": {},
262 | "outputs": [],
263 | "source": []
264 | },
265 | {
266 | "cell_type": "markdown",
267 | "metadata": {},
268 | "source": [
269 | "Y ahora predecimos con datos nuevos y vemos el resultado"
270 | ]
271 | },
272 | {
273 | "cell_type": "code",
274 | "execution_count": null,
275 | "metadata": {},
276 | "outputs": [],
277 | "source": []
278 | },
279 | {
280 | "cell_type": "code",
281 | "execution_count": null,
282 | "metadata": {},
283 | "outputs": [],
284 | "source": []
285 | },
286 | {
287 | "cell_type": "code",
288 | "execution_count": null,
289 | "metadata": {
290 | "scrolled": true
291 | },
292 | "outputs": [],
293 | "source": []
294 | },
295 | {
296 | "cell_type": "markdown",
297 | "metadata": {},
298 | "source": [
299 | "### Problema de Clasificación"
300 | ]
301 | },
302 | {
303 | "cell_type": "markdown",
304 | "metadata": {},
305 | "source": [
306 | "En `scikit-learn` tenemos disponibles muchos datasets clásicos de ejemplo que podemos utilizar para practicar. Uno de ellos es el dataset MNIST, que consiste en imágenes escaneadas de números escritos a mano por funcionarios de los EEUU, y que pueden ser de 10 posibles clases diferentes."
307 | ]
308 | },
309 | {
310 | "cell_type": "markdown",
311 | "metadata": {},
312 | "source": [
313 | "Para cargarlo, importamos la función correspondiente de `sklearn.datasets`:"
314 | ]
315 | },
316 | {
317 | "cell_type": "code",
318 | "execution_count": null,
319 | "metadata": {},
320 | "outputs": [],
321 | "source": [
322 | "# importamos los datasets"
323 | ]
324 | },
325 | {
326 | "cell_type": "markdown",
327 | "metadata": {},
328 | "source": [
329 | "Un dataset es un objeto parecido a un diccionario que almacena los datos y algunos metadatos asociados."
330 | ]
331 | },
332 | {
333 | "cell_type": "code",
334 | "execution_count": null,
335 | "metadata": {},
336 | "outputs": [],
337 | "source": [
338 | "# cargamos el dataset the digits que es con el que vamos a trabajar."
339 | ]
340 | },
341 | {
342 | "cell_type": "markdown",
343 | "metadata": {},
344 | "source": [
345 | "Los datos de las muestras, están almacenados en `.data`, que siempre es un array 2D de `n_samples` por `n_features`."
346 | ]
347 | },
348 | {
349 | "cell_type": "code",
350 | "execution_count": null,
351 | "metadata": {},
352 | "outputs": [],
353 | "source": [
354 | "# vemos el contenido de los datos"
355 | ]
356 | },
357 | {
358 | "cell_type": "code",
359 | "execution_count": null,
360 | "metadata": {},
361 | "outputs": [],
362 | "source": [
363 | "# vemos cuantas muestras y características tenemos "
364 | ]
365 | },
366 | {
367 | "cell_type": "markdown",
368 | "metadata": {},
369 | "source": [
370 | "Tenemos 1797 muestras, y cada una está caracterizada por 64 valores. En este caso, cada muestra original consiste en una imagen de (8,8), es decir, 64 características, a la que se puede acceder por índice, por ejemplo:"
371 | ]
372 | },
373 | {
374 | "cell_type": "code",
375 | "execution_count": null,
376 | "metadata": {},
377 | "outputs": [],
378 | "source": [
379 | "# acceso a una muestra"
380 | ]
381 | },
382 | {
383 | "cell_type": "markdown",
384 | "metadata": {},
385 | "source": [
386 | "Por otro lado, en el caso de problemas supervisados, se almacenan en `.target` una o más variables de respuesta, que en nuestro ejemplo consisten en un número para cada muestra, y que correponde con el dígito que estamos intentando aprender."
387 | ]
388 | },
389 | {
390 | "cell_type": "code",
391 | "execution_count": null,
392 | "metadata": {},
393 | "outputs": [],
394 | "source": [
395 | "# vemos los targets"
396 | ]
397 | },
398 | {
399 | "cell_type": "code",
400 | "execution_count": null,
401 | "metadata": {},
402 | "outputs": [],
403 | "source": [
404 | "# vemos cuantos targets tenemos (mismos que muestras)"
405 | ]
406 | },
407 | {
408 | "cell_type": "markdown",
409 | "metadata": {},
410 | "source": [
411 | "Además, podemos ver cuáles son los posibles valores que toman estos targets."
412 | ]
413 | },
414 | {
415 | "cell_type": "code",
416 | "execution_count": null,
417 | "metadata": {},
418 | "outputs": [],
419 | "source": []
420 | },
421 | {
422 | "cell_type": "markdown",
423 | "metadata": {},
424 | "source": [
425 | "Por último, podemos extraer información global sobre el dataset de la siguiente forma:"
426 | ]
427 | },
428 | {
429 | "cell_type": "code",
430 | "execution_count": null,
431 | "metadata": {},
432 | "outputs": [],
433 | "source": []
434 | },
435 | {
436 | "cell_type": "markdown",
437 | "metadata": {},
438 | "source": [
439 | "Ya tenemos los datos separados en matriz de características y vector de predicción. En este caso, tendremos 64 = 8x8 características (un valor numérico por cada pixel de la imagen) y una variable a predecir que será el número en sí y que irá de 0 a 8."
440 | ]
441 | },
442 | {
443 | "cell_type": "markdown",
444 | "metadata": {},
445 | "source": [
446 | "Vamos a visualizar una de las imágenes como ejemplo para hacernos una idea. "
447 | ]
448 | },
449 | {
450 | "cell_type": "code",
451 | "execution_count": null,
452 | "metadata": {},
453 | "outputs": [],
454 | "source": [
455 | "# elegimos por ejemplo los datos asociados a la muestra 42"
456 | ]
457 | },
458 | {
459 | "cell_type": "code",
460 | "execution_count": null,
461 | "metadata": {},
462 | "outputs": [],
463 | "source": [
464 | "# vemos qué número sabemos que almacena esta muestra"
465 | ]
466 | },
467 | {
468 | "cell_type": "code",
469 | "execution_count": null,
470 | "metadata": {},
471 | "outputs": [],
472 | "source": [
473 | "# hacemos un reshape a la muestra para poder represetnarla \n",
474 | "#(sabemos que viene en un array 1d, pero se corresponde con uno 2d de 8x8)"
475 | ]
476 | },
477 | {
478 | "cell_type": "code",
479 | "execution_count": null,
480 | "metadata": {},
481 | "outputs": [],
482 | "source": [
483 | "# pintamos el resultado\n",
484 | "# (si todo ha ido bien, deberíamos ver el valor indicado por label_num_ej)"
485 | ]
486 | },
487 | {
488 | "cell_type": "markdown",
489 | "metadata": {},
490 | "source": [
491 | "Ten en cuenta que nosotros sabemos qué número es cada imagen porque somos humanos y podemos leerlas. El ordenador lo sabe porque están etiquetadas, pero ¿qué pasa si viene una imagen nueva? \n",
492 | "\n",
493 | "El objetivo por lo tanto es, dada una imagen, predecir qué dígito representa, y como hemos indicado a la hora de explicar el proceso a seguir, el siguiente paso es construir un modelo de clasificación.\n",
494 | "\n",
495 | "Cada algoritmo está expuesto desde scikit-learn a través de un objeto `\"Estimador\"`. Por ejemplo, en este caso vamos a elegir un modelo de regresión logística:"
496 | ]
497 | },
498 | {
499 | "cell_type": "code",
500 | "execution_count": null,
501 | "metadata": {},
502 | "outputs": [],
503 | "source": [
504 | "# importamos el modelo"
505 | ]
506 | },
507 | {
508 | "cell_type": "code",
509 | "execution_count": null,
510 | "metadata": {},
511 | "outputs": [],
512 | "source": [
513 | "# creamos la instancia del modelo"
514 | ]
515 | },
516 | {
517 | "cell_type": "markdown",
518 | "metadata": {},
519 | "source": [
520 | "Una vez importado y creado, lo que hacemos es ajustar nuestro modelo con él, usando `fit`."
521 | ]
522 | },
523 | {
524 | "cell_type": "code",
525 | "execution_count": null,
526 | "metadata": {},
527 | "outputs": [],
528 | "source": [
529 | "# ajustamos el modelo"
530 | ]
531 | },
532 | {
533 | "cell_type": "markdown",
534 | "metadata": {},
535 | "source": [
536 | "Y tras ajustar el modelo, vamos a calcular sus predicciones para los mismos datos de entrenamiento, usando `predict`."
537 | ]
538 | },
539 | {
540 | "cell_type": "code",
541 | "execution_count": null,
542 | "metadata": {},
543 | "outputs": [],
544 | "source": []
545 | },
546 | {
547 | "cell_type": "markdown",
548 | "metadata": {},
549 | "source": [
550 | "Por últimos, vamos a comparar esas predicciones con los datos reales, para ver qué tal ha sido el ajuste. Para ello usamos `sklearn.metrics` para medir la eficacia del algoritmo."
551 | ]
552 | },
553 | {
554 | "cell_type": "code",
555 | "execution_count": null,
556 | "metadata": {},
557 | "outputs": [],
558 | "source": []
559 | },
560 | {
561 | "cell_type": "code",
562 | "execution_count": null,
563 | "metadata": {},
564 | "outputs": [],
565 | "source": []
566 | },
567 | {
568 | "cell_type": "markdown",
569 | "metadata": {},
570 | "source": [
571 | "¡Parece que hemos acertado prácticamente todas! Más tarde volveremos sobre este porcentaje de éxito, que bien podría ser engañoso. De momento, representemos otra medida de éxito que es la matriz de confusión, y que nos indica el nñumero de observaciones Cij, que sabemos que tendrían que ir en el grupo i, pero que que se ha predecido que están en el grupo j."
572 | ]
573 | },
574 | {
575 | "cell_type": "code",
576 | "execution_count": null,
577 | "metadata": {},
578 | "outputs": [],
579 | "source": []
580 | },
581 | {
582 | "cell_type": "code",
583 | "execution_count": null,
584 | "metadata": {},
585 | "outputs": [],
586 | "source": []
587 | },
588 | {
589 | "cell_type": "markdown",
590 | "metadata": {},
591 | "source": [
592 | "¡Y ya está! Lo básico de `scikit-learn` está aquí. Lo próximo será usar diferentes tipos de modelos y examinar con rigor su rendimiento para poder seleccionar el que mejor funcione para nuestros datos."
593 | ]
594 | },
595 | {
596 | "cell_type": "markdown",
597 | "metadata": {},
598 | "source": [
599 | "---\n",
600 | "Hemos aprendido:\n",
601 | "* En que consiste el machine learning.\n",
602 | "* Como empezar a usar la librería scikit-learn\n",
603 | "* Resolver un problema de clasificación y otro de regresión."
604 | ]
605 | },
606 | {
607 | "cell_type": "markdown",
608 | "metadata": {},
609 | "source": [
610 | "###### Juan Luis Cano, Alejandro Sáez, Mabel Delgado"
611 | ]
612 | },
613 | {
614 | "cell_type": "markdown",
615 | "metadata": {},
616 | "source": [
617 | "---\n",
618 | "_Las siguientes celdas contienen configuración del Notebook_\n",
619 | "\n",
620 | "_Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como [seguro](http://ipython.org/ipython-doc/dev/notebook/security.html)_\n",
621 | "\n",
622 | " File > Trusted Notebook"
623 | ]
624 | },
625 | {
626 | "cell_type": "code",
627 | "execution_count": null,
628 | "metadata": {},
629 | "outputs": [],
630 | "source": [
631 | "# esta celda da el estilo al notebook"
632 | ]
633 | }
634 | ],
635 | "metadata": {
636 | "kernelspec": {
637 | "display_name": "Python 3",
638 | "language": "python",
639 | "name": "python3"
640 | },
641 | "language_info": {
642 | "codemirror_mode": {
643 | "name": "ipython",
644 | "version": 3
645 | },
646 | "file_extension": ".py",
647 | "mimetype": "text/x-python",
648 | "name": "python",
649 | "nbconvert_exporter": "python",
650 | "pygments_lexer": "ipython3",
651 | "version": "3.6.4"
652 | }
653 | },
654 | "nbformat": 4,
655 | "nbformat_minor": 2
656 | }
657 |
--------------------------------------------------------------------------------
/notebooks/zz-AEMET-get_data.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# API-REST: AEMET OPEN DATA "
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "En este notebook veremos otro ejemplo de uso de la api open data de AEMET. En este caso obtendremos parámetros medidos por una estación meteorológica."
15 | ]
16 | },
17 | {
18 | "cell_type": "code",
19 | "execution_count": 1,
20 | "metadata": {},
21 | "outputs": [],
22 | "source": [
23 | "import requests\n",
24 | "import datetime\n",
25 | "import time"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": 2,
31 | "metadata": {},
32 | "outputs": [],
33 | "source": [
34 | "import urllib3\n",
35 | "urllib3.disable_warnings()"
36 | ]
37 | },
38 | {
39 | "cell_type": "code",
40 | "execution_count": 3,
41 | "metadata": {},
42 | "outputs": [],
43 | "source": [
44 | "# Cargamos la api key \n",
45 | "# Get API KEY in AEMET: https://opendata.aemet.es/centrodedescargas/inicio\n",
46 | "api_key = open(\"../../apikey-aemet.txt\").read().rstrip()\n",
47 | "querystring = {\"api_key\": api_key}"
48 | ]
49 | },
50 | {
51 | "cell_type": "code",
52 | "execution_count": 4,
53 | "metadata": {},
54 | "outputs": [],
55 | "source": [
56 | "def generate_chunks(start_date, final_date, step):\n",
57 | " day_step = datetime.timedelta(days=1)\n",
58 | " \n",
59 | " next_date = start_date + step\n",
60 | " \n",
61 | " while next_date < final_date:\n",
62 | " yield (start_date, next_date)\n",
63 | " start_date = next_date + day_step\n",
64 | " next_date = start_date + step\n",
65 | " \n",
66 | " yield (start_date, final_date)"
67 | ]
68 | },
69 | {
70 | "cell_type": "code",
71 | "execution_count": 5,
72 | "metadata": {},
73 | "outputs": [
74 | {
75 | "data": {
76 | "text/plain": [
77 | "[(datetime.datetime(2017, 1, 1, 0, 0), datetime.datetime(2017, 1, 31, 0, 0)),\n",
78 | " (datetime.datetime(2017, 2, 1, 0, 0), datetime.datetime(2017, 3, 3, 0, 0)),\n",
79 | " (datetime.datetime(2017, 3, 4, 0, 0), datetime.datetime(2017, 3, 15, 0, 0))]"
80 | ]
81 | },
82 | "execution_count": 5,
83 | "metadata": {},
84 | "output_type": "execute_result"
85 | }
86 | ],
87 | "source": [
88 | "start_date = datetime.datetime(2017, 1, 1, 0, 0, 0)\n",
89 | "final_date = datetime.datetime(2017, 3, 15, 0, 0, 0)\n",
90 | "step = datetime.timedelta(days=30)\n",
91 | "list(generate_chunks(start_date, final_date, step))"
92 | ]
93 | },
94 | {
95 | "cell_type": "code",
96 | "execution_count": 6,
97 | "metadata": {},
98 | "outputs": [],
99 | "source": [
100 | "def get_daily_data_url(start, end, station):\n",
101 | " url = (\"https://opendata.aemet.es/opendata/api/valores/climatologicos/diarios/datos/\"\n",
102 | " \"fechaini/{start}/fechafin/{end}/estacion/{station}\".format(\n",
103 | " start=start_date.strftime('%Y-%m-%dT%H:%M:%SUTC'),\n",
104 | " end=final_date.strftime('%Y-%m-%dT%H:%M:%SUTC'),\n",
105 | " station=station)\n",
106 | " )\n",
107 | " return url"
108 | ]
109 | },
110 | {
111 | "cell_type": "code",
112 | "execution_count": 7,
113 | "metadata": {},
114 | "outputs": [],
115 | "source": [
116 | "def make_request(url):\n",
117 | " request_again = True\n",
118 | " sleep_secs = 1\n",
119 | " while request_again:\n",
120 | " r = requests.get(url, params=querystring, verify=False)\n",
121 | " print(r)\n",
122 | " if r.status_code == requests.codes.OK:\n",
123 | " request_again = False\n",
124 | " data_url = r.json()['datos']\n",
125 | " r_data = requests.get(data_url, params=querystring, verify=False)\n",
126 | " raw_data = r_data.json()\n",
127 | " else:\n",
128 | " print(f\"failed, sleep {sleep_secs}s and try again\")\n",
129 | " time.sleep(sleep_secs)\n",
130 | " sleep_secs += 1\n",
131 | " \n",
132 | " return raw_data"
133 | ]
134 | },
135 | {
136 | "cell_type": "code",
137 | "execution_count": 8,
138 | "metadata": {},
139 | "outputs": [
140 | {
141 | "data": {
142 | "text/plain": [
143 | "'https://opendata.aemet.es/opendata/api/valores/climatologicos/diarios/datos/fechaini/2017-01-01T00%3A00%3A00UTC/fechafin/2017-01-30T00%3A00%3A00UTC/estacion/8025'"
144 | ]
145 | },
146 | "execution_count": 8,
147 | "metadata": {},
148 | "output_type": "execute_result"
149 | }
150 | ],
151 | "source": [
152 | "(\"https://opendata.aemet.es/opendata/api/valores/climatologicos/diarios/datos/\"\n",
153 | " \"fechaini/2017-01-01T00%3A00%3A00UTC/fechafin/2017-01-30T00%3A00%3A00UTC/estacion/8025\")"
154 | ]
155 | },
156 | {
157 | "cell_type": "code",
158 | "execution_count": 9,
159 | "metadata": {},
160 | "outputs": [
161 | {
162 | "name": "stdout",
163 | "output_type": "stream",
164 | "text": [
165 | "https://opendata.aemet.es/opendata/api/valores/climatologicos/diarios/datos/fechaini/2015-01-01T00:00:00UTC/fechafin/2015-01-31T00:00:00UTC/estacion/8025,8019,08370,7247X\n",
166 | "\n",
358 | "\n",
371 | "\n",
372 | " \n",
373 | "
\n",
515 | "
"
516 | ],
517 | "text/plain": [
518 | " altitud dir fecha horaPresMax horaPresMin horaracha horatmax \\\n",
519 | "0 81.0 14.0 2015-01-01 Varias 00 14:00 13:20 \n",
520 | "1 575.0 5.0 2015-01-01 NaN NaN 06:00 15:00 \n",
521 | "2 43.0 NaN 2015-01-01 Varias 00 NaN 12:46 \n",
522 | "3 81.0 19.0 2015-01-02 11 04 14:00 14:00 \n",
523 | "4 575.0 99.0 2015-01-02 NaN NaN Varias 14:30 \n",
524 | "\n",
525 | " horatmin indicativo nombre prec presMax presMin \\\n",
526 | "0 07:30 8025 ALICANTE/ALACANT 0.0 1027.2 1019.8 \n",
527 | "1 06:50 7247X PINOSO 0.0 NaN NaN \n",
528 | "2 21:30 8019 ALICANTE-ELCHE AEROPUERTO 0.0 1033.5 1026.0 \n",
529 | "3 07:20 8025 ALICANTE/ALACANT 0.0 1028.8 1025.3 \n",
530 | "4 06:50 7247X PINOSO 0.0 NaN NaN \n",
531 | "\n",
532 | " provincia racha sol tmax tmed tmin velmedia \n",
533 | "0 ALICANTE 4.7 8.6 16.0 9.6 3.2 1.4 \n",
534 | "1 ALICANTE 4.4 NaN 12.1 3.7 -4.7 1.1 \n",
535 | "2 ALICANTE NaN 6.8 15.9 10.8 5.7 1.9 \n",
536 | "3 ALICANTE 4.2 8.8 18.1 10.0 2.0 1.1 \n",
537 | "4 ALICANTE 2.8 NaN 16.2 5.8 -4.6 1.1 "
538 | ]
539 | },
540 | "execution_count": 14,
541 | "metadata": {},
542 | "output_type": "execute_result"
543 | }
544 | ],
545 | "source": [
546 | "df.head()"
547 | ]
548 | },
549 | {
550 | "cell_type": "code",
551 | "execution_count": 15,
552 | "metadata": {},
553 | "outputs": [],
554 | "source": [
555 | "interesting_cols = [\n",
556 | " \"dir\",\n",
557 | " \"fecha\",\n",
558 | " # \"horaPresMax\",\n",
559 | " # \"horaPresMin\",\n",
560 | " # \"horaracha\",\n",
561 | " # \"horatmax\",\n",
562 | " # \"horatmin\",\n",
563 | " \"indicativo\",\n",
564 | " \"nombre\",\n",
565 | " \"prec\",\n",
566 | " \"presMax\",\n",
567 | " \"presMin\",\n",
568 | " \"provincia\",\n",
569 | " \"racha\",\n",
570 | " \"sol\",\n",
571 | " \"tmax\",\n",
572 | " \"tmed\",\n",
573 | " \"tmin\",\n",
574 | " \"velmedia\"\n",
575 | "]"
576 | ]
577 | },
578 | {
579 | "cell_type": "code",
580 | "execution_count": 16,
581 | "metadata": {},
582 | "outputs": [],
583 | "source": [
584 | "CSV_FILE = '../data/alicante_climate_AEMET.csv'"
585 | ]
586 | },
587 | {
588 | "cell_type": "code",
589 | "execution_count": 17,
590 | "metadata": {},
591 | "outputs": [],
592 | "source": [
593 | "df.to_csv(CSV_FILE, index=False, sep='\\t', columns=interesting_cols)"
594 | ]
595 | },
596 | {
597 | "cell_type": "code",
598 | "execution_count": 18,
599 | "metadata": {},
600 | "outputs": [],
601 | "source": [
602 | "with open(CSV_FILE) as f:\n",
603 | " lines = f.readlines()\n",
604 | " now = time.strftime(\"%c\")\n",
605 | " final = [\"created on: \" + now + '\\n'*2] + lines\n",
606 | "\n",
607 | "with open(CSV_FILE, mode='w') as f:\n",
608 | " f.writelines(final)"
609 | ]
610 | },
611 | {
612 | "cell_type": "code",
613 | "execution_count": 19,
614 | "metadata": {},
615 | "outputs": [],
616 | "source": [
617 | "df = df.loc[df['indicativo'] == '8025']"
618 | ]
619 | },
620 | {
621 | "cell_type": "code",
622 | "execution_count": 20,
623 | "metadata": {},
624 | "outputs": [],
625 | "source": [
626 | "CSV_FILE = '../data/alicante_city_climate_AEMET.csv'"
627 | ]
628 | },
629 | {
630 | "cell_type": "code",
631 | "execution_count": 21,
632 | "metadata": {},
633 | "outputs": [],
634 | "source": [
635 | "df.to_csv(CSV_FILE, index=False, sep='\\t', columns=interesting_cols)"
636 | ]
637 | },
638 | {
639 | "cell_type": "code",
640 | "execution_count": 22,
641 | "metadata": {},
642 | "outputs": [],
643 | "source": [
644 | "with open(CSV_FILE) as f:\n",
645 | " lines = f.readlines()\n",
646 | " now = time.strftime(\"%c\")\n",
647 | " final = [\"created on: \" + now + '\\n'*2] + lines\n",
648 | "\n",
649 | "with open(CSV_FILE, mode='w') as f:\n",
650 | " f.writelines(final)"
651 | ]
652 | }
653 | ],
654 | "metadata": {
655 | "kernelspec": {
656 | "display_name": "Python 3",
657 | "language": "python",
658 | "name": "python3"
659 | },
660 | "language_info": {
661 | "codemirror_mode": {
662 | "name": "ipython",
663 | "version": 3
664 | },
665 | "file_extension": ".py",
666 | "mimetype": "text/x-python",
667 | "name": "python",
668 | "nbconvert_exporter": "python",
669 | "pygments_lexer": "ipython3",
670 | "version": "3.6.4"
671 | }
672 | },
673 | "nbformat": 4,
674 | "nbformat_minor": 2
675 | }
676 |
--------------------------------------------------------------------------------
/notebooks_vacios/0101_Pandas-Carga-datos-y-manipulacion.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Curso de introducción al análisis y modelado de datos con Python \n",
8 | "\n",
9 | "| \n", 375 | " | altitud | \n", 376 | "dir | \n", 377 | "fecha | \n", 378 | "horaPresMax | \n", 379 | "horaPresMin | \n", 380 | "horaracha | \n", 381 | "horatmax | \n", 382 | "horatmin | \n", 383 | "indicativo | \n", 384 | "nombre | \n", 385 | "prec | \n", 386 | "presMax | \n", 387 | "presMin | \n", 388 | "provincia | \n", 389 | "racha | \n", 390 | "sol | \n", 391 | "tmax | \n", 392 | "tmed | \n", 393 | "tmin | \n", 394 | "velmedia | \n", 395 | "
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | \n", 400 | "81.0 | \n", 401 | "14.0 | \n", 402 | "2015-01-01 | \n", 403 | "Varias | \n", 404 | "00 | \n", 405 | "14:00 | \n", 406 | "13:20 | \n", 407 | "07:30 | \n", 408 | "8025 | \n", 409 | "ALICANTE/ALACANT | \n", 410 | "0.0 | \n", 411 | "1027.2 | \n", 412 | "1019.8 | \n", 413 | "ALICANTE | \n", 414 | "4.7 | \n", 415 | "8.6 | \n", 416 | "16.0 | \n", 417 | "9.6 | \n", 418 | "3.2 | \n", 419 | "1.4 | \n", 420 | "
| 1 | \n", 423 | "575.0 | \n", 424 | "5.0 | \n", 425 | "2015-01-01 | \n", 426 | "NaN | \n", 427 | "NaN | \n", 428 | "06:00 | \n", 429 | "15:00 | \n", 430 | "06:50 | \n", 431 | "7247X | \n", 432 | "PINOSO | \n", 433 | "0.0 | \n", 434 | "NaN | \n", 435 | "NaN | \n", 436 | "ALICANTE | \n", 437 | "4.4 | \n", 438 | "NaN | \n", 439 | "12.1 | \n", 440 | "3.7 | \n", 441 | "-4.7 | \n", 442 | "1.1 | \n", 443 | "
| 2 | \n", 446 | "43.0 | \n", 447 | "NaN | \n", 448 | "2015-01-01 | \n", 449 | "Varias | \n", 450 | "00 | \n", 451 | "NaN | \n", 452 | "12:46 | \n", 453 | "21:30 | \n", 454 | "8019 | \n", 455 | "ALICANTE-ELCHE AEROPUERTO | \n", 456 | "0.0 | \n", 457 | "1033.5 | \n", 458 | "1026.0 | \n", 459 | "ALICANTE | \n", 460 | "NaN | \n", 461 | "6.8 | \n", 462 | "15.9 | \n", 463 | "10.8 | \n", 464 | "5.7 | \n", 465 | "1.9 | \n", 466 | "
| 3 | \n", 469 | "81.0 | \n", 470 | "19.0 | \n", 471 | "2015-01-02 | \n", 472 | "11 | \n", 473 | "04 | \n", 474 | "14:00 | \n", 475 | "14:00 | \n", 476 | "07:20 | \n", 477 | "8025 | \n", 478 | "ALICANTE/ALACANT | \n", 479 | "0.0 | \n", 480 | "1028.8 | \n", 481 | "1025.3 | \n", 482 | "ALICANTE | \n", 483 | "4.2 | \n", 484 | "8.8 | \n", 485 | "18.1 | \n", 486 | "10.0 | \n", 487 | "2.0 | \n", 488 | "1.1 | \n", 489 | "
| 4 | \n", 492 | "575.0 | \n", 493 | "99.0 | \n", 494 | "2015-01-02 | \n", 495 | "NaN | \n", 496 | "NaN | \n", 497 | "Varias | \n", 498 | "14:30 | \n", 499 | "06:50 | \n", 500 | "7247X | \n", 501 | "PINOSO | \n", 502 | "0.0 | \n", 503 | "NaN | \n", 504 | "NaN | \n", 505 | "ALICANTE | \n", 506 | "2.8 | \n", 507 | "NaN | \n", 508 | "16.2 | \n", 509 | "5.8 | \n", 510 | "-4.6 | \n", 511 | "1.1 | \n", 512 | "
\n",
10 | ""
11 | ]
12 | },
13 | {
14 | "cell_type": "markdown",
15 | "metadata": {},
16 | "source": [
17 | "---"
18 | ]
19 | },
20 | {
21 | "cell_type": "markdown",
22 | "metadata": {},
23 | "source": [
24 | "# Pandas: Carga y manipulación básica de datos"
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {},
30 | "source": [
31 | "_Hasta ahora hemos visto las diferentes estructuras para almacenamiento de datos que nos ofrece Python, como; integer, real, complex, boolen, list, tuple, dictionary... Sin embargo, también se pueden utilizar arrays a través del paquete `NumPy`, matrices dispersas que nos proporciona el paquete `sparse` de `SciPy`, y otros tipos de estructuras._\n",
32 | "\n",
33 | "_En este notebook, vamos a presentar y empezar a trabajar con el paquete `pandas`. En concreto, nos basaremos en algunos problemas para ver las características de sus estructuras de datos, y para aprender a cargar datos y empezar a manipularnos._\n",
34 | "\n",
35 | "---"
36 | ]
37 | },
38 | {
39 | "cell_type": "markdown",
40 | "metadata": {},
41 | "source": [
42 | "## ¿Qué es pandas?"
43 | ]
44 | },
45 | {
46 | "cell_type": "markdown",
47 | "metadata": {},
48 | "source": [
49 | "`pandas` es una libreria que nos proporciona estructuras de datos y herramientas para realizar análisis de grandes volúmenes de datos de manera rápida.\n",
50 | "\n",
51 | "Se articula sobre la librería `NumPy`, y nos permite enfrentarnos a situaciones en las que tenemos que manejar datos reales, que requieren seguir un proceso de carga, limpieza, filtrado y reducción, y su posterior análisis y representación.\n",
52 | "\n",
53 | "Es de gran utilidad en la industria del Big Data, pues un grandísmo porcentaje del tiempo de trabajo de un Data Scientist, está asociado a la limpieza y preparación de los datos (ver [artículo](https://www.forbes.com/sites/gilpress/2016/03/23/data-preparation-most-time-consuming-least-enjoyable-data-science-task-survey-says/#a5231076f637)), y pandas nos ayuda mucho en esta tarea. "
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "De manera estándar y por convenio, pandas se importa de la siguiente forma:"
61 | ]
62 | },
63 | {
64 | "cell_type": "code",
65 | "execution_count": null,
66 | "metadata": {},
67 | "outputs": [],
68 | "source": []
69 | },
70 | {
71 | "cell_type": "markdown",
72 | "metadata": {},
73 | "source": [
74 | "## Cargando los datos"
75 | ]
76 | },
77 | {
78 | "cell_type": "markdown",
79 | "metadata": {},
80 | "source": [
81 | "Trabajaremos sobre un fichero de datos metereológicos de AEMET obtenido de su portal de datos abiertos a través de la API (ver notebook adjunto). https://opendata.aemet.es/centrodedescargas/inicio"
82 | ]
83 | },
84 | {
85 | "cell_type": "code",
86 | "execution_count": 2,
87 | "metadata": {},
88 | "outputs": [
89 | {
90 | "data": {
91 | "text/html": [
92 | ""
93 | ],
94 | "text/plain": [
95 | "Para acordarnos de cómo parsear las fechas: http://strftime.org/
"
177 | ]
178 | },
179 | {
180 | "cell_type": "markdown",
181 | "metadata": {},
182 | "source": [
183 | "## Explorando los datos"
184 | ]
185 | },
186 | {
187 | "cell_type": "code",
188 | "execution_count": null,
189 | "metadata": {},
190 | "outputs": [],
191 | "source": [
192 | "# recuperar los tipos de datos de cada columna"
193 | ]
194 | },
195 | {
196 | "cell_type": "code",
197 | "execution_count": null,
198 | "metadata": {},
199 | "outputs": [],
200 | "source": [
201 | "# recuperar los índices"
202 | ]
203 | },
204 | {
205 | "cell_type": "code",
206 | "execution_count": null,
207 | "metadata": {},
208 | "outputs": [],
209 | "source": [
210 | "# muestro solo las primers 4 líneas"
211 | ]
212 | },
213 | {
214 | "cell_type": "code",
215 | "execution_count": null,
216 | "metadata": {},
217 | "outputs": [],
218 | "source": [
219 | "# muestro sólo las últimas 6 líneas"
220 | ]
221 | },
222 | {
223 | "cell_type": "code",
224 | "execution_count": null,
225 | "metadata": {},
226 | "outputs": [],
227 | "source": [
228 | "# muestro sólo determinadas líneas (slicing)"
229 | ]
230 | },
231 | {
232 | "cell_type": "code",
233 | "execution_count": null,
234 | "metadata": {},
235 | "outputs": [],
236 | "source": [
237 | "# ordeno de índice más antiguo a más moderno"
238 | ]
239 | },
240 | {
241 | "cell_type": "code",
242 | "execution_count": null,
243 | "metadata": {},
244 | "outputs": [],
245 | "source": [
246 | "# ordeno de mayor a menor la temperatura media"
247 | ]
248 | },
249 | {
250 | "cell_type": "code",
251 | "execution_count": null,
252 | "metadata": {
253 | "scrolled": true
254 | },
255 | "outputs": [],
256 | "source": [
257 | "# información general del dataset. \n",
258 | "# cuidado, para cada columna son las filas con elementos"
259 | ]
260 | },
261 | {
262 | "cell_type": "code",
263 | "execution_count": null,
264 | "metadata": {},
265 | "outputs": [],
266 | "source": [
267 | "# numero de filas y columnas en el dataset"
268 | ]
269 | },
270 | {
271 | "cell_type": "code",
272 | "execution_count": null,
273 | "metadata": {},
274 | "outputs": [],
275 | "source": [
276 | "# contamos cuantos elementos tenemos sin valor"
277 | ]
278 | },
279 | {
280 | "cell_type": "code",
281 | "execution_count": null,
282 | "metadata": {},
283 | "outputs": [],
284 | "source": [
285 | "# contamos cuantos elementos tenemos con valor"
286 | ]
287 | },
288 | {
289 | "cell_type": "markdown",
290 | "metadata": {},
291 | "source": [
292 | "### Descripción estadística"
293 | ]
294 | },
295 | {
296 | "cell_type": "markdown",
297 | "metadata": {},
298 | "source": [
299 | "Se pueden pedir los datos estadísticos asociados al dataframe."
300 | ]
301 | },
302 | {
303 | "cell_type": "code",
304 | "execution_count": null,
305 | "metadata": {},
306 | "outputs": [],
307 | "source": [
308 | "# descripción estadística"
309 | ]
310 | },
311 | {
312 | "cell_type": "markdown",
313 | "metadata": {},
314 | "source": [
315 | "Por defecto, los elementos con NA no se tienen en cuenta a la hora de calcular los valores. Se puede comprobar viendo como cambian los datos cuando se sustitiyen con ceros."
316 | ]
317 | },
318 | {
319 | "cell_type": "code",
320 | "execution_count": null,
321 | "metadata": {},
322 | "outputs": [],
323 | "source": [
324 | "# cambiar na por ceros y volver a ver la descripción estadística\n",
325 | "# recuerda que esto no cambia data en realidad, porque no lo hemos guardado"
326 | ]
327 | },
328 | {
329 | "cell_type": "markdown",
330 | "metadata": {},
331 | "source": [
332 | "Otra forma de acceder a los datos estadísticos, es pedirlos de forma directa."
333 | ]
334 | },
335 | {
336 | "cell_type": "code",
337 | "execution_count": null,
338 | "metadata": {},
339 | "outputs": [],
340 | "source": [
341 | "# media"
342 | ]
343 | },
344 | {
345 | "cell_type": "code",
346 | "execution_count": null,
347 | "metadata": {},
348 | "outputs": [],
349 | "source": [
350 | "# cuantil"
351 | ]
352 | },
353 | {
354 | "cell_type": "markdown",
355 | "metadata": {},
356 | "source": [
357 | "## Accediendo a los datos."
358 | ]
359 | },
360 | {
361 | "cell_type": "markdown",
362 | "metadata": {},
363 | "source": [
364 | "Tenemos dos funciones principales para acceder a los datos, que son `.loc` que permite acceder por etiquetas, y `.iloc`que permite acceder por índices. "
365 | ]
366 | },
367 | {
368 | "cell_type": "markdown",
369 | "metadata": {},
370 | "source": [
371 | "##### columnas"
372 | ]
373 | },
374 | {
375 | "cell_type": "markdown",
376 | "metadata": {},
377 | "source": [
378 | "Hay varias formas de acceder a las columnas: por nombre o por atributo (si no contienen espacios ni caracteres especiales). Además, también se puede usar `.loc` (basado en etiquetas), `.iloc` (basado en posiciones enteras).\n"
379 | ]
380 | },
381 | {
382 | "cell_type": "code",
383 | "execution_count": null,
384 | "metadata": {},
385 | "outputs": [],
386 | "source": [
387 | "# accediendo a una columna por el nombre (label) y obteniendo una serie"
388 | ]
389 | },
390 | {
391 | "cell_type": "code",
392 | "execution_count": null,
393 | "metadata": {},
394 | "outputs": [],
395 | "source": [
396 | "# accediendo a una columna por el nombre (label) y obteniendo un dataframe."
397 | ]
398 | },
399 | {
400 | "cell_type": "code",
401 | "execution_count": null,
402 | "metadata": {},
403 | "outputs": [],
404 | "source": [
405 | "# accediendo a varias columnas por el nombre (label)"
406 | ]
407 | },
408 | {
409 | "cell_type": "code",
410 | "execution_count": null,
411 | "metadata": {},
412 | "outputs": [],
413 | "source": [
414 | "# accediendo a una columna por el atributo"
415 | ]
416 | },
417 | {
418 | "cell_type": "code",
419 | "execution_count": null,
420 | "metadata": {},
421 | "outputs": [],
422 | "source": [
423 | "# accediendo a una columna por índice y obteniendo una serie"
424 | ]
425 | },
426 | {
427 | "cell_type": "code",
428 | "execution_count": null,
429 | "metadata": {},
430 | "outputs": [],
431 | "source": [
432 | "# accediendo a una columna por índice y obteniendo un dataframe"
433 | ]
434 | },
435 | {
436 | "cell_type": "code",
437 | "execution_count": null,
438 | "metadata": {},
439 | "outputs": [],
440 | "source": [
441 | "# accediendo a varias columnas por índice"
442 | ]
443 | },
444 | {
445 | "cell_type": "code",
446 | "execution_count": null,
447 | "metadata": {},
448 | "outputs": [],
449 | "source": [
450 | "# accediendo a una columna por el label y obteniendo una serie"
451 | ]
452 | },
453 | {
454 | "cell_type": "code",
455 | "execution_count": null,
456 | "metadata": {},
457 | "outputs": [],
458 | "source": [
459 | "# accediendo a una columna por el label y obteniendo un dataframe"
460 | ]
461 | },
462 | {
463 | "cell_type": "code",
464 | "execution_count": null,
465 | "metadata": {},
466 | "outputs": [],
467 | "source": [
468 | "# accediendo a varias columnas por le label"
469 | ]
470 | },
471 | {
472 | "cell_type": "markdown",
473 | "metadata": {},
474 | "source": [
475 | "##### filas"
476 | ]
477 | },
478 | {
479 | "cell_type": "markdown",
480 | "metadata": {},
481 | "source": [
482 | "Para acceder a las filas tenemos dos métodos: `.loc` (basado en etiquetas), `.iloc` (basado en posiciones enteras)."
483 | ]
484 | },
485 | {
486 | "cell_type": "code",
487 | "execution_count": null,
488 | "metadata": {},
489 | "outputs": [],
490 | "source": [
491 | "# accediendo a una fila por etiqueta y obteniendo una serie"
492 | ]
493 | },
494 | {
495 | "cell_type": "code",
496 | "execution_count": null,
497 | "metadata": {},
498 | "outputs": [],
499 | "source": [
500 | "# accediendo a una fila por etiqueta y obteniendo un dataframe"
501 | ]
502 | },
503 | {
504 | "cell_type": "code",
505 | "execution_count": null,
506 | "metadata": {},
507 | "outputs": [],
508 | "source": [
509 | "# accediendo a varias filas por etiqueta"
510 | ]
511 | },
512 | {
513 | "cell_type": "code",
514 | "execution_count": null,
515 | "metadata": {},
516 | "outputs": [],
517 | "source": [
518 | "# accediendo a una fila por posición entera y obteniendo una serie"
519 | ]
520 | },
521 | {
522 | "cell_type": "code",
523 | "execution_count": null,
524 | "metadata": {},
525 | "outputs": [],
526 | "source": [
527 | "# accediendo a una fila por posición entera y obteniendo un dataframe"
528 | ]
529 | },
530 | {
531 | "cell_type": "code",
532 | "execution_count": null,
533 | "metadata": {},
534 | "outputs": [],
535 | "source": [
536 | "# accediendo a varias filas por posición entera"
537 | ]
538 | },
539 | {
540 | "cell_type": "markdown",
541 | "metadata": {},
542 | "source": [
543 | "##### filas y columnas "
544 | ]
545 | },
546 | {
547 | "cell_type": "code",
548 | "execution_count": null,
549 | "metadata": {},
550 | "outputs": [],
551 | "source": [
552 | "# accediendo a files y columnas por etiquetas"
553 | ]
554 | },
555 | {
556 | "cell_type": "code",
557 | "execution_count": null,
558 | "metadata": {},
559 | "outputs": [],
560 | "source": [
561 | "# accediendo a filas y columnas por posiciones enteras"
562 | ]
563 | },
564 | {
565 | "cell_type": "markdown",
566 | "metadata": {},
567 | "source": [
568 | "## Filtrado de datos"
569 | ]
570 | },
571 | {
572 | "cell_type": "code",
573 | "execution_count": null,
574 | "metadata": {},
575 | "outputs": [],
576 | "source": [
577 | "# busco duplicados en las fechas"
578 | ]
579 | },
580 | {
581 | "cell_type": "code",
582 | "execution_count": null,
583 | "metadata": {},
584 | "outputs": [],
585 | "source": [
586 | "# tmax > 37"
587 | ]
588 | },
589 | {
590 | "cell_type": "code",
591 | "execution_count": null,
592 | "metadata": {},
593 | "outputs": [],
594 | "source": [
595 | "# 0\n",
10 | ""
11 | ]
12 | },
13 | {
14 | "cell_type": "markdown",
15 | "metadata": {},
16 | "source": [
17 | "---"
18 | ]
19 | },
20 | {
21 | "cell_type": "markdown",
22 | "metadata": {},
23 | "source": [
24 | "# Introducción"
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {},
30 | "source": [
31 | "A continuación, haremos una rápida introducción al lenguaje Python y al intérprete IPython, así como a Jupyter Notebook, la herramienta que vamos a usar en este curso.\n",
32 | "Detallaremos cuáles son las bondades de Python frente a otros lenguajes, y veremos como ejecutar un script y cuáles son los tipos y estructuras básicas de este lenguaje.\n",
33 | "\n",
34 | "**¡Comenzamos!**\n",
35 | "\n",
36 | "---"
37 | ]
38 | },
39 | {
40 | "cell_type": "markdown",
41 | "metadata": {},
42 | "source": [
43 | "