Archivo de la categoría: Formación

Mapa España por Comunidades Autónomas con Google Studio

Continúo evaluando métodos para crear mapas con software que no sea de pago e intentando que la dificultad sea mínima. En este caso quería mostraros y poner a vuestra disposición un mapa de España por Comunidades Autónomas, además os dejo acceso libre a los datos que usa el mapa para que vosotros mismos podáis realizar el trabajo. Voy a pasaros 2 enlaces uno con los datos donde tenemos datos de pruebas PCR por 100.000 habitantes a nivel de Comunidad Autónoma (por representar algo) es ahí donde incluís los datos que deseáis representar gráficamente. Y el otro enlace es el dashboard simple hecho con Data Studio que véis al inicio de la entrada que contiene un mapa con el formato que en este momento necesito. Este trabajo es meramente experimental porque pongo a disposición de todos tanto mapa como Hoja de Google, veremos lo que tarda en dejar de funcionar.

El mapa se ha llevado a cabo según las instrucciones de este video:

Si necesitáis realizar el mismo proceso para México ahí lo tenéis muy bien explicado, en mi caso voy a pasar los link para generar el mapa y vosotros mismos cambiando los datos de la google sheet deberíais poder materializar el gráfico. Para no dejar abiertos al público vuestros mapas os pediría copiar o duplicar tanto la Google Sheet Seguir leyendo Mapa España por Comunidades Autónomas con Google Studio

Leer fichero de texto de ancho fijo con Python Pandas

Es muy habitual trabajar con archivos csv pero en ocasiones disponemos de ficheros de texto con determinado formato o con ancho fijo para las columnas. Hace tiempo ya escribí sobre la lectura de archivos csv con Python y Pandas pero en esta ocasión vamos a leer archivos que no tienen un separador. Evidentemente tienen que darnos el formato del archivo, en este caso, para ilustrar el ejemplo, vamos a pasar un código en R a un código en Python. Necesitamos leer unos datos usados en el libro Non-Life Insurance Pricing with GLM, con R teníamos el siguiente programa:

varib <- c(edad = 2L, sexo = 1L, zona = 1L, clase_moto = 1L, antveh = 2L,
           bonus = 1L, exposicion = 8L, nsin = 4L, impsin = 8L)

varib.classes <- c("integer", rep("factor", 3), "integer",
                   "factor", "numeric", rep("integer", 2))
con <- url("https://staff.math.su.se/esbj/GLMbook/mccase.txt")
moto <- read.fwf(con, widths = varib, header = FALSE,
                 col.names = names(varib),
                 colClasses = varib.classes,
                 na.strings = NULL, comment.char = "")

Necesitamos crear ese data frame moto con Python. Evidentemente una lectura a las bravas no tiene sentido:

import pandas as pd
data1 = pd.read_fwf("http://staff.math.su.se/esbj/GLMbook/mccase.txt")
data1.head(10)

El programa R ya nos define el formato del fichero y es necesario "traducirlo" a Pandas:

#Asignamos 
columnas = [(0, 2), (2,3), (3,4), (4,5), (5,7), (7,8), (8,16), (16,20), (20,28)]
data1 = pd.read_fwf("http://staff.math.su.se/esbj/GLMbook/mccase.txt", colspecs=columnas, header=None)
data1.head(10)

Vamos a crear una lista con el ancho de los campos que denominamos columnas, como siempre, en este caso empezamos en 0 no en el 1 y el final del anterior campo será el principio del siguiente, después sumamos a ese principio la longitud del campo que nos han definido. Ahora cuando usemos read_fwf que es la función necesaria para leer files-with-format, ficheros con formato, en colspecs pondremos la lista con las longitudes de los campos y en este caso no tenemos encabezados por lo que es necesario poner header = None. Ya tenemos un data frame al que solo falta asignar los nombres con los campos:

data1.columns = ['edad','sexo','zona','clase_moto', 'antveh', 'bonus', 'exposicion', 'nsin', 'impsin']
data1.head()

El ejemplo os sirve, pero se puede simplificar porque los campos son consecutivos usando widths = lista de longitudes:

data2 = pd.read_fwf("http://staff.math.su.se/esbj/GLMbook/mccase.txt", widths = [2,1,1,1,2,1,8,4,8], header=None)
data2.columns = ['edad','sexo','zona','clase_moto', 'antveh', 'bonus', 'exposicion', 'nsin', 'impsin']
data2.head()

Equivale a lo que hemos visto con anterioridad pero es preferible usar el primer método porque es más rápida la lectura. Saludos.

Leer una tabla en PDF con Excel (a través de R)

Hay situaciones en las que tenemos datos en pdf y los necesitamos exportar a Excel para graficar o cruzar esos datos. En ocasiones es mejor meter esos datos a mano, otras veces disponemos de un software de pago que nos permite realizar esa tarea y también hay páginas web que nos permiten cambiar el formato del pdf. En nuestro caso simplemente necesitamos una tabla que está en formato pdf para disponer de esos datos en Excel, más sencillo, copiar del pdf y pegar en Excel esa tabla. Si está en texto el pdf se puede complicar y si está en modo imagen más. Si empleas windows en tu esta entrada puede ser de utilidad ya que usando de R podrás hacer está tarea de copiar pdf y pegar Excel de un modo más rápido, te cuento paso por paso en video.

El primer paso será la instalación de R y RStudio:

Una vez hemos disponemos de R y Rstudio en nuestro equipo descarga este programa en R que te permitirá exportar una tabla a R con las instrucciones que resumo a continuación:

Esta entrada del blog quiero que sea dinámica, me gustaría mejorar el proceso porque tiene posibilidades de dar a conocer R a personas sin conocimientos de programación. Podemos crear desde una aplicación hasta leer url. Saludos.

La importancia del valor predictivo positivo en las pruebas diagnósticas

El valor predictivo positivo es un dato olvidado cuando realizamos una prueba diagnóstica o (mejor dicho) cuando empleamos este método de medir la potencia de mi modelo. En ocasiones un modelo parece excepcional, pero, cabe preguntarse si un buen modelo puede hacernos perder dinero. Además incidir en la necesidad de calibrar los modelos y medir su comportamiento predictivo y su “comportamiento económico”.

Imagen de previsualización de YouTube

Este video es continuación del que tenemos en la anterior entrada del blog. Espero despertar alguna conciencia e incidir sobre la importancia de medir económicamente el comportamiento de un modelo. La historia que se cuenta es real y supuso un buen proyecto para la compañía en la que trabajaba, no haciendo modelos, pero si instalando un nuevo entorno de detección de fraude. Saludos.

Principales elementos en las pruebas diagnósticas

Primer video que subo. Ilustro de modo sencillo algunos elementos de las pruebas diagnósticas con un ejemplo sencillo que podéis reproducir en cualquier hoja de cálculo. No soy precisamente un experto en este tipo de análisis pero me han sido útiles en algunos momentos de mi vida profesional, además, esa visión “simplista” de las cosas puede ayudar a muchos a comprender conceptos más complejos.

Imagen de previsualización de YouTube

Si tiene éxito continuaré hablando sobre razones de probabilidad. Gracias.

Tratamiento y procesado de imágenes con R y magick

Estoy preparando la batalla entre geometría e inteligencia artificial, batalla que está perdida porque tengo que dar de comer a mis chavales y si tengo que ir a vender un producto queda más comercial contar lo que se supone que hace la inteligencia artificial y no contar lo que hacen vectores, direcciones, puntos en el espacio,… eso lo cuentan en la educación secundaria y no es “disruptivo”. Sin embargo, aprovecho para contar historia del abuelo, el único proyecto serio basado en inteligencia artificial en el que he estado involucrado se resolvió gracias a la geometría y a las mejoras que se propusieron en el reconocimiento óptico, las redes convolucionales nos provocaron un problema. Inicialmente es mejor plantear una solución sencilla.

En esta batalla perdida que he entablado con algún modelo de Tensorflow apareció el paquete magick de R para el procesamiento de imágenes con R y es sencillo y tiene un pequeño manual en español (https://www.datanovia.com/en/blog/easy-image-processing-in-r-using-the-magick-package/) además recientemente fue el cumpleaños de Sean Connery y voy a aprovechar para hacerle un pequeño homenaje.

La imagen de trabajo la saqué de este tweet:

Es una imagen grande 2048×1147 pixel que guardé en mi equipo y que se lee así:

library(dplyr)
library(magick)
ub = "C:\\Users\\rvaquerizo\\Pictures\\sean_connery.jpg"
sean = image_read(ub)
image_info(sean)
plot(sean)

Tenemos 5 imágenes de Sean Connery en una así pues será necesario seleccionar y estandarizar cada una de las imágenes para que la unión sea más homogénea:

sean_1 <- sean %>% image_crop( "400x620+0+100") %>% image_scale("x300") %>% 
  image_border(color = "grey", geometry = "5x5")
sean_2 <- sean %>% image_crop( "380x450+430+20") %>% image_scale("x300") %>% 
  image_border(color = "grey", geometry = "5x5")
sean_3 <- sean %>% image_crop( "400x750+826+0") %>% image_scale("x300") %>% 
  image_border(color = "grey", geometry = "5x5")
sean_4 <- sean %>% image_crop( "400x580+1226+50") %>% image_scale("x300") %>% 
  image_border(color = "grey", geometry = "5x5")
sean_5 <- sean %>% image_crop( "400x450+1635+0") %>% image_scale("x300") %>% 
  image_border(color = "grey", geometry = "5x5")
plot(sean_1)

Con image_crop vamos a cortar las imágenes del siguiente modo width x height + donde empiezo por la izquierda + donde empiezo por arriba. En el momento en el que habéis cortado 3 imágenes le cogéis el aire enseguida, no cuesta. Con image_scale le damos a todas las imágenes la misma escala, para nuestro ejercicio puede ser redundante pero está bien que lo sepamos. Por último vamos a añadir un borde con image_border es una cuestión estética.

Ya tenemos 5 imágenes similares y podemos realizar una animación pasando una tras otra:

image_resize(c(sean_1, sean_2, sean_3, sean_4, sean_5), '300x300!') %>%
  image_background('grey') %>%
  image_morph() %>%
  image_animate(fps=5)

image_resize ya realiza la homogeneización de las 5 imágenes de Sir Connery, por eso comentaba la redundancia. Ponemos un fondo con image_background, la combinación entre image_morph e image_animate realiza la animación donde hemos puesto la opción fps (frames por segundo) para que no pasen tan rápido. Desde mi punto de vista la forma más sencilla de realizar animaciones. Por cierto, a la hora de guardar la imagen lo hago desde el navegador.

Expandir un data frame de R con tidyr

En alguna entrada del blog ya he tratado sobre la expansión de un conjunto de datos pero quería tener una entrada específica. Es algo que se puede programar mediante bucles (tarda una vida) o bien podemos usar la función expand del paquete tydyr. Viendo un ejemplo y los conjuntos de datos generados vais a entender el propósito de la expansión de tablas, se trata de un inicio y un fin y deseamos que se genere una secuencia de observaciones sucesivas dado ese inicio y ese fin. A modo de ejemplo ilustrativo:

library(tidyverse)

clientes <- 100 

cliente <- data.frame(id_cliente = seq(1, clientes))
cliente %>% mutate( inicio = rpois(nrow(cliente), 2),
                    fin = inicio + rpois(nrow(cliente), 4)) ->
  cliente

cliente_expand <- cliente %>% group_by(id_cliente) %>% expand(entrada=inicio:fin) %>% as_tibble()

Con este programa pasamos de un data frame con un registro por id a otro data frame con tantos registros por id como longitud tenga la secuencia entre el campo de inicio y el campo fin:

Esta función expand de rstats me está siendo especialmente útil para trabajar con horas. Saludos.

Optical Character Recognition (OCR) con R y tesseract

Una pincelada sobre Optical Character Recognition con R. El paquete tesseract de R permite aplicar el reconocimiento óptico de caracteres con R de una forma bastante sencilla, es uno de los múltiples líos en los que me estoy metiendo, si llega a buen puerto pondré más. Tenemos esta imagen:

Necesitamos tanto el paquete tesseract como el magick y ejecutando en R:

library(tesseract)
library(magick)

img <- image_read("https://analisisydecision.es/wp-content/uploads/2020/06/prueba_OCR.png")
str(img)
cat(image_ocr(img))
Tipos de uniones (join) de tablas con Python Pandas

By rvaquerizo | 16/05/2020 | No hay comentarios | Formacién, Monogréticos, Python

Recopilacién de las uniones més habituales con Python Pandas en una sola entrada. No se realiza equivalencias con sal join, la intencién es tener de
‘forma resumida los cédigos para realizar left join inner join y concatenacién de data frames de Pandas. Hay amplia documentacion esto es una
sintesis. Los data frames empleados para ilustrar [..]

Fácil en principio y parece tener problemas con las tildes. Si llegan a buen puerto mis proyectos iré poniendo algunas posibilidades más. Saludos.

Tipos de uniones (join) de tablas con Python Pandas

Recopilación de las uniones más habituales con Python Pandas en una sola entrada. No se realiza equivalencias con sql join, la intención es tener de forma resumida los códigos para realizar left join inner join y concatenación de data frames de Pandas. Hay amplia documentación esto es una síntesis.

Los data frames empleados para ilustrar el ejemplo son:

import pandas as pd
import numpy as np
ejemplo = { "variable1": [10, 20, 30, 40],
            "variable2": [100, 200, 300, 400]
}
anio=["2011", "2012", "2013", "2014"]
df1 = pd.DataFrame(ejemplo,index=anio)
df1
ejemplo = { "variable1": [50, 60, 70, 80],
            "variable3": [5000, 6000, 7000, 8000]
}
anio=["2013", "2014", "2015", "2016"]
df2 = pd.DataFrame(ejemplo,index=anio)
df2

Uniones de data frames con índices

La estructura de una join con Pandas es:

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
     left_index=False, right_index=False, sort=True,
     suffixes=('_x', '_y'), copy=True, indicator=False,
     validate=None)

Left Join

left_join = pd.merge(df1, df2, how='left', on=None, left_on=None, right_on=None,
         left_index=True, right_index=True, sort=True)
left_join

Outer Join

outer_join = pd.merge(df1, df2, how='outer', on=None, left_on=None, right_on=None,
         left_index=True, right_index=True, sort=True)
outer_join

Right Join

right_join = pd.merge(df1, df2, how='right', on=None, left_on=None, right_on=None,
         left_index=True, right_index=True, sort=True)
right_join

Inner Join

inner_join = pd.merge(df1, df2, how='inner', on=None, left_on=None, right_on=None,
         left_index=True, right_index=True, sort=True)
inner_join

Concatenar

Concatenación simple

concatenar = pd.concat([df1,df2])
concatenar

Concatenación inner

concatenar_inner = pd.concat([df1,df2],join="inner")
concatenar_inner

Concatenación outer

concatenar_outer = pd.concat([df1,df2],join="outer")
concatenar_outer

Uniones sin índices

Data frames de ejemplo análogos a los anteriores.

import pandas as pd
import numpy as np
ejemplo = { "variable1": [10, 20, 30, 40],
            "variable2": [100, 200, 300, 400],
            "anio":      ["2011", "2012", "2013", "2014"]
}

df1 = pd.DataFrame(ejemplo)

ejemplo = { "variable1": [50, 60, 70, 80],
            "variable3": [5000, 6000, 7000, 8000],
            "anio":      ["2013", "2014", "2015", "2016"]
}

df2 = pd.DataFrame(ejemplo)

Si no tenemos índices es importante especificar en el parámetro on= la variable con la que hacemos la unión de las tablas. En este caso ponemos todas las uniones:

Left, outer, right con campo de unión común

left_join = pd.merge(df1, df2, how='left', on='anio')
outer_join = pd.merge(df1, df2, how='outer', left_on=df1['anio'], right_on=df2['anio'])
right_join = pd.merge(df1, df2, how='right', on='anio')

Inner join con campo de unión de distinto nombre

#Renombramos la variable anio
df2 = df2.rename(columns={"anio": "fecha"})
inner_join = pd.merge(df1, df2, how='inner', left_on='anio', right_on='fecha')

Uniones más habituales en una sola entrada y en pocas líneas de código.

Mapa estático de España con Python

Faltaban mapas de España con Python en el blog y hoy ilustro como hacerlos con geopandas y matplotlib, creo que una de las formas más sencillas de hacer este tipo de mapas. No debía de ser necesaria esta entrada puesto que la realización del mapa debería hacerse con QGis pero es posible que alguien necesite hacer un mapa de España por Comunidades Autónomas de manera rápida y sencilla en su sesión de Python. Es necesario comentar que este trabajo está hecho con Ubuntu, en un entorno Windows la instalación del paquete geopandas es un dolor de cabeza.

Shapefile

El primer paso para la realización del mapa es la obtención del shapefile desde GADM. No he encontrado un paquete de Python que realice esta tarea como sucede con R. Una vez lo hayamos descargado empezamos creando nuestro data frame con la información del shape file:

import geopandas as gpd
import matplotlib.pyplot as plt

# Filepaths
ub_shp = '/home/rvaquerizo/Mapas/gadm36_ESP_shp/gadm36_ESP_1.shp'

# Read files
espania = gpd.read_file(ub_shp, encoding='utf-8')
espania.head()

Reseñar que el mapa de GADM a nivel de Comunidad Autónoma Seguir leyendo Mapa estático de España con Python