Si estáis buscando formación dentro del ecosistema de Big Data y Ciencia de Datos os recomiendo este máster de la UNED:
No sólo lo recomiendo por contenido y por el modo de impartir ese contenido. Recomiendo que os matriculéis en el módulo de seguros. Saludos.
Me han preguntado hoy como parametrizar una consulta de Sql Server desde R y la verdad es que es algo que me parecía muy sencillo y no me había planteado compartirlo. En mi caso suelo emplear la librería RODBC para acceder a Sql Server porque realizo las consultas vía ODBC, por este motivo lo primero debéis tener es configurado el origen de datos ODBC e instalada la librería RODBC en R. Para acceder vía R a los datos de Sql Server lo primero es crear la conexión a la BBDD:
conexion <- odbcConnect("ORIGEN_ODBC")
Ya estamos en disposición de realizar nuestras consultas sobre la BBDD de SQL Server, en R debemos ejecutar siempre:
objeto_r <- sqlQuery(conexion,"")
Con sqlQuery realizamos la consulta tal cual la realizaríamos en Sql Server y obtendremos el objeto en R o directamente puede salirnos en la consola. Recomiendo siempre cerrar las conexiones ODBC, R nos lo irá recordando de todas formas:
odbcCloseAll()
Con odbccloseAll cerramos todas las conexiones ODBC. Y si deseamos añadir parámetros a nuestra consulta desde R sólo tenemos que recordar que en sqlQuery metemos un texto por ello podremos hacer:
fecha <- '2019-08-01'
conexion <- odbcConnect("ORIGEN_ODBC")
objeto_r <- sqlQuery(conexion,paste0("SELECT * FROM TABLA WHERE FECHA>", fecha ,"AND ESTADO='1'"))
odbcCloseAll()
En ocasiones realizamos consultas más complejas, yo suelo "jugar con frases" y directamente pasar a sqlQuery la frase. Truco sencillo.
La realización de gráficos animados con R, gganimate y ggplot2 es algo que quiero empezar a trabajar en mis visualizaciones de datos, una buena forma de llamar la atención sobre nuestros gráficos. Para ilustrar el ejemplo he recogido los datos que publica mensualmente el CIS con las 3 principales preocupaciones de los españoles que podéis encontrar en este enlace, por cierto, este enlace tiene toda la pinta de ser una salida en SAS, no me parece muy apropiado pero no diré nada porque imagino que serán lectores del blog (ya podíais hacer una salida más acorde con los tiempos). El caso es que la primera parte de nuestro trabajo será el “scrapeado” de la web. Scrapear verbo regular de la primera conjugación:
library(XML)
library(dplyr)
library(lubridate)
#Lectura de los datos del CIS
url < - "http://www.cis.es/cis/export/sites/default/-Archivos/Indicadores/documentos_html/TresProblemas.html"
doc = htmlParse(url, encoding = "UTF-8")
tableNodes = getNodeSet(doc, "//table")
#Leemos la tabla que tiene un formato un tanto peculiar
problemas <- readHTMLTable(tableNodes[[2]], skip.rows=1)
problemas <- problemas %>% filter(!is.na(V1))
#Transformamos los puntos en 0, parece que estuviera hecho con SAS
haz.cero.na=function(x){ifelse(x==".",0,as.numeric(as.character(x)))}
problemas < - cbind.data.frame(as.character(problemas$V1),sapply(problemas,haz.cero.na),stringsAsFactors=FALSE)
problemas <- problemas %>% select(-V1)
#El primer elemento de la tabla contiene los nombres que vamos a emplear
nombres < - readHTMLTable(tableNodes[[2]])[1,]
nombres$V1="Problema"
nombres <- as.vector(t(nombres))
names(problemas) <- nombres
#Hay un registro en la tabla que tiene el número de encuestas, no es necesario
problemas <- filter(problemas,Problema != "(N)")
Cosas interesantes en el código. Hacemos HTMLParse de la web y nos quedamos con las tablas, Seguir leyendo Los principales problemas de los españoles. Animaciones con R y gganimate
Entrada para facilitar la realización de mapas de códigos postales de España con R. Todo parte del trabajo de Íñigo Flores al que ya mencionamos en otra entrada. Íñigo descargó de Cartociudad y recopiló los objetos shape file para realizar estos gráficos y los subió a su repositorio, están desactualizados pero puede ser suficiente para la realización de mapas de códigos postales. Íñigo subió en formato .zip todos los archivos necesarios provincia a provincia como lo tenía Cartociudad. Podemos clonarnos el repositorio o leer directamente de github, en cualquier caso necesitamos una función en R que nos permita leer archivos comprimidos en formato zip y cuando lea el zip seleccionar que expresamente lea el archivo shp que contiene el spatial data.
library(maptools)
leer.zip <- function(archivozip) {
zipdir <- tempfile()
dir.create(zipdir)
unzip(archivozip, exdir=zipdir)
archivo <- list.files(zipdir)
archivo <- archivo[grepl("shp",archivo)>0]
archivo <- paste(zipdir, archivo, sep="/")
readShapeSpatial(archivo)
}
Esta función leer.zip permite leer archivos zip, guardarlos en un directorio temporal y posteriormente sólo lee aquel archivo extraído que en su nombre contenga el texto “shp”. Función interesante que modificada ligeramente os permitirá descomprimir cualquier archivo y leer el elemento que deseáis, además de un buen ejemplo de uso de unzip. En este punto, como comentamos antes, podemos leer directamente de github con R.
url <- 'https://github.com/inigoflores/ds-codigos-postales/raw/master/archive/42605-NAVARRA.zip' tf = tempfile(tmpdir=tempdir(), fileext=".zip") download.file(url, tf) navarra <- leer.zip(tf)
Creamos un temporal para descargarnos el zip pero es necesario especificar la extensión. Descargamos de la url correspondiente el archivo con los elementos comprimidos y el objeto navarra será el resultado de la lectura del shapefile con los códigos postales de Navarra. La otra forma es clonar el repositorio y acceder directamente al directorio:
navarra <- leer.zip('C:\\temp\\personales\\wordpress\\ds-codigos-postales-master\\archive\\42605-NAVARRA.zip')
Otro de los motivos de esta entrada es mostraros como podemos realizar mapas de modo rápido con la librería tmap.
library(tmap)
navarra <- leer.zip('C:\\temp\\personales\\wordpress\\ds-codigos-postales-master\\archive\\42605-NAVARRA.zip')
navarra@data$dato <- rpois(nrow(navarra@data),2)
qtm(shp = navarra, fill = "dato", fill.palette = "Blues")
La función qtm se traduce como -Quick thematic plot- y quick es muy quick. El mejor balance entre rápido y sencillo que hay (bajo mi punto de vista). En el ejemplo se pinta un dato aleatorio pero podéis hacer una left join con vuestros datos (que me conozco a algunos). Y si queremos crear un objeto con cada uno de los elementos que preparó Íñigo podemos hacer.
trabajo <- 'C:/temp/personales/wordpress/ds-codigos-postales-master/archive/'
provincias <- list.files(trabajo)
provincias <- data.frame(archivo=provincias)
provincias$nombre <- substr(provincias$archivo,regexpr("-",provincias$archivo)+1,length(provincias$archivo))
provincias$nombre <- gsub('.zip','',provincias$nombre)
for (i in 1:nrow(provincias) ){
instruccion <- paste0(provincias$nombre[i],' <- leer.zip("',trabajo,provincias$archivo[i],'")')
eval(parse(text=instruccion))
}
Código rudimentario que crea un data frame a partir de los archivos de un directorio de trabajo, los archivos son los .zip que nos clonamos de github y con ellos vamos a crear 52 data frame para cada una de las provincias. El nombre de los archivos es XXXX-provincia.zip por eso tenemos que usar algunas funciones de texto para obtener el nombre de la provincia como regexpr que nos permite encontrar la primera posición en la se encuentra un patrón dentro de un texto, por otro lado gsub nos sirve para sustituir un patrón de texto por otro. Así leemos desde el – y posteriormente tenemos que eliminar el .zip para tener el nombre de cada provincia. Y por último un clásico en mis programas de R herencia de los tiempos en los que trabajaba con macros en SAS, tengo que recorrer ese data frame con los elementos del directorio y el nombre del objeto será una columna del data frame y el archivo a leer otra columna, para evaluar un texto el mítico eval ( parse ( text = nunca me falla, habrá formas más elegantes pero esta son dos líneas. Siempre hay que poner talento en la construcción de la instrucción y acordarse de cerrar paréntesis y demás. Ejecutando eso tendríamos un objeto para cada provincia, si queremos toda España.
trabajo <- 'C:/temp/personales/wordpress/ds-codigos-postales-master/archive/'
provincias <- list.files(trabajo)
provincias <- data.frame(archivo=provincias)
provincias$nombre <- substr(provincias$archivo,regexpr("-",provincias$archivo)+1,length(provincias$archivo))
provincias$nombre <- gsub('.zip','',provincias$nombre)
for (i in 1:nrow(provincias) ){
instruccion <- paste0('borrar <- leer.zip("',trabajo,provincias$archivo[i],'")')
eval(parse(text=instruccion))
if (i == 1) {espania <- borrar}
espania <- rbind(espania,borrar)
remove(borrar)
}
plot(espania)
Otro bucle con la marca de la casa pero que funciona perfectamente, leemos uno a uno cada zip con las provincias y con rbind podemos unir los objetos spatial para poder pintar el mapa de España y cuidado que esto si genera un objeto de casi 120 MB. Podéis manejar los objetos spatial data y así reducir su tamaño, así como idea por si pongo el código en el repositorio.
El caso es que ya sabéis como hacer un mapa de España de códigos postales con R, incluso si sois avezados podéis guardar el objeto final resultante y utilizarlo con QGIS u otra herramienta que uséis para hacer mapas. Además esta entrada es todo un compendio de malas prácticas en programación con R que funcionan a las mil maravillas, desde leer archivos zip con R, seleccionar el que deseamos a funciones de texto para extraer con condiciones, ejemplo de gráfico de mapa rápido con tmap y un bucle que lee un data frame y genera objetos con él.
writeSpatialShape(espania, "C:/temp/personales/wordpress/espania.shp")
Por último podemos guardar el objeto resultante de R para usarlo directamente con QGIS, se generan todos los archivos necesarios, el shp, el dbf y el otro.
Un gráfico muy habitual a la hora de construir modelos de riesgo para el cálculo de tarifas es el gráfico de correlaciones de la V de Cramer que nos sirve para medir la correlación entre factores, entre variables cuantitativas hace muchos años ya escribí sobre el tema. Hoy os traigo la creación de un corrplot con R aplicado a la V de Cramer y además os descubro una función muy elegante para realizar este análisis de correlaciones entre factores, esta función está sacada de stackoverflow (como no) y añado un análisis gráfico que nos permite conocer algunas opciones de corrplot.
library(vcd)
library(corrplot)
library(tidyverse)
data(mtcars)
#Partimos de una matriz vacía con las dimensiones apropiadas
empty_m <- matrix(ncol = length(correlaciones),
nrow = length(correlaciones),
dimnames = list(names(correlaciones),
names(correlaciones)))
#Calculamos el estadístico y vamos rellenando la matriz
calculate_cramer <- function(m, df) {
for (r in seq(nrow(m))){
for (c in seq(ncol(m))){
m[[r, c]] <- assocstats(table(df[[r]], df[[c]]))$cramer
}
}
return(m)
}
Lo que hace la brillante función es, partiendo de una matriz cuadrada con los factores, ir rellenando con el correspondiente cálculo de la V de Cramer. El resultado final será igual que una matriz de correlaciones por lo que podremos realizar el gráfico.
predictoras <- c("cyl","vs","am","gear","carb")
correlaciones <- select(mtcars,predictoras)
cor_matrix <- calculate_cramer(empty_m ,correlaciones)
#Ya podemos graficarlo
corrplot(cor_matrix, method="number", is.corr=F,type="upper", diag=F, cl.lim=c(0,1))
remove(correlaciones)
El resultado:
Aspectos interesantes con la función corrplot, con method = "number" sale el valor, no me gustan las bolas, aunque podéis probar con pie, mejor poned is.corr = F con type="upper" sale la parte superior de la matriz, quitamos la diagonal que es 1 con diag=F y la V de Cramer es un valor que va entre 0 y 1 con cl.lim establecemos los límites de la leyenda en el gráfico de correlaciones. A partir de aquí cada uno que establezca un umbral para determinar que dos factores están correlados, yo por ejemplo lo establezco en 0.33, saludos.
Hace años conocí a una persona que no sabía hacer medias ponderadas con Excel, hoy esa persona es una referencia dentro de este ecosistema de Inteligencia Artificial, Big Data, Machine Learning, Unsupervised Learning,… total, una referencia en la venta de humo porque me imagino que seguirá sin saber hacer una media ponderada en Excel con el SUMAPRODUCTO y por eso realizo esta entrada en homenaje a esas grandes locomotoras que echan humo y más humo pero que ahí siguen. Además también es útil para varias cosas más como:
La función es sencilla y replica la forma habitual de hacer medias ponderadas en Excel con el SUMAPRODUCTO del dato del que deseamos calcular la media por el campo de ponderación dividido por la suma del campo de ponderación:
Public Function MEDIAPONDERADA(Valor As Range, Ponderacion As Range) If Valor.Rows.Count <> Ponderacion.Rows.Count Then Sample = "Tamaños distintos de rango" Exit Function ElseIf Valor.Rows.Count = 1 Then Sample = "Solo un número no se puede" Exit Function End If acum = 0 For i = 1 To Valor.Rows.Count dato = Valor(i) * Ponderacion(i) acum = acum + dato Next MEDIAPONDERADA = acum / Excel.WorksheetFunction.Sum(Ponderacion) End Function
Esta función la ponéis en el libro de macros personal y cuando escribáis =MEDIAPONDERADA ya la tendréis a vuestra disposición en todas las sesiones de Excel. Saludos.
A continuación os planteo un acercamiento básico a la lectura de archivos csv con Python y algunos trucos para facilitar la vida cuando realizamos importaciones basados en la experiencia como son leer los primeros registros del csv o realizar una lectura de observaciones aleatoria por si el archivo es muy voluminoso. Para realizar las importaciones vamos a emplear Pandas y la función read_csv con sus infititas opciones:
pd.read_csv(filepath_or_buffer, sep=', ', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, iterator=False, chunksize=None, compression='infer', thousands=None, decimal=b'.', lineterminator=None, quotechar='"', quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, tupleize_cols=None, error_bad_lines=True, warn_bad_lines=True, skipfooter=0, doublequote=True, delim_whitespace=False, low_memory=True, memory_map=False, float_precision=None)
Para trabajar la entrada vamos a necesitar dos archivos de texto:
Como costumbre poner la ubicación del archivo y después la lectura:
path = 'C:/temp/' import pandas as pd df = pd.read_csv (path + 'index.csv') df.head()
En este caso la vida es maravillosa y ha salido todo a la primera pero sabemos que eso no pasa siempre, ejecutáis:
df = pd.read_csv (path + 'bank-additional-full.csv') df.head()
El separador es distinto:
df = pd.read_csv (path + 'bank-additional-full.csv', sep = ';') df.head()
La vida sigue sin ser muy complicada porque el archivo de ejemplo tiene pocos registros, pero imaginad que leéis unas docenas de GB por ello previamente es mejor ejecutar:
df = pd.read_csv (path + 'bank-additional-full.csv', nrows= 200) df.shape
con nrows = 200 leemos las primeras 200 líneas y podemos comprobar si lo estamos leyendo correctamente y podemos ahorrarnos disgustos, tiempo y trabajo. E incluso estaría bien no leer las docenas de GB porque no tenemos suficiente memoria o porque no necesitamos leer entero el archivo podemos leer por trozos:
meses = ['may', 'jul']
df = pd.DataFrame()
for trozo in pd.read_csv(path + 'bank-additional-full.csv', sep=';',
chunksize=1000):
df = pd.concat([df,trozo[trozo['month'].isin(meses)]])
df.month.value_counts()
Con chunksize estamos leyendo el archivo csv en trozos (chunks) de 1000 en 1000 y nos quedamos sólo con aquellos que cumplan un determinado requisito, en este caso que el campo month sea may o jul. E incluso podéis leer el csv extrayendo una muestra aleatoria mientras leéis el fichero por partes y no sobre pasar la memoria:
df2 = pd.DataFrame()
for trozo in pd.read_csv(path + 'bank-additional-full.csv', sep=';',
chunksize=1000):
df2 = pd.concat([df2,trozo.sample(frac=0.25)])
df2.shape
Este último truco puede servir para leer csv extremadamente grandes y realizar los primeros análisis aproximativos a nuestro problema porque como dice un buen amigo “si en 200.000 registros no encuentras una señal no hace falta que cargues millones”.
Entrada dedicada al manejo de datos más básico con Python y Pandas, es análoga a otra ya realizada con dplyr para R. Sirve para tener en un vistazo las tareas más habituales que realizamos en el día a día con Pandas. Para aquel que se esté introduciendo al uso de Python puede ser de utilidad tener todo junto y más claro, a mi personalmente me sirve para no olvidar cosas que ya no uso. En una sola entrada recogemos las dudas más básicas cuando nos estamos iniciando con Python. Las tareas más comunes son:
Para variar vamos a emplear el conjunto de datos iris y que nos descargamos directamente de una url para ello las primeras sentencias que hemos de ejecutar son las siguientes:
import pandas as pd
import io
import requests
url='https://raw.githubusercontent.com/uiuc-cse/data-fa14/gh-pages/data/iris.csv'
s=requests.get(url).content
df=pd.read_csv(io.StringIO(s.decode('utf-8')))
Este código es un buen ejemplo de como obtener un csv directamente de una url porque en ocasiones pueden surgir problemas.
Seleccionar columnas con Pandas Python:
Directamente
df2 = df[['sepal_length','sepal_width']] df2.head()
Mediante una lista, parece más claro.
seleccionadas = ['sepal_length','sepal_width'] df2 = df[seleccionadas] df2.head()
Eliminar columnas:
df3 = df.drop(columns=['sepal_length','sepal_width']) df3.head()
Seleccionar registros con Pandas Python:
Con condiciones simples, los operadores se pueden consultar pero no son “extraños”. También se presenta la función value_counts() que es una sumarización muy habitual.
df['species'].value_counts() df4 = df[df['species']=="setosa"] df4['species'].value_counts()
Algo que tiene especial relevancia (desde mi punto de vista) son los paréntesis en condiciones complejas o múltiples cuando usamos Pandas.
df5 = df.loc[(df.sepal_length<5) & (df.species=="setosa")] df6 = df[(df['sepal_length']<5) & (df['species'] != "setosa")]
Particularmente la función isin para hacer condiciones del tipo in en listas la encuentro de mucha utilidad.
lista = ['setosa', 'virginica'] df7 = df[df['species'].isin(lista)] df7['species'].value_counts()
Crear nuevas variables con Pandas Python:
df['sepal_length_tipi'] = df['sepal_length']/df['sepal_length'].mean() df['sepal_length_tipi'].describe()
En este sentido destacaría el uso de la función de numpy where, el famoso np.where que trabaja igual que el ifelse de R.
import numpy as np
df['sepal_length_altas'] = np.where(df['sepal_length'] > np.mean(df['sepal_length']),
"Por encima de la media", "Por debajo de la media")
df['sepal_length_altas'].value_counts()
Sumarizar datos con Pandas Python:
df[['sepal_length','species']].groupby('species').mean()
df[['sepal_length','species']].groupby('species').count()
Sumarizar por múltiples columnas tienes que listar variables.
df.groupby(['species','sepal_length_altas']).min()
Ordenar data frames con Pandas Python:
df8 = df.sort_values('sepal_length',ascending=[True])
Si queremos ordenar por múltiples campos del data frame con distintos órdenes:
df9 = df.sort_values(['sepal_length','sepal_width'],ascending=[True,False])
Pero en pocas líneas quedan recogidas las principales tareas con registros y columnas que se pueden hacer en un data frame con Pandas. La siguiente entrada irá encaminada a la unión de data frames con Python y Pandas.
Hacía tiempo que no ponía trucos en Excel y hoy os traigo un truco que puede ser de utilidad cuando tienes que hacer combinaciones. Se trata de realizar el producto cartesiano mediante una macro de Excel, además os pongo el enlace al propio Excel para que podáis rellenar los campos a cruzar. No creo que haga falta describir que es un producto cartesiano de dos campospero de forma resumida se puede decir que es crear el total de pares de esos dos campos, un todos con todos, es útil cuando quieres hacer combinaciones (como ya he dicho). La macro en Visual Basic se podrá hacer mejor, pero a mi se me ha ocurrido hacer un triple bucle, probablemente se pueda hacer con n campos pero si tenéis que realizar productos cartesianos más complejos es preferible que lo hagáis con otra herramienta. El código empleado es este:
Sub ProductoCartesiano()
L1 = Range(Range("A2"), Range("A2").End(xlDown)).Rows.Count
L2 = Range(Range("B2"), Range("B2").End(xlDown)).Rows.Count
Cells(1, 4) = Cells(1, 1)
Cells(1, 5) = Cells(1, 2)
i = 2
j = 1
While i <= L1 * L2
While j <= L1
k = 1
While k <= L2
Cells(i, 4) = Cells(j + 1, 1)
Cells(i, 5) = Cells(k + 1, 2)
k = k + 1
If k > L2 Then j = j + 1
i = i + 1
Wend
Wend
Wend
End Sub
Nada emocionante pero tiene su “talento”. Si no queréis complicaros la vida directamente podéis descargar del siguiente enlace la hoja del cálculo que realiza este proceso:
Saludos.
No sé como me llegado esta recopilación de Cheat Sheet para el Data Science pero viendo el trabajo que realizan algunas personas aun es posible creer en la humanidad. Disfrutad del link y ya estamos todos siguiendo el git de este gran tipo: