PyConES_17/GeoPandas/GeoPandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instalamos las dependencias\n",
    "\n",
    "Vamos a instalar los módulos de Python necesarios, utilizando pip. Si en tu ordenador la versión por defecto de Python es 2.7 y quieres instalarlos para python3, tendrás que sustituir pip por pip3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!pip install pandas geopandas\n",
    "!pip install --pre cartoframes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Obtenemos los datos\n",
    "Vamos a descargarnos un csv con datos sobre las peticiones que realizan los ciudadanos al gobierno de Reino Unido.\n",
    "\n",
    "Después los importaremos mediante la librería *Pandas*, la cual utilizaremos para analizarlos y obtener relaciones entre ellos. La estructura de datos principal en pandas es el *DataFrame*, con la que trabajaremos de forma similar a como lo haríamos con una hoja de cálculo, pero de manera mucho más eficiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "all_petitions = pandas.read_csv('UKData/petitions.csv')\n",
    "all_petitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Juguemos con los datos\n",
    "Si observamos la anterior tabla, vemos que cada fila representa una petición concreta al gobierno de UK. Las columnas contienen la información del número de personas que apoyan la petición en cada distrito electoral. \n",
    "\n",
    "¿Y qué hacemos con estos datos? Tal y como están es difícil obtener conclusiones... Para empezar, vamos a ver qué peticiones son más populares, es decir, cuáles son las que han obtenido mayor número de votos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Añadimos una nueva columna, el total de votos\n",
    "all_petitions['total'] = all_petitions.iloc[:, 2:].sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Ordenamos los datos en función de dicha columna y nos quedamos con los primeros 100 \n",
    "top_petitions = all_petitions.sort_values('total', ascending=False)[:100]\n",
    "top_petitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parece que lo que más le importa a esta gente son los referéndums y que Donald Trump no les haga una visita...\n",
    "\n",
    "¿Qué otra cosas serán las que más les preocupen a los detractores de Donald Trump?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hallamos la correlación\n",
    "top_petitions.corr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hemos calculado la correlación de las columnas... pero las columnas definen los distritos electorales y no es eso lo que queremos. Necesitamos calcular la correlación entre las filas, que representan las peticiones (o acciones). \n",
    "\n",
    "¿Qué operación matricial podemos aplicar a la tabla?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_petitions.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_petitions.T.corr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué ha pasado? Pues que estamos intentando calcular correlaciones con campos de texto... (los nombres de las acciones)\n",
    "\n",
    "Vamos a probar a tomar de la tabla sólo las columnas que contienen los datos relevantes y repetimos el proceso de trasponer y correlar..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data_columns = top_petitions.columns.drop(['id', 'total', 'action'])\n",
    "top_petitions.loc[:, data_columns].T.corr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué son 122, 976, 534...? Son identificadores de las distintas acciones, pero ¿no sería mejor ver el texto de la acción en su lugar?\n",
    "\n",
    "Para ello, podemos marcar la columna *action* como cabecera de la tabla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "top_petitions.set_index('action').loc[:, data_columns].T.corr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bueno, ¡pues parece que tiene buena pinta! Ahora que calculamos correctamente las correlaciones, vamos a guardarlas en un nuevo DataFrame y sólo nos queda ordenarlas para saber qué otras peticiones son las que más les interesan a los detractores de Donald Trump..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "correlation_df = top_petitions.set_index('action').loc[:, data_columns].T.corr()\n",
    "correlation_df.sort_values('Block Donald J Trump from UK entry', ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ahora, ¡a pintar mapas!\n",
    "\n",
    "Primero vamos a probar *Geopandas*, una extensión de pandas que nos permite trabajar con datos geográficos de manera más sencilla.\n",
    "\n",
    "Empezaremos por obtener las regiones de Reino Unido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import geopandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "boundaries = geopandas.read_file('UKData/uk_boundaries.geojson')\n",
    "boundaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La variable `boundaries` no es más que un DataFrame con la información del polígono que delimita cada región o distrito electoral (si nos fijamos, los identificadores de la columna *geoid* coinciden con los que teníamos en la tabla de peticiones).\n",
    "\n",
    "Vamos a pintarlo utilizando *Matplotlib*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Directiva de Jupyter para pintar \"inline\" el objeto que devuelve matplotlib\n",
    "%matplotlib inline    \n",
    "boundaries.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# No se ve un pijo, ¡más grande!\n",
    "boundaries.plot(figsize=(10, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Llegó el momento publicitario...\n",
    "\n",
    "Vamos a utilizar la librería *Cartoframes* para subir los datos a CARTO, visualizarlos y trabajar con ellos en la plataforma. \n",
    "\n",
    "¿Y por qué vamos a usar CARTO? Pues aparte de porque nos da de comer a la familia, porque permite mostrar el mapa en una interfaz web interactiva (y hacerlo público fácilmente), además de permitir realizar análisis más interesantes que los ofrecidos por geopandas, cómo veremos más adelante.\n",
    "\n",
    "En primer lugar, necesitamos obtener nuestro API Key de la interfaz web de CARTO. Una vez logueados, al clickar en el avatar aparece un menú con la opción *Your API Keys*, que contiene lo que necesitamos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import cartoframes\n",
    "CF = cartoframes.CartoContext(\n",
    "    creds=cartoframes.Credentials(username='pycones01', key='1234567890123456789012345678901234567890')\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a subir nuestro DataFrame de regiones de UK (`boundaries`) a CARTO y crear un mapa con dos capas: la capa del mapa base y una segunda capa con estos datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "CF.write(boundaries, 'uk_boundaries', overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CF.map(layers=[\n",
    "    cartoframes.BaseMap('light'),\n",
    "    cartoframes.Layer('uk_boundaries'),\n",
    "], interactive=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mostremos nuestros datos\n",
    "\n",
    "Hasta ahora, nos hemos limitado a mostrar datos de regiones de Reino Unido, pero lo que realmente queremos es mostrar los datos de las peticiones. Para ello, tenemos que relacionar nuestras dos tablas: `boundaries`, que contiene los datos geográficos de las distintas regiones, y `top_petitions`, que contiene los datos numéricos (votos de las peticiones en cada región).\n",
    "\n",
    "Podemos conseguir esto utilizando la función `merge` de pandas. Para usar merge, debemos tener una columna en común entre ambas tablas, en este caso *geoid*. Pero en la tabla de peticiones, no tenemos tal columna, si no que es la cabecera de las filas. Debemos por tanto transponer esta tabla una vez más, de forma que la disposición sea la correcta.\n",
    "\n",
    "A continuación, indicamos que queremos hacer corresponder la columna *geoid* de la tabla de la izquierda (`boundaries`) con la cabecera o *index* de la tabla de la derecha (`top_petitions`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "geo_petitions = boundaries.merge(top_petitions.set_index('action').T, left_on='geoid', right_index=True)\n",
    "geo_petitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora que hemos relacionado las tablas y tenemos un DataFrame que contiene tanto la información del número de votantes como la geometría de la región, vamos a pintarlo en un mapa con geopandas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "geo_petitions.plot('Block Donald J Trump from UK entry', figsize=(10, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos hacer lo mismo en CARTO. En este caso, subimos la tabla de unión (`geo_petitions`), pero sólo con las columnas que nos interesan, para ahorrar ancho de banda :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "trump = geo_petitions[['Block Donald J Trump from UK entry', 'geometry', 'geoid']]\n",
    "# Renombramos las columnas para escribir menos...\n",
    "trump.columns = ['trump_haters', 'geometry', 'geoid']\n",
    "CF.write(trump, 'trump', overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "CF.map(layers=[\n",
    "    cartoframes.BaseMap('light'),\n",
    "    cartoframes.Layer('trump',\n",
    "        color={'column': 'trump_haters',\n",
    "               'scheme': cartoframes.styling.sunset(5)}),\n",
    "], interactive=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si nos fijamos bien, lo que hemos conseguido realmente se parece mucho a un mapa de densidad de población, es decir, muchos más votantes en las ciudades que en las zonas rurales.\n",
    "\n",
    "Esto es porque hemos pintado el número total de votantes, que evidentemente será mayor en las ciudades por el mero hecho de que allí vive más gente.\n",
    "\n",
    "Vamos a intentar normalizar los datos, es decir, dividirlos por la población total, para hallar el porcentaje de votantes, que es una medida más significativa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Normalización por área\n",
    "\n",
    "Antes de nada, con geopandas es muy fácil normalizar los datos del número de votantes por el tamaño de cada región. No es la mejor de las normalizaciones, pero es rápido de ver, así que merece la pena hacer el experimento.\n",
    "\n",
    "Vamos a añadir una nueva columna a nuestro DataFrame, *haters_per_area*, aprovechándonos de la propiedad *area* de geopandas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "geo_petitions['haters_per_area'] = geo_petitions['Block Donald J Trump from UK entry'] / geo_petitions.area\n",
    "geo_petitions.plot('haters_per_area', figsize=(10,10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uhm... Aún más concentrado en las ciudades..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Normalización por población\n",
    "\n",
    "Con cartoframes es muy sencillo normalizar por población gracias al *Data Observatory*, un repositorio de datos que contiene, entre otros muchos, datos de la población de Reino Unido.\n",
    "\n",
    "Vamos al catálogo del repositorio: https://cartodb.github.io/bigmetadata y ahí buscamos cuál es el identificador de los datos de población de Reino Unido (pista: es \"uk.ons.LC2102EW0001\").  \n",
    "\n",
    "Con este identificador, llamamos a la función `data_augment` para añadir una nueva columna con la población a la tabla `trump` que habíamos creado previamente en CARTO."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "uk_pop = [{'numer_id': 'uk.ons.LC2102EW0001', 'normalization': 'prenormalized'}]\n",
    "augmented = CF.data_augment('trump', uk_pop)\n",
    "augmented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculamos el porcentaje de detractores de Trump por región, teniendo en cuenta el número de votos y la población\n",
    "# de dicha región\n",
    "augmented['trump_hater_percent'] = augmented['trump_haters'] / augmented['total_pop_prenormalized_2011']\n",
    "augmented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "CF.write(augmented, 'trump_percent', overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "CF.map(layers=[\n",
    "    cartoframes.BaseMap('light', labels='front'),\n",
    "    cartoframes.Layer('trump_percent',\n",
    "        color={'column': 'trump_hater_percent',\n",
    "               'scheme': cartoframes.styling.burg(5)}),\n",
    "], interactive=True, size=(900, 600))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dado que hemos normalizado por población, cabría esperar ver un mapa con un color similar en todas sus áreas si el apoyo de la propuesta fuera uniforme...\n",
    "\n",
    "Sin embargo, podemos observar una mayor concentración de votos en las ciudades respecto a las áreas rurales, con lo que los detractores de Trump se concentran en los núcleos importantes de población (sobre todo, en Londres)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra: Normalizar por población al principio\n",
    "\n",
    "Repitamos el análisis, normalizando por población desde el principio, para calcular la correlación sobre el % de votos de cada petición (en vez del número total)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "augmented_boundaries = boundaries.merge(augmented).set_index('geoid')\n",
    "augmented_boundaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "normalized_top_petitions = top_petitions.copy()\n",
    "for col in data_columns:\n",
    "    normalized_top_petitions[col] /= augmented_boundaries.loc[col, 'total_pop_prenormalized_2011']\n",
    "normalized_top_petitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "norm_correlation_matrix = normalized_top_petitions.set_index('action').loc[:, data_columns].T.corr()\n",
    "norm_correlation_matrix.sort_values('Block Donald J Trump from UK entry', ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra: Sobre proyecciones y áreas\n",
    "\n",
    "Cuando calculamos el área, ésta se calcula en función de la proyección que estamos utilizando. Una proyección es una manera de traducir el esferoide terrestre a un plano bidimensional.\n",
    "\n",
    "Las más conocidas son:\n",
    "- WSG84 (EPSG: 4326). Las típicas coordenadas latitud/longitud.\n",
    "- Mercator (EPSG: 3395). La que estamos acostumbrados a ver en mapas.\n",
    "\n",
    "En el primer caso, el área se daría en grados cuadrados y, en el segundo, las unidades son arbitrarias (similares a metros, pero sólo precisa cerca del ecuador). También existen proyecciones específicas para calcular áreas, como la que usamos en este ejemplo.\n",
    "\n",
    "Quizás más interesante que ver el efecto sobre el área, es verlo sobre el mapa. Según la proyección, algunas partes del mapa parecerán estiradas o encogidas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "geo_petitions.plot('haters_per_area', figsize=(10,10))\n",
    "\n",
    "geo_petitions.crs = {'init': 'epsg:4326'}\n",
    "mercator = geo_petitions.to_crs({'init': 'epsg:3395'})\n",
    "mercator.plot('haters_per_area', figsize=(10,10))\n",
    "\n",
    "equalarea = geo_petitions.to_crs({'init': 'epsg:23090'})\n",
    "equalarea.plot('haters_per_area', figsize=(10,10))\n",
    "\n",
    "geo_petitions.area[1], mercator.area[1], equalarea.area[1]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}