<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Me | Julián Cabezas Peña</title><link>https://www.juliancabezas.com/authors/me/</link><atom:link href="https://www.juliancabezas.com/authors/me/index.xml" rel="self" type="application/rss+xml"/><description>Me</description><generator>HugoBlox Kit (https://hugoblox.com)</generator><language>es-CL</language><lastBuildDate>Mon, 01 Apr 2019 00:00:00 +0000</lastBuildDate><image><url>https://www.juliancabezas.com/media/authors/me_hu_d26330c6690c521c.jpg</url><title>Me</title><link>https://www.juliancabezas.com/authors/me/</link></image><item><title>Trabajar con un base de datos en .csv o .txt más grande que tu memoria RAM en R utilizando SQLite</title><link>https://www.juliancabezas.com/post/tutorial-2/</link><pubDate>Mon, 01 Apr 2019 00:00:00 +0000</pubDate><guid>https://www.juliancabezas.com/post/tutorial-2/</guid><description>&lt;div id="TOC"&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="#el-problema-del-maldito-ram-y-las-bases-de-datos-enormes"&gt;El problema del maldito RAM y las bases de datos enormes&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#primero-lo-primero-cuanta-memoria-tengo-disponible"&gt;Primero lo primero: ¿Cuanta memoria tengo disponible?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#csv-o-txt-a-sqllite"&gt;CSV o TXT a SQLlite&lt;/a&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href="#los-benditos-paquetes"&gt;Los benditos paquetes&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#que-tan-grande-es-mi-base-de-datos-cuales-son-sus-caracteristicas"&gt;¿Que tan grande es mi base de datos? ¿Cuales son sus características?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#crear-la-ruta-a-la-base-de-datos"&gt;Crear la ruta a la base de datos&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#la-prometida-funcion"&gt;La prometida funcion&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#mover-la-csv-o-txt-a-la-base-de-datos-sqllite"&gt;Mover la csv o txt a la base de datos SQLlite&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#analizar-y-recoger-datos-con-dplyr"&gt;Analizar y recoger datos con dplyr&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/div&gt;
&lt;div id="el-problema-del-maldito-ram-y-las-bases-de-datos-enormes" class="section level3"&gt;
&lt;h3&gt;El problema del maldito RAM y las bases de datos enormes&lt;/h3&gt;
&lt;p&gt;No se si es el caso de todos, pero por mi parte, cada vez que llego a un nuevo trabajo, me pasan &lt;strong&gt;el peor computador de la oficina&lt;/strong&gt;, usualmente 4 Gb de RAM a lo sumo (y con Windows de 32 bits si tienes muy mala suerte, como me pasó a mi una vez). Como ocupo R para todo, se me hace muy difícil trabajar con bases de datos grandes, a veces mayores a la memoria asignada a R. Este tutorial sirve también si tenemos una base de datos &lt;strong&gt;enorme&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;A continuación vamos a revisar cuanta memoria RAM tiene asignada R en el sistema, y a crear una base de datos SQLite de la cual vamos a poder extraer datos y realizar análisis que pueden ser manejados en nuestra memoria RAM, todo con la ayuda de una función que adapté de este &lt;a href="https://gist.github.com/vnijs/e53a68c957747e82c2e3"&gt;gist de vnijs&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;En este tutorial vamos a usar el formato de base de datos &lt;a href="https://www.sqlite.org/index.html"&gt;SQLite&lt;/a&gt; por que es fácil de configurar y usar, y puede ser implementado localmente en simples pasos. Otros formatos posibles serian PostgreSQL y MySQL, pero sería un poco más complicado&lt;/p&gt;
&lt;p&gt;Para poder usar este tutorial se requiere de un conocimiento intermedio-avanzado de R, y entender un poco el mundo del SQL&lt;/p&gt;
&lt;/div&gt;
&lt;div id="primero-lo-primero-cuanta-memoria-tengo-disponible" class="section level3"&gt;
&lt;h3&gt;Primero lo primero: ¿Cuanta memoria tengo disponible?&lt;/h3&gt;
&lt;p&gt;Para ver cuanta memoria tiene R disponible vamos a usar el comando memory.size()&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;memory.limit()&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## [1] 16269&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Como podemos ver, tengo un total de 16 Gb de memoria disponible (aprox. 16000 Mb), que es lo que tiene el computador que estoy utilizando.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Nota:&lt;/strong&gt; Si estas ocupando un sistema operativo de 32 bits, tu limite de memoria no podrá exceder los 2-3 Gb, no importa cuanto RAM tengas instalado.&lt;/p&gt;
&lt;/div&gt;
&lt;div id="csv-o-txt-a-sqllite" class="section level3"&gt;
&lt;h3&gt;CSV o TXT a SQLlite&lt;/h3&gt;
&lt;p&gt;Ahora supongamos que tenemos una base de datos en un csv o txt &lt;strong&gt;ENORME&lt;/strong&gt;. Para efectos de este tutorial voy a ocupar la base de datos del censo de población y vivienda de Chile (año 2017), no es una base de datos tan grande pero para efectos de este tutorial servirá, la pueden descargar de &lt;a href="http://www.ine.cl/docs/default-source/censos/censo-2017/base-de-datos/csv/microdatos-persona/microdato_censo2017-personas.rar?sfvrsn=3"&gt;esta pagina web del Instituto Nacional de Estadísticas de Chile&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Adentro viene un .rar que descomprimiremos para obtener la base de datos en .csv, como podemos ver, pesa aproximadamente 2.5 Gb, no es tanto, pero si estuviéramos ocupando un computador realmente malo no podríamos trabajarla en R, y abrirla en excel puede ser algo difícil.&lt;/p&gt;
&lt;p&gt;La base de datos la voy a descomprimir en una carpeta llamada “Censo” en el disco C:/&lt;/p&gt;
&lt;div class="figure"&gt;
&lt;img src="https://www.juliancabezas.com/img/archivo_censo.JPG" /&gt;
&lt;/div&gt;
&lt;div id="los-benditos-paquetes" class="section level4"&gt;
&lt;h4&gt;Los benditos paquetes&lt;/h4&gt;
&lt;p&gt;Asegúrate de instalar estos 5 paquetes:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;readr&lt;/strong&gt;: Para leer el archivo delimitado por comas (csv) por tabulaciones o por el limite que sea&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;DBI, RSQLite&lt;/strong&gt;: Para comunicarnos con las bases de datos y usar SQLite&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;dplyr y dbplyr&lt;/strong&gt;: Para sacar información de la base de datos&lt;/li&gt;
&lt;/ul&gt;
&lt;pre class="r"&gt;&lt;code&gt;library(readr)
library(DBI)
library(RSQLite)
library(dplyr)
library(dbplyr)&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;div id="que-tan-grande-es-mi-base-de-datos-cuales-son-sus-caracteristicas" class="section level4"&gt;
&lt;h4&gt;¿Que tan grande es mi base de datos? ¿Cuales son sus características?&lt;/h4&gt;
&lt;p&gt;Primero definimos la ruta de nuestra base de datos, le vamos a poner delim_file:&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;delim_file &amp;lt;- &amp;quot;C:/Censo/Microdato_Censo2017-Personas.csv&amp;quot;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Para ver sus características vamos a leer sus primeras 2 lineas, para eso vamos a usar la función &lt;strong&gt;readLines&lt;/strong&gt;&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;readLines(delim_file, n=2)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## [1] &amp;quot;REGION;PROVINCIA;COMUNA;DC;AREA;ZC_LOC;ID_ZONA_LOC;NVIV;NHOGAR;PERSONAN;P07;P08;P09;P10;P10COMUNA;P10PAIS;P11;P11COMUNA;P11PAIS;P12;P12COMUNA;P12PAIS;P12A_LLEGADA;P12A_TRAMO;P13;P14;P15;P15A;P16;P16A;P16A_OTRO;P17;P18;P19;P20;P21M;P21A;P10PAIS_GRUPO;P11PAIS_GRUPO;P12PAIS_GRUPO;ESCOLARIDAD;P16A_GRUPO;REGION_15R;PROVINCIA_15R;COMUNA_15R;P10COMUNA_15R;P11COMUNA_15R;P12COMUNA_15R&amp;quot;
## [2] &amp;quot;15;152;15202;1;2;6;13225;1;1;1;1;1;73;1;98;998;3;15101;998;1;98;998;9998;98;2;4;6;2;1;2;98;7;98;98;98;98;9998;998;998;998;4;2;15;152;15202;98;15101;98&amp;quot;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Ya con esta información podemos ver los nombres de los encabezados y ver que el separador (delim) es un punto y coma (;)&lt;/p&gt;
&lt;p&gt;Para obtener el número de filas de una base de datos grande R no nos va a servir, ya que no la vamos a poder cargar, así que utilizaremos un comando de Powershell (get content) en el caso de estar en Windows o un comando de sistema (wc) en el caso de estar en Linux.&lt;/p&gt;
&lt;p&gt;Para saber cuantas filas tiene mi archivo (esto se demora un poco):&lt;/p&gt;
&lt;p&gt;En Windows:&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;total_records &amp;lt;- system2(&amp;quot;powershell&amp;quot;, args = c(&amp;quot;Get-content&amp;quot;, delim_file, &amp;quot;|&amp;quot;, &amp;quot;Measure-Object&amp;quot;, &amp;quot;–Line&amp;quot;),
stdout = TRUE)
total_records &amp;lt;- as.numeric(gsub(&amp;quot;[^0-9]&amp;quot;, &amp;quot;&amp;quot;, paste(total_records, collapse = &amp;quot;&amp;quot;))) - 1
total_records&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## [1] 17574003&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;17574003 registros o lineas (dejando fuera el encabezado), ese el numero de personas que registró el censo del año 2017, así que estamos bien.&lt;/p&gt;
&lt;p&gt;Nota: Si tienes Windows 10 no debería haber problemas, pero si tienes Windows 7 u 8 te recomiendo ver que versión de powershell tienes instalada &lt;a href="https://docs.microsoft.com/en-us/skypeforbusiness/set-up-your-computer-for-windows-powershell/download-and-install-windows-powershell-5-1"&gt;estas instrucciones de Microsoft&lt;/a&gt; e instalar powershell 5.1 siguiendo &lt;a href="https://docs.microsoft.com/en-us/powershell/scripting/install/installing-windows-powershell?view=powershell-6"&gt;este link tambien de Microsoft&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;En Linux sería algo así:&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt; total_records &amp;lt;- system2(&amp;quot;wc&amp;quot;, args = c(&amp;quot;-l&amp;quot;, delim_file), stdout = TRUE) %&amp;gt;%
sub(normalizePath(delim_file), &amp;quot;&amp;quot;, .) %&amp;gt;%
as.integer() %&amp;gt;%
{
. - 1
}&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;div id="crear-la-ruta-a-la-base-de-datos" class="section level4"&gt;
&lt;h4&gt;Crear la ruta a la base de datos&lt;/h4&gt;
&lt;p&gt;Para crear la base de datos vamos a generar una ruta a un futuro archivo de extensión .sqlite3,&lt;/p&gt;
&lt;p&gt;Definimos la ruta y el nombre de la tabla dentro de la base de datos, necesitaremos este nombre para extraer datos en el futuro, otra gracia de estas bases de datos es que pueden contener varias tablas dentro de ellas.&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;table_name_censo &amp;lt;- &amp;quot;censo2017&amp;quot;
sqlite_file_censo &amp;lt;- &amp;quot;C:/Censo/censo2017.sqlite3&amp;quot;&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;div id="la-prometida-funcion" class="section level4"&gt;
&lt;h4&gt;La prometida funcion&lt;/h4&gt;
&lt;p&gt;Teniendo el numero total de filas del archivo, las rutas definidas y el delimitador (coma, punto y coma, espacio etc), podremos usar la siguiente función:&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;read_delim2sqlite &amp;lt;- function(delim_file, delim, sqlite_file, table_name, batch_size = 10000, OS = &amp;quot;Windows&amp;quot;) {
&lt;h2 id="establish-a-connection-to-the-database"&gt;establish a connection to the database&lt;/h2&gt;
&lt;p&gt;condb &amp;lt;- dbConnect(SQLite(), sqlite_file)&lt;/p&gt;
&lt;h2 id="get-the-total-number-of-records-in-the-file"&gt;get the total number of records in the file&lt;/h2&gt;
&lt;h1 id="in-unix"&gt;in Unix&lt;/h1&gt;
&lt;p&gt;if (OS == &amp;quot;Unix&amp;quot;) {
total_records &amp;lt;- system2(&amp;quot;wc&amp;quot;, args = c(&amp;quot;-l&amp;quot;, delim_file), stdout = TRUE) %&amp;gt;%
sub(normalizePath(delim_file), &amp;quot;&amp;quot;, .) %&amp;gt;%
as.integer() %&amp;gt;%
{
. - 1
}
} else {
# In windows
total_records &amp;lt;- system2(&amp;quot;powershell&amp;quot;, args = c(&amp;quot;Get-content&amp;quot;, delim_file, &amp;quot;|&amp;quot;, &amp;quot;Measure-Object&amp;quot;, &amp;quot;–Line&amp;quot;), stdout = TRUE)
total_records &amp;lt;- as.numeric(gsub(&amp;quot;[^0-9]&amp;quot;, &amp;quot;&amp;quot;, paste(total_records, collapse = &amp;quot;&amp;quot;))) - 1
}&lt;/p&gt;
&lt;p&gt;message(&amp;quot;Total records: &amp;quot;, total_records)&lt;/p&gt;
&lt;h2 id="find-the-number-of-passes-needed-based-on-size-of-each-batch"&gt;find the number of passes needed based on size of each batch&lt;/h2&gt;
&lt;p&gt;passes &amp;lt;- total_records %/% batch_size
remaining &amp;lt;- total_records %% batch_size&lt;/p&gt;
&lt;p&gt;message(&amp;quot;Total Passes to complete: &amp;quot;, passes)&lt;/p&gt;
&lt;h2 id="first-pass-determines-header-and-column-types"&gt;first pass determines header and column types&lt;/h2&gt;
&lt;p&gt;dat &amp;lt;- read_delim(delim_file, delim, n_max = batch_size, progress = FALSE) %&amp;gt;% as.data.frame()
if (nrow(problems(dat)) &amp;gt; 0) print(problems(dat))
col_names &amp;lt;- colnames(dat)
col_types &amp;lt;- c(character = &amp;quot;c&amp;quot;, numeric = &amp;quot;d&amp;quot;, integer = &amp;quot;i&amp;quot;, logical = &amp;quot;l&amp;quot;, Date = &amp;quot;c&amp;quot;) %&amp;gt;%
.[sapply(dat, class)] %&amp;gt;%
paste0(collapse = &amp;quot;&amp;quot;)&lt;/p&gt;
&lt;h2 id="write-to-database-table"&gt;write to database table&lt;/h2&gt;
&lt;p&gt;dbWriteTable(condb, table_name, dat, overwrite = TRUE)&lt;/p&gt;
&lt;h2 id="multiple-passes"&gt;multiple passes&lt;/h2&gt;
&lt;p&gt;for (p in 2:passes) {
message(&amp;quot;Pass number: &amp;quot;, p, &amp;quot;, Progress:&amp;quot;, round(p / passes, 2) * 100, &amp;quot;%&amp;quot;)
read_delim(delim_file, delim,
col_names = col_names, col_types = col_types,
skip = (p - 1) * batch_size + 1, n_max = batch_size, progress = FALSE
) %&amp;gt;%
as.data.frame() %&amp;gt;%
dbWriteTable(condb, table_name, ., append = TRUE)
}&lt;/p&gt;
&lt;p&gt;if (remaining) {
read_delim(delim_file, delim,
col_names = col_names, col_types = col_types,
skip = p * batch_size + 1, n_max = remaining, progress = FALSE
) %&amp;gt;%
as.data.frame() %&amp;gt;%
dbWriteTable(condb, table_name, ., append = TRUE)
}&lt;/p&gt;
&lt;h2 id="close-the-database-connection"&gt;close the database connection&lt;/h2&gt;
&lt;p&gt;dbDisconnect(condb)
}&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;p&gt;Se ve algo intimidante la función, pero la verdad no es tan compleja, lo que hace es leer el archivo por partes de cierto tamaño (batch_size), utilizando la función read_delim del paquete “readr” para leer rápidamente el archivo, luego inserta la parte leída en la base de datos SQLite, y repite el proceso hasta la ultima linea del archivo.&lt;/p&gt;
&lt;p&gt;Los argumentos de la función son los siguientes:&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;delim file&lt;/strong&gt;: Ruta al archivo delimitado (en este caso la BD del censo). &lt;strong&gt;delim&lt;/strong&gt;: Caracter delimitador, en este caso un punto y coma. &lt;strong&gt;sqlite_file&lt;/strong&gt;: Ruta a la base de datos de SQLite, debe terminar con “.sqlite3”. &lt;strong&gt;table_name&lt;/strong&gt;: Nombre de la tabla dentro de la base de datos de SQLite. &lt;strong&gt;batch_size&lt;/strong&gt;: Numero de registros que va a leer en cada iteración. &lt;strong&gt;OS&lt;/strong&gt;: Sistema operativo que estamos utilizando, puede ser “Windows” o “Unix” (Solo probado en Linux, no en Mac).&lt;/p&gt;
&lt;/div&gt;
&lt;div id="mover-la-csv-o-txt-a-la-base-de-datos-sqllite" class="section level4"&gt;
&lt;h4&gt;Mover la csv o txt a la base de datos SQLlite&lt;/h4&gt;
&lt;p&gt;Con lo que ya tenemos preparado podemos usar la función, en este caso, para asegurarme de no quedarme sin RAM, voy a pasar la base de datos en conjuntos de un millon de lineas (batch_size), por lo que debería terminarse en 18 iteraciones.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Advertencia, esto tardará unos cuantos minutos, vayan a cebarse un mate&lt;/strong&gt;&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;read_delim2sqlite(delim_file, delim=&amp;quot;;&amp;quot;, sqlite_file = sqlite_file_censo,
table_name = table_name_censo, batch_size=1000000)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Total records: 17574003&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Total Passes to complete: 17&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Parsed with column specification:
## cols(
## .default = col_integer(),
## P18 = col_character()
## )&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## See spec(...) for full column specifications.&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 2, Progress:12%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 3, Progress:18%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 4, Progress:24%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 5, Progress:29%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 6, Progress:35%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 7, Progress:41%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 8, Progress:47%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 9, Progress:53%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 10, Progress:59%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 11, Progress:65%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 12, Progress:71%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 13, Progress:76%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 14, Progress:82%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 15, Progress:88%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 16, Progress:94%&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Pass number: 17, Progress:100%&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Este proceso tan demoroso solo lo haremos una vez. Como podemos ver se crea un archivo .sqlite3, que incluso es un poco más pequeño que nuestro .csv&lt;/p&gt;
&lt;div class="figure"&gt;
&lt;img src="https://www.juliancabezas.com/img/archivo_censo_sqlite.JPG" alt="Archivo SQLite creado" /&gt;
&lt;p class="caption"&gt;Archivo SQLite creado&lt;/p&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;div id="analizar-y-recoger-datos-con-dplyr" class="section level3"&gt;
&lt;h3&gt;Analizar y recoger datos con dplyr&lt;/h3&gt;
&lt;p&gt;Para empezar a colectar datos de la tabla en primer lugar tengo que hacer una conexión con la base de datos&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;con &amp;lt;- dbConnect(SQLite(), sqlite_file_censo)
con&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## &amp;lt;SQLiteConnection&amp;gt;
## Path: C:\Censo\censo2017.sqlite3
## Extensions: TRUE&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Podemos ver las características de la conexión y el nombre que le asignamos a la base de datos&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;dbListTables(con)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## [1] &amp;quot;censo2017&amp;quot;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Creamos un objeto que va a representar a los datos, este objeto no está en nuestro RAM, es solo una conexión, por eso no salen las filas de la base de datos.&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;datos_db &amp;lt;- tbl(con, &amp;quot;censo2017&amp;quot;)
datos_db&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## # Source: table&amp;lt;censo2017&amp;gt; [?? x 48]
## # Database: sqlite 3.22.0 [C:\Censo\censo2017.sqlite3]
## REGION PROVINCIA COMUNA DC AREA ZC_LOC ID_ZONA_LOC NVIV NHOGAR
## &amp;lt;int&amp;gt; &amp;lt;int&amp;gt; &amp;lt;int&amp;gt; &amp;lt;int&amp;gt; &amp;lt;int&amp;gt; &amp;lt;int&amp;gt; &amp;lt;int&amp;gt; &amp;lt;int&amp;gt; &amp;lt;int&amp;gt;
## 1 15 152 15202 1 2 6 13225 1 1
## 2 15 152 15202 1 2 6 13225 3 1
## 3 15 152 15202 1 2 6 13225 3 1
## 4 15 152 15202 1 2 6 13225 3 1
## 5 15 152 15202 1 2 6 13225 3 1
## 6 15 152 15202 1 2 6 13225 9 1
## 7 15 152 15202 1 2 6 13225 9 1
## 8 15 152 15202 1 2 6 13225 9 1
## 9 15 152 15202 1 2 6 13225 9 1
## 10 15 152 15202 1 2 6 13225 10 1
## # ... with more rows, and 39 more variables: PERSONAN &amp;lt;int&amp;gt;, P07 &amp;lt;int&amp;gt;,
## # P08 &amp;lt;int&amp;gt;, P09 &amp;lt;int&amp;gt;, P10 &amp;lt;int&amp;gt;, P10COMUNA &amp;lt;int&amp;gt;, P10PAIS &amp;lt;int&amp;gt;,
## # P11 &amp;lt;int&amp;gt;, P11COMUNA &amp;lt;int&amp;gt;, P11PAIS &amp;lt;int&amp;gt;, P12 &amp;lt;int&amp;gt;, P12COMUNA &amp;lt;int&amp;gt;,
## # P12PAIS &amp;lt;int&amp;gt;, P12A_LLEGADA &amp;lt;int&amp;gt;, P12A_TRAMO &amp;lt;int&amp;gt;, P13 &amp;lt;int&amp;gt;,
## # P14 &amp;lt;int&amp;gt;, P15 &amp;lt;int&amp;gt;, P15A &amp;lt;int&amp;gt;, P16 &amp;lt;int&amp;gt;, P16A &amp;lt;int&amp;gt;,
## # P16A_OTRO &amp;lt;int&amp;gt;, P17 &amp;lt;int&amp;gt;, P18 &amp;lt;chr&amp;gt;, P19 &amp;lt;int&amp;gt;, P20 &amp;lt;int&amp;gt;,
## # P21M &amp;lt;int&amp;gt;, P21A &amp;lt;int&amp;gt;, P10PAIS_GRUPO &amp;lt;int&amp;gt;, P11PAIS_GRUPO &amp;lt;int&amp;gt;,
## # P12PAIS_GRUPO &amp;lt;int&amp;gt;, ESCOLARIDAD &amp;lt;int&amp;gt;, P16A_GRUPO &amp;lt;int&amp;gt;,
## # REGION_15R &amp;lt;int&amp;gt;, PROVINCIA_15R &amp;lt;int&amp;gt;, COMUNA_15R &amp;lt;int&amp;gt;,
## # P10COMUNA_15R &amp;lt;int&amp;gt;, P11COMUNA_15R &amp;lt;int&amp;gt;, P12COMUNA_15R &amp;lt;int&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Ahora podemos ocupar los verbos de dplyr!, por ejemplo, digamos que queremos obtener un vector con las edades simples para hacer un histograma o algo así (la edad en la base de datos del censo es el campo P09).&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;edades &amp;lt;- datos_db %&amp;gt;%
select(P09)
&lt;p&gt;edades&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;## # Source: lazy query [?? x 1]
## # Database: sqlite 3.22.0 [C:\Censo\censo2017.sqlite3]
## P09
## &amp;lt;int&amp;gt;
## 1 73
## 2 78
## 3 78
## 4 52
## 5 44
## 6 39
## 7 35
## 8 13
## 9 12
## 10 65
## # ... with more rows&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Pareciera que todo estuviera bien, sin embargo, el objeto sigue siendo una “conexión”, lo que hace R es un “lazy loading” (lazy de perezoso o flojo), es decir, solo realiza una parte de la operación para no demorarse mucho.&lt;/p&gt;
&lt;p&gt;Lo podemos confirmar en el environment también:&lt;/p&gt;
&lt;div class="figure"&gt;
&lt;img src="https://www.juliancabezas.com/img/archivo_censo_con.JPG" /&gt;
&lt;/div&gt;
&lt;p&gt;Como podemos ver, el numero de filas ni siquiera esta disponible:&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;nrow(edades)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## [1] NA&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Para traer esta columna a nuestro RAM necesitamos usar la función &lt;strong&gt;collect&lt;/strong&gt;, recomiendo utilizar esta función &lt;strong&gt;siempre&lt;/strong&gt;, para asegurarnos que estamos trabajando con objetos completos y no con conexiones&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;edades&amp;lt;-collect(edades)
&lt;p&gt;nrow(edades)&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;## [1] 17574003&lt;/code&gt;&lt;/pre&gt;
&lt;pre class="r"&gt;&lt;code&gt;edades&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## # A tibble: 17,574,003 x 1
## P09
## &amp;lt;int&amp;gt;
## 1 73
## 2 78
## 3 78
## 4 52
## 5 44
## 6 39
## 7 35
## 8 13
## 9 12
## 10 65
## # ... with 17,573,993 more rows&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Ahora si!&lt;/p&gt;
&lt;p&gt;Otro ejemplo, el campo “P09” se refiere a la edad y el campo “P08” al sexo, supongamos que queremos saber la edad promedio por región de los hombres (Sexo=1). ¡No nos olvidemos del &lt;strong&gt;collect&lt;/strong&gt;!&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;hombres_edad &amp;lt;- datos_db %&amp;gt;%
filter(P08==1) %&amp;gt;%
group_by(REGION) %&amp;gt;%
summarise(Edad_media = mean(P09))
&lt;p&gt;hombres_edad &amp;lt;- collect(hombres_edad)&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;## Warning: Missing values are always removed in SQL.
## Use `AVG(x, na.rm = TRUE)` to silence this warning&lt;/code&gt;&lt;/pre&gt;
&lt;pre class="r"&gt;&lt;code&gt;hombres_edad&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## # A tibble: 16 x 2
## REGION Edad_media
## &amp;lt;int&amp;gt; &amp;lt;dbl&amp;gt;
## 1 1 32.1
## 2 2 33.0
## 3 3 33.7
## 4 4 34.6
## 5 5 35.8
## 6 6 35.7
## 7 7 35.9
## 8 8 35.0
## 9 9 35.3
## 10 10 35.1
## 11 11 34.2
## 12 12 35.9
## 13 13 34.2
## 14 14 35.7
## 15 15 33.5
## 16 16 36.8&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Listo, ya podemos trabajar con gran parte de las base de datos estructuradas, extraer datos y realizar análisis.&lt;/p&gt;
&lt;p&gt;¡Ojala les haya gustado el tutorial, no duden en contactarme!&lt;/p&gt;
&lt;div class="figure"&gt;
&lt;img src="https://media.giphy.com/media/3hvmlYNsOTFWE/giphy.gif" /&gt;
&lt;/div&gt;
&lt;/div&gt;</description></item><item><title>Una función para paralelizar en Windows o en servidores (Tutorial paralelizar en R parte 2)</title><link>https://www.juliancabezas.com/post/tutorial/</link><pubDate>Thu, 24 Jan 2019 00:00:00 +0000</pubDate><guid>https://www.juliancabezas.com/post/tutorial/</guid><description>&lt;div id="TOC"&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="#el-problema-crear-clusters-es-tedioso"&gt;El problema: Crear clusters es tedioso&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#la-solucion-una-funcion-para-clear-clusters"&gt;La solucion: Una función para clear clusters&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#un-pequeno-y-reciclado-ejemplo"&gt;Un pequeño y reciclado ejemplo&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/div&gt;
&lt;p&gt;Este mini-tutorial es la segunda parte de mi primer tutorial sobre paralelizar R en Windows, &lt;a href="https://www.juliancabezas.com/post/paralelizando-r-en-windows-usando-el-paquete-parallel/"&gt;te recomendo leerlo primero&lt;/a&gt;&lt;/p&gt;
&lt;div id="el-problema-crear-clusters-es-tedioso" class="section level2"&gt;
&lt;h2&gt;El problema: Crear clusters es tedioso&lt;/h2&gt;
&lt;p&gt;Ya nos dimos cuenta de que el tema de crear los clusters y todas esas cosas puede ser muy tedioso, cargar los paquetes uno por uno y exportar las bases de datos es lento, olvidar un paquete crucial es pan de cada día y la idea es hacerlo más conveniente, además existe la posibilidad de que estemos usando un servidor sin acceso a Internet, lo que complica la instalación de paquetes&lt;/p&gt;
&lt;/div&gt;
&lt;div id="la-solucion-una-funcion-para-clear-clusters" class="section level2"&gt;
&lt;h2&gt;La solucion: Una función para clear clusters&lt;/h2&gt;
&lt;p&gt;así que cree una función, que mantengo en esta &lt;a href="https://github.com/juliancabezas/random_functions/blob/master/create_cluster"&gt;Carpeta en Github&lt;/a&gt;, para ser justo, la función esta inspirada en el paquete &lt;a href="https://github.com/nathanvan/parallelsugar"&gt;parallelsugar&lt;/a&gt;, pero con algunas modificaciones&lt;/p&gt;
&lt;p&gt;La función crea un cluster de &lt;em&gt;n&lt;/em&gt; nodos (argumento &lt;em&gt;nnodes&lt;/em&gt;)&lt;/p&gt;
&lt;p&gt;create_cluster esta diseñada para funcionar en servidores, ya que en general estos no tienen conexión a Internet es posible instalar los paquetes en una carpeta compartida local y usarlos dentro de nuestra función. en &lt;em&gt;libroute&lt;/em&gt; podemos especificar la ruta a la librería de nuestra conveniencia.&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;create_cluster &amp;lt;- function(nnodes, libroute = NULL) {
&lt;h1 id="nnodes-number-of-nodes"&gt;nnodes: Number of nodes&lt;/h1&gt;
&lt;h1 id="libroute-provided-library-route-different-of-the-default-library"&gt;libroute: Provided library route (different of the default library)&lt;/h1&gt;
&lt;p&gt;tryCatch({
cl &amp;lt;- parallel::makeCluster(nnodes) # Create an empty cluster with n nodes&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;loaded.package.names &amp;amp;lt;- c( # Find the loaded packages in the session
sessionInfo()$basePkgs, # base packages
names(sessionInfo()$otherPkgs)
) # aditional loaded packages
# Send the packages and the complete environment to the cluster
parallel::clusterExport(cl,
&amp;amp;quot;loaded.package.names&amp;amp;quot;, # loaded packages
envir = environment()
) # &amp;amp;quot;Environment&amp;amp;quot;
## Charge the packages in all nodes
if (is.null(libroute)) { # Use default library location
parallel::parLapply(cl, 1:length(cl), function(xx) {
lapply(loaded.package.names, function(yy) {
library(yy, character.only = TRUE)
})
})
} else {
# If we provide a library location use it (useful when working in remote machines)
parallel::parLapply(cl, 1:length(cl), function(xx) {
lapply(loaded.package.names, function(yy) {
library(yy, character.only = TRUE, lib.loc = libroute)
})
})
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;})
return(cl) # The result is the cluster
}&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div id="un-pequeno-y-reciclado-ejemplo" class="section level2"&gt;
&lt;h2&gt;Un pequeño y reciclado ejemplo&lt;/h2&gt;
&lt;p&gt;Para ejemplificar, en este problema (sacado del tutorial anterior), teníamos que ocupar &lt;em&gt;clusterCall&lt;/em&gt; para llamar al paquete &lt;em&gt;randomForest&lt;/em&gt;, acá, si ya tenemos el paquete cargado en la sesión (y varios paquetes más, los exportamos a los nodos todo de una sola vez&lt;/p&gt;
&lt;p&gt;Cargo el paquete y creo la función:&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;library(randomForest)
&lt;p&gt;rf_boot_fun &amp;lt;- function(iter, data, n_sample) {
ind &amp;lt;- sample(1:nrow(data), size = n_sample)
data_sample &amp;lt;- data[ind, ]&lt;/p&gt;
&lt;h1 id="ejecuto-el-modelo-random-forest"&gt;Ejecuto el modelo Random Forest&lt;/h1&gt;
&lt;p&gt;model1 &amp;lt;- randomForest(Sepal.Length ~ Petal.Length, data = data_sample)&lt;/p&gt;
&lt;h1 id="extraigo-el-pseudo-r2"&gt;Extraigo el pseudo-R2&lt;/h1&gt;
&lt;p&gt;R2 &amp;lt;- model1$rsq[length(model1$rsq)]&lt;/p&gt;
&lt;h1 id="extraigo-el-mse"&gt;Extraigo el MSE&lt;/h1&gt;
&lt;p&gt;MSE &amp;lt;- model1$mse[length(model1$mse)]
results &amp;lt;- c(&amp;quot;R2&amp;quot; = R2, &amp;quot;MSE&amp;quot; = MSE)
return(results)
}&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;p&gt;Ahora puedo aplicar esta función con &lt;em&gt;parLapply&lt;/em&gt;&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;library(parallel)
&lt;h1 id="defino-una-ruta-para-mi-libreria-opcional"&gt;Defino una ruta para mi libreria (opcional)&lt;/h1&gt;
&lt;p&gt;ruta_libreria &amp;lt;- &amp;quot;C:/Users/Julian/Documents/R/win-library/3.5&amp;quot;&lt;/p&gt;
&lt;h1 id="esto-puede-ser-simplemente-nuevoclus-create_cluster4"&gt;Esto puede ser simplemente nuevoclus&amp;lt;-create_cluster(4)&lt;/h1&gt;
&lt;p&gt;nuevoclus &amp;lt;- create_cluster(4, ruta_libreria)&lt;/p&gt;
&lt;h1 id="10000-iteraciones-de-nuestra-funcion-con-la-base-de-datos-iris"&gt;10000 iteraciones de nuestra funcion con la base de datos &amp;quot;iris&amp;quot;&lt;/h1&gt;
&lt;p&gt;results &amp;lt;- parLapply(nuevoclus, 1:10000, rf_boot_fun, data = iris, n_sample = 100)&lt;/p&gt;
&lt;p&gt;stopCluster(nuevoclus) # Cerramos el cluster, NO OLVIDAR&lt;/p&gt;
&lt;h1 id="los-primeros-dos-resultados"&gt;Los primeros dos resultados&lt;/h1&gt;
&lt;p&gt;head(results, n = 2)&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;## [[1]]
## R2 MSE
## 0.778244 0.174310
##
## [[2]]
## R2 MSE
## 0.6912495 0.1865890&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;¡Listo, paralelizamos mucho mas fácil!&lt;/p&gt;
&lt;div class="figure"&gt;
&lt;img src="https://media.giphy.com/media/uTuLngvL9p0Xe/giphy.gif" /&gt;
&lt;/div&gt;
&lt;p&gt;&lt;strong&gt;Espero les sirva!&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Espero sus comentarios y dudas!&lt;/strong&gt;&lt;/p&gt;
&lt;/div&gt;</description></item><item><title>Paralelizando R en Windows (usando el paquete parallel)</title><link>https://www.juliancabezas.com/post/paralelizando-r-en-windows-usando-el-paquete-parallel/</link><pubDate>Mon, 07 Jan 2019 00:00:00 +0000</pubDate><guid>https://www.juliancabezas.com/post/paralelizando-r-en-windows-usando-el-paquete-parallel/</guid><description>&lt;div id="TOC"&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="#por-que-paralelizar"&gt;¿Por que Paralelizar?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#convertir-tu-loop-en-una-funcion"&gt;Convertir tu loop en una función&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#usando-la-funcion-lapply"&gt;Usando la funcion lapply&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#el-paquete-parallel"&gt;El paquete parallel&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#un-ejemplo-mas-realista-usando-machine-learning"&gt;Un ejemplo más realista (usando Machine Learning)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/div&gt;
&lt;div id="por-que-paralelizar" class="section level2"&gt;
&lt;h2&gt;¿Por que Paralelizar?&lt;/h2&gt;
&lt;p&gt;En tu trabajo te pidieron correr un código que se demora 20 horas en ejecutarse, consiste en ejecutar la misma función con distintos parámetros o datos muchas pero &lt;strong&gt;muchas&lt;/strong&gt; veces.&lt;/p&gt;
&lt;p&gt;A pesar de que puede que para ti esto puede no ser un problema, es común que te pidan las cosas &lt;del&gt;para ayer&lt;/del&gt; sin 20 horas de anticipación. Si este es tu caso, y te estás preguntando por que tu PC o workstation viene con 4, 8 o 16 núcleos ¡este tutorial es para ti!&lt;/p&gt;
&lt;p&gt;Paralelizar procesos en R puede ser difícil, pero si a eso le sumas &lt;del&gt;la mala suerte&lt;/del&gt; el hecho de estar trabajando en Windows, se puede convertir en una tarea casi imposible&lt;/p&gt;
&lt;p&gt;En este tutorial (&lt;strong&gt;¡el primero de esta pagina!&lt;/strong&gt;), vamos a realizar una pequeña introducción a la paralelización de procesos en R bajo el SO Windows, partiendo por el uso de la familia de funciones &lt;strong&gt;apply&lt;/strong&gt;, el uso del paquete parallel en R y una solución para crear un cluster en windows, terminando con un ejemplo de aplicación muy común en &lt;em&gt;machine learning&lt;/em&gt;&lt;/p&gt;
&lt;div id="nivel-de-este-tutorial" class="section level4"&gt;
&lt;h4&gt;Nivel de este tutorial:&lt;/h4&gt;
&lt;p&gt;Al escribir este tutorial estoy asumiendo que eres un usuario intermedio o avanzado de R.&lt;/p&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;div id="convertir-tu-loop-en-una-funcion" class="section level2"&gt;
&lt;h2&gt;Convertir tu loop en una función&lt;/h2&gt;
&lt;p&gt;En este ejemplo vamos a utilizar la base de datos &lt;strong&gt;iris&lt;/strong&gt;, una de las más conocidas entre los usuarios de R, esta base de datos tiene mediciones del largo y ancho de pétalos y sépalos de 3 especies de flores&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;data(iris)
knitr::kable(head(iris))&lt;/code&gt;&lt;/pre&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr class="header"&gt;
&lt;th align="right"&gt;Sepal.Length&lt;/th&gt;
&lt;th align="right"&gt;Sepal.Width&lt;/th&gt;
&lt;th align="right"&gt;Petal.Length&lt;/th&gt;
&lt;th align="right"&gt;Petal.Width&lt;/th&gt;
&lt;th align="left"&gt;Species&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr class="odd"&gt;
&lt;td align="right"&gt;5.1&lt;/td&gt;
&lt;td align="right"&gt;3.5&lt;/td&gt;
&lt;td align="right"&gt;1.4&lt;/td&gt;
&lt;td align="right"&gt;0.2&lt;/td&gt;
&lt;td align="left"&gt;setosa&lt;/td&gt;
&lt;/tr&gt;
&lt;tr class="even"&gt;
&lt;td align="right"&gt;4.9&lt;/td&gt;
&lt;td align="right"&gt;3.0&lt;/td&gt;
&lt;td align="right"&gt;1.4&lt;/td&gt;
&lt;td align="right"&gt;0.2&lt;/td&gt;
&lt;td align="left"&gt;setosa&lt;/td&gt;
&lt;/tr&gt;
&lt;tr class="odd"&gt;
&lt;td align="right"&gt;4.7&lt;/td&gt;
&lt;td align="right"&gt;3.2&lt;/td&gt;
&lt;td align="right"&gt;1.3&lt;/td&gt;
&lt;td align="right"&gt;0.2&lt;/td&gt;
&lt;td align="left"&gt;setosa&lt;/td&gt;
&lt;/tr&gt;
&lt;tr class="even"&gt;
&lt;td align="right"&gt;4.6&lt;/td&gt;
&lt;td align="right"&gt;3.1&lt;/td&gt;
&lt;td align="right"&gt;1.5&lt;/td&gt;
&lt;td align="right"&gt;0.2&lt;/td&gt;
&lt;td align="left"&gt;setosa&lt;/td&gt;
&lt;/tr&gt;
&lt;tr class="odd"&gt;
&lt;td align="right"&gt;5.0&lt;/td&gt;
&lt;td align="right"&gt;3.6&lt;/td&gt;
&lt;td align="right"&gt;1.4&lt;/td&gt;
&lt;td align="right"&gt;0.2&lt;/td&gt;
&lt;td align="left"&gt;setosa&lt;/td&gt;
&lt;/tr&gt;
&lt;tr class="even"&gt;
&lt;td align="right"&gt;5.4&lt;/td&gt;
&lt;td align="right"&gt;3.9&lt;/td&gt;
&lt;td align="right"&gt;1.7&lt;/td&gt;
&lt;td align="right"&gt;0.4&lt;/td&gt;
&lt;td align="left"&gt;setosa&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;Supongamos que a alguien de tu equipo le interesa generar un modelo lineal entre los pétalos (Petal) y los sépalos (Sepal). Debido a que la muestra es pequeña (150 individuos) te mandan a hacer un bootstrap de 20000 iteraciones para ver como se comporta el R&lt;sup&gt;2&lt;/sup&gt; y los coeficientes del modelo.&lt;/p&gt;
&lt;p&gt;Para poder lograr esto hacemos un loop, que ejecuta lo siguiente: - Saca una muestra de 100 individuos (dos tercios del total) - Genera el modelo lineal - Guarda el R&lt;sup&gt;2&lt;/sup&gt; y los coeficientes en una dataframe&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;# Hacemos una dataframe vacia para guardar los resultados
results &amp;lt;- data.frame()
&lt;p&gt;system.time({
for (i in 1:20000) {
# Saco una muestra de 100 numeros entre 1 y 150
ind &amp;lt;- sample(1:nrow(iris), size = 100)
iris_sample &amp;lt;- iris[ind, ]
# Hago un lm con el petalo y el sepalo
model1 &amp;lt;- lm(iris_sample[, &amp;quot;Sepal.Length&amp;quot;] ~ iris_sample[, &amp;quot;Petal.Length&amp;quot;])&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# Extraigo el R2 y los coeficientes
R2 &amp;amp;lt;- summary(model1)$r.squared
coef &amp;amp;lt;- coefficients(model1)
# lo junto todo en la data.frame de resultados
results &amp;amp;lt;- rbind(results, c(R2, coef))
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;}
})&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;## user system elapsed
## 20.90 0.03 20.95&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;El algoritmo se demora un poco más de 20 segundos en funcionar, tal vez esto no signifique un problema, pero ¿que pasa si el día de mañana te piden hacer lo mismo con una base de datos de medio millón de observaciones?.&lt;/p&gt;
&lt;p&gt;El problema es que el loop ocupa solo un núcleo de tu procesador para ejecutar la operación una iteración tras otra, lo que no es muy eficiente&lt;/p&gt;
&lt;p&gt;El primer paso para aprovechar los beneficios de la paralelización en convertir tu loop en una función, este caso el único argumento de nuestra función será un vector “iter”, que es el que nos dará la opción de realizar más iteraciones&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;lm_boot_fun &amp;lt;- function(iter) {
ind &amp;lt;- sample(1:nrow(iris), size = 100)
iris_sample &amp;lt;- iris[ind, ]
model1 &amp;lt;- lm(iris_sample[, &amp;quot;Sepal.Length&amp;quot;] ~ iris_sample[, &amp;quot;Petal.Length&amp;quot;])
R2 &amp;lt;- summary(model1)$r.squared
coef &amp;lt;- coefficients(model1)
# Creo un vector con los resultados
results &amp;lt;- c(&amp;quot;R2&amp;quot; = R2, coef)
# El output de mi función
return(results)
}&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;!Ahora probemos nuestra función!. Como podemos ver en el siguiente código, la función da resultados independiente del argumento que le pongamos&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;result &amp;lt;- lm_boot_fun(1)
result&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## R2 (Intercept)
## 0.7554039 4.3353075
## iris_sample[, &amp;quot;Petal.Length&amp;quot;]
## 0.3999710&lt;/code&gt;&lt;/pre&gt;
&lt;pre class="r"&gt;&lt;code&gt;result &amp;lt;- lm_boot_fun(56876)
result&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## R2 (Intercept)
## 0.7393922 4.3426829
## iris_sample[, &amp;quot;Petal.Length&amp;quot;]
## 0.3939433&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Si le pusiéramos un vector nos daría solo un valor, por que “results” se sobrescribe en cada iteración&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;result &amp;lt;- lm_boot_fun(1:10)
result&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## R2 (Intercept)
## 0.7732318 4.2822007
## iris_sample[, &amp;quot;Petal.Length&amp;quot;]
## 0.4256894&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;div id="usando-la-funcion-lapply" class="section level2"&gt;
&lt;h2&gt;Usando la funcion lapply&lt;/h2&gt;
&lt;p&gt;Para que nos guarde todos los resultados podemos recurrir a la Recurriendo a la función lapply&lt;/p&gt;
&lt;p&gt;La función lapply pertenece a la familia de funciones apply (apply, sapply, vapply, lapply y mapply), una de las herramientas más potentes de R (y que me habría gustado aprender mucho antes), este tutorial no se trata sobre ellas, por lo que solo ocuparemos lapply por ahora&lt;/p&gt;
&lt;p&gt;La funcion lapply aplica otra función (como la que construimos), sobre una lista o vector de argumentos, y retorna una lista del mismo tamaño que los argumentos&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;iter &amp;lt;- seq(1, 20000)
system.time({
results &amp;lt;- lapply(iter, lm_boot_fun)
})&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## user system elapsed
## 15.05 0.00 15.07&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Bueno, como podemos ver, ya bajamos un poco los tiempos de procesamiento, pero queremos hacerlo mucho más rápido aún. El único problema es que la función lapply te da como resultado una lista&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;head(results, n = 3)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## [[1]]
## R2 (Intercept)
## 0.7795166 4.2839537
## iris_sample[, &amp;quot;Petal.Length&amp;quot;]
## 0.4123361
##
## [[2]]
## R2 (Intercept)
## 0.7683068 4.2132627
## iris_sample[, &amp;quot;Petal.Length&amp;quot;]
## 0.4311986
##
## [[3]]
## R2 (Intercept)
## 0.7909086 4.2600338
## iris_sample[, &amp;quot;Petal.Length&amp;quot;]
## 0.4163103&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Para convertir esta lista en una dataframe, utilizamos la función unlist para generar una matriz que se convierte en una dataframe. especificamos que queremos 3 columnas&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;results &amp;lt;- data.frame(matrix(unlist(results), ncol = 3, byrow = T))
head(results, n = 2)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## X1 X2 X3
## 1 0.7795166 4.283954 0.4123361
## 2 0.7683068 4.213263 0.4311986&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Otras soluciones más elegantes para este problema pueden ser encontradas en &lt;a href="https://stackoverflow.com/questions/4227223/r-list-to-data-frame"&gt;este post de stackoverflow&lt;/a&gt;&lt;/p&gt;
&lt;/div&gt;
&lt;div id="el-paquete-parallel" class="section level2"&gt;
&lt;h2&gt;El paquete parallel&lt;/h2&gt;
&lt;p&gt;El paquete parallel, desde hace algunas versiones viene incluido con R. Este increíble paquete contiene versiones en paralelo para todas las funciones de la familia apply, para utilizar este tipo de función necesitamos saber primero con cuantos núcleos contamos&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;library(parallel)
numCores &amp;lt;- detectCores()
numCores&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## [1] 8&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;¡Tenemos 8 núcleos lógicos!. En este caso, como regla general, vamos a a ocupar la mitad (4 nucleos). Si tuviéramos un sistema tipo Unix (linux o mac, por ejemplo), podríamos utilizar la función mclapply. Sin embargo, mclapply utiliza &lt;em&gt;forking&lt;/em&gt;, una útil función que simplemente crea una copia del sistema y realiza la operación, solo disponible en sistemas tipo Unix&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;iter &amp;lt;- seq(1, 20000)
system.time({
results &amp;lt;- mclapply(iter, lm_boot_fun, mc.cores = 7)
})&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Error in mclapply(iter, lm_boot_fun, mc.cores = 7): &amp;#39;mc.cores&amp;#39; &amp;gt; 1 is not supported on Windows&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Timing stopped at: 0 0 0&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;En nuestro caso, lo que haremos es crear un cluster manualmente, para eso, utilizamos la función makeCluster, lo que creara un objeto que utilizaremos como argumento en la función parlapply, en este caso vamos a ocupar 4 nucleos&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;cl &amp;lt;- makeCluster(4) # Hacemos el cluster
system.time(
results &amp;lt;- parLapply(cl, iter, lm_boot_fun)
)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## user system elapsed
## 0.03 0.00 4.76&lt;/code&gt;&lt;/pre&gt;
&lt;pre class="r"&gt;&lt;code&gt;stopCluster(cl) # Cerramos el cluster, NO OLVIDAR&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;Wow&lt;/strong&gt;, bajamos MUCHO el tiempo de procesamiento de nuestro bootstrap, ya podemos ir a tomarnos un matecito con tranquilidad, no sin antes destruir el cluster con la función stopCluster.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;¡Bien!&lt;/strong&gt; &lt;img src="https://media.giphy.com/media/4xpB3eE00FfBm/giphy.gif" /&gt;&lt;/p&gt;
&lt;p&gt;Podríamos dejar este tutorial aquí, pero este ejemplo es muy simple, en general utilizamos bases de datos que tenemos en nuestro computador, y 5-10 librerías.&lt;/p&gt;
&lt;div id="complejizando-la-funcion" class="section level3"&gt;
&lt;h3&gt;Complejizando la funcion&lt;/h3&gt;
&lt;p&gt;Probemos simulando que iris es una base de datos que tenemos en nuestra computador, adicionalmente, a nuestra función le agregaremos dos argumentos referidos a la base de datos y al tamaño de la muestra&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;# Escribo la base de datos iris en mi computador
write.csv(iris, file = &amp;quot;iris.csv&amp;quot;)
&lt;h1 id="leo-la-base-de-datos-que-creé"&gt;Leo la base de datos que creé&lt;/h1&gt;
&lt;p&gt;datos_pc &amp;lt;- read.csv(&amp;quot;iris.csv&amp;quot;)&lt;/p&gt;
&lt;p&gt;lm_boot_fun2 &amp;lt;- function(iter, data, n_sample) {&lt;/p&gt;
&lt;h1 id="ahora-data-y-n_sample-son-argumentos-de-la-función"&gt;Ahora data y n_sample son argumentos de la función&lt;/h1&gt;
&lt;p&gt;ind &amp;lt;- sample(1:nrow(data), size = n_sample)
data_sample &amp;lt;- data[ind, ]
model1 &amp;lt;- lm(data_sample[, &amp;quot;Sepal.Length&amp;quot;] ~ data_sample[, &amp;quot;Petal.Length&amp;quot;])
R2 &amp;lt;- summary(model1)$r.squared
coef &amp;lt;- coefficients(model1)
results &amp;lt;- c(&amp;quot;R2&amp;quot; = R2, coef)
return(results)
}&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;p&gt;Ahora vamos a hacer lo mismo pero con los argumentos adicionales de parlapply&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;cl &amp;lt;- makeCluster(4) # Hacemos el cluster
system.time(
results &amp;lt;- parLapply(cl, iter, lm_boot_fun2, data = datos_pc, n_sample = 100)
)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## user system elapsed
## 0.01 0.00 4.52&lt;/code&gt;&lt;/pre&gt;
&lt;pre class="r"&gt;&lt;code&gt;stopCluster(cl) # Cerramos el cluster, NO OLVIDAR&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Ahora pensemos que entra nuestro jefe diciendo que el cliente quiere un Random Forest (probablemente por que suena bacán/chevere), adaptemos nuestra función complacer a todos, vamos a usar la librería randomForest, y a guardar el pseudo-R2 y el MSE&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;library(randomForest)
&lt;p&gt;rf_boot_fun &amp;lt;- function(iter, data, n_sample) {
ind &amp;lt;- sample(1:nrow(data), size = n_sample)
data_sample &amp;lt;- data[ind, ]&lt;/p&gt;
&lt;h1 id="ejecuto-el-modelo-random-forest"&gt;Ejecuto el modelo Random Forest&lt;/h1&gt;
&lt;p&gt;model1 &amp;lt;- randomForest(Sepal.Length ~ Petal.Length, data = data_sample)&lt;/p&gt;
&lt;h1 id="extraigo-el-pseudo-r2"&gt;Extraigo el pseudo-R2&lt;/h1&gt;
&lt;p&gt;R2 &amp;lt;- model1$rsq[length(model1$rsq)]&lt;/p&gt;
&lt;h1 id="extraigo-el-mse"&gt;Extraigo el MSE&lt;/h1&gt;
&lt;p&gt;MSE &amp;lt;- model1$mse[length(model1$mse)]
results &amp;lt;- c(&amp;quot;R2&amp;quot; = R2, &amp;quot;MSE&amp;quot; = MSE)
return(results)
}&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;p&gt;Ahora usemos &lt;em&gt;parLapply&lt;/em&gt;&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;library(randomForest)
cl &amp;lt;- makeCluster(4) # Hacemos el cluster
system.time(
results &amp;lt;- parLapply(cl, iter, rf_boot_fun, data = datos_pc, n_sample = 100)
)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Error in checkForRemoteErrors(val): 4 nodes produced errors; first error: no se pudo encontrar la función &amp;quot;randomForest&amp;quot;&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Timing stopped at: 0 0 0&lt;/code&gt;&lt;/pre&gt;
&lt;pre class="r"&gt;&lt;code&gt;stopCluster(cl) # Cerramos el cluster, NO OLVIDAR&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;¿¿QUE PASÓ??&lt;/strong&gt; ¡ya llamé a &lt;em&gt;library(randomForest)&lt;/em&gt;!&lt;/p&gt;
&lt;div class="figure"&gt;
&lt;img src="https://media.giphy.com/media/DVkZv0SltX1h6/giphy.gif" /&gt;
&lt;/div&gt;
&lt;p&gt;Lo que pasó es lo siguiente: ya tenemos cargado el paquete &lt;em&gt;randomForest&lt;/em&gt; en nuestra sesión, sin embargo, en el momento que ocupamos la función &lt;em&gt;makeCluster&lt;/em&gt;, se abren &lt;em&gt;n&lt;/em&gt; nuevas sesiones de R, cada una desde cero, por lo que lo que debemos hacer es cargar los paquetes en todas estas sesiones, en algunos casos, también es necesario exportar las bases de datos y funciones.&lt;/p&gt;
&lt;p&gt;Para cargar el paquete &lt;em&gt;randomForest&lt;/em&gt; en los nodos del cluster ocupamos la función &lt;em&gt;clusterCall&lt;/em&gt;, que nos permite ejecutar una función en todos los clusters, en este caso la utilizamos para cargar la librería randomForest en todos los cluster&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;cl &amp;lt;- makeCluster(4) # Hacemos el cluster
clusterCall(cl, function() library(randomForest))&lt;/code&gt;&lt;/pre&gt;
&lt;pre class="r"&gt;&lt;code&gt;system.time(
results &amp;lt;- parLapply(cl, iter, rf_boot_fun, data = datos_pc, n_sample = 100)
)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## user system elapsed
## 0.02 0.00 137.75&lt;/code&gt;&lt;/pre&gt;
&lt;pre class="r"&gt;&lt;code&gt;stopCluster(cl) # Cerramos el cluster, NO OLVIDAR&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;div id="un-ejemplo-mas-realista-usando-machine-learning" class="section level2"&gt;
&lt;h2&gt;Un ejemplo más realista (usando Machine Learning)&lt;/h2&gt;
&lt;p&gt;Ok, mucho jugar y poca acción, vamos a presentar un ejemplo más realista, en este caso, el &lt;em&gt;tuning&lt;/em&gt; de un modelo. “tunear” un modelo se refiere muchas veces a escoger el valor optimo de uno o más parámetros, de acuerdo a algún estadístico de rendimiento del modelo (como el &lt;em&gt;R&lt;sup&gt;2&lt;/sup&gt;o&lt;/em&gt; el &lt;em&gt;RMSE&lt;/em&gt;), este tuneo se hace en la base de datos de entrenamiento o calibración, y el modelo se valida en los datos de validación.&lt;/p&gt;
&lt;p&gt;Vamos a simular que la base de datos “iris” es nuestra base de datos de entrenamiento, vamos a suponer que solo tenemos información sobre los sépalos (para hacerlo un poco más difícil)&lt;/p&gt;
&lt;p&gt;En este caso utilizaremos un &lt;em&gt;Support Vector Machine&lt;/em&gt; (SVM) para intentar predecir la especie en base al largo y ancho de los pétalos y sépalos, este modelo es muy bueno y funciona genial para tareas de clasificación, sin embargo, a ratos es bastante dependiente del parámetro de costo y el parámetro de gamma (en el caso que utilicemos la función radial), vamos a intentar optimizar ambos parámetros&lt;/p&gt;
&lt;p&gt;En este caso, el paquete &lt;strong&gt;e1071&lt;/strong&gt; ya trae una función &lt;em&gt;tune&lt;/em&gt;, que permite usar &lt;em&gt;cross validation&lt;/em&gt; para tunear el parámetro. En este caso se utilizaremos &lt;em&gt;10-fold&lt;/em&gt; con 3 repeticiones. Este ejemplo lo saqué de un caso real de un trabajo, en el que debíamos construir un modelo con una matriz de datos gigante, cada ejecución del modelo se tardaba aproximadamente 1 hora y media en ejecutarse, por lo que el tuneo iba a durar varios dias sin paralelizar&lt;/p&gt;
&lt;p&gt;¡Basta de hablar, veamos el modelo!&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;library(e1071)
svm_model &amp;lt;- svm(Species ~ Sepal.Length + Sepal.Width, data = iris)
summary(svm_model)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;##
## Call:
## svm(formula = Species ~ Sepal.Length + Sepal.Width, data = iris)
##
##
## Parameters:
## SVM-Type: C-classification
## SVM-Kernel: radial
## cost: 1
## gamma: 0.5
##
## Number of Support Vectors: 86
##
## ( 10 40 36 )
##
##
## Number of Classes: 3
##
## Levels:
## setosa versicolor virginica&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Como podemos ver, por defecto el costo que se utiliza es 1 y el gamma 0.5, veamos algo de las &lt;em&gt;performances&lt;/em&gt;&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;library(caret)
confusionMatrix(iris$Species, predict(svm_model))&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Confusion Matrix and Statistics
##
## Reference
## Prediction setosa versicolor virginica
## setosa 49 1 0
## versicolor 0 36 14
## virginica 0 12 38
##
## Overall Statistics
##
## Accuracy : 0.82
## 95% CI : (0.749, 0.8779)
## No Information Rate : 0.3467
## P-Value [Acc &amp;gt; NIR] : &amp;lt; 2.2e-16
##
## Kappa : 0.73
## Mcnemar&amp;#39;s Test P-Value : NA
##
## Statistics by Class:
##
## Class: setosa Class: versicolor Class: virginica
## Sensitivity 1.0000 0.7347 0.7308
## Specificity 0.9901 0.8614 0.8776
## Pos Pred Value 0.9800 0.7200 0.7600
## Neg Pred Value 1.0000 0.8700 0.8600
## Prevalence 0.3267 0.3267 0.3467
## Detection Rate 0.3267 0.2400 0.2533
## Detection Prevalence 0.3333 0.3333 0.3333
## Balanced Accuracy 0.9950 0.7980 0.8042&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Tenemos un &lt;em&gt;Accuracy&lt;/em&gt; de 0.82, en muchos casos eso no es suficiente, tratemos de mejorarlo tuneando los parámetros&lt;/p&gt;
&lt;p&gt;Creamos una función que con los argumentos costo y gamma me de el rendimiento del modelo, como se puede observar, solo utilizo la función &lt;em&gt;tune&lt;/em&gt; con un parámetro a la vez, se podría utilizar con una lista de parámetros, pero sería más difícil de paralelizar&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;tune_svm_par &amp;lt;- function(costo, gamma) {
control &amp;lt;- tune.control(
nrepeat = 3, repeat.aggregate = mean,
sampling = &amp;quot;cross&amp;quot;, sampling.aggregate = mean,
sampling.dispersion = sd,
cross = 10
)
&lt;p&gt;svm_cv &amp;lt;- tune(&amp;quot;svm&amp;quot;,
train.x = iris[, c(&amp;quot;Sepal.Length&amp;quot;, &amp;quot;Sepal.Width&amp;quot;)],
train.y = iris$Species,
kernel = &amp;quot;radial&amp;quot;,
scale = TRUE,
type = &amp;quot;C-classification&amp;quot;,
tunecontrol = control,
ranges = list(cost = costo, gamma = gamma)
)&lt;/p&gt;
&lt;p&gt;return(svm_cv$performances)
}&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;p&gt;Y ahora, para paralelizarla, vamos a tener que utilizar la función &lt;em&gt;clusterMap&lt;/em&gt;, que nos permite poner más de un argumento variable (es el equivalente a &lt;em&gt;mapply&lt;/em&gt; en la familia *apply)&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;costos.test &amp;lt;- seq(0.2, 4, by = 0.1)
gammas.test &amp;lt;- seq(0.2, 4, by = 0.1)
&lt;p&gt;grilla &amp;lt;- expand.grid(&amp;quot;costos&amp;quot; = costos.test, &amp;quot;gammas&amp;quot; = gammas.test)
nrow(grilla)&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;## [1] 1521&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;1521 valores, esto &lt;em&gt;deberia&lt;/em&gt; tardarse&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;t1 &amp;lt;- Sys.time()
&lt;p&gt;cl &amp;lt;- makeCluster(4) # Hacemos el cluster
clusterCall(cl, function() library(e1071))&lt;/p&gt;
&lt;p&gt;list.errores &amp;lt;- clusterMap(
cl = cl, fun = tune_svm_par,
costo = grilla$costos,
gamma = grilla$gammas,
SIMPLIFY = FALSE, RECYCLE = FALSE
)&lt;/p&gt;
&lt;p&gt;library(dplyr)
errores.bind &amp;lt;- bind_rows(list.errores)&lt;/p&gt;
&lt;p&gt;stopCluster(cl)&lt;/p&gt;
&lt;p&gt;t2 &amp;lt;- Sys.time()&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;print(t2 - t1)&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Time difference of 52.99884 secs&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;¡Nos demoramos casi nada!. Ahora a buscar la combinación de costo y gamma que nos da un menor error&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;knitr::kable(subset(errores.bind, errores.bind$error == min(errores.bind$error)))&lt;/code&gt;&lt;/pre&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr class="header"&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th align="right"&gt;cost&lt;/th&gt;
&lt;th align="right"&gt;gamma&lt;/th&gt;
&lt;th align="right"&gt;error&lt;/th&gt;
&lt;th align="right"&gt;dispersion&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr class="odd"&gt;
&lt;td&gt;885&lt;/td&gt;
&lt;td align="right"&gt;2.8&lt;/td&gt;
&lt;td align="right"&gt;2.4&lt;/td&gt;
&lt;td align="right"&gt;0.18&lt;/td&gt;
&lt;td align="right"&gt;0.1044681&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;Ahora probemos nuestro svm con esos parámetros&lt;/p&gt;
&lt;pre class="r"&gt;&lt;code&gt;library(e1071)
svm_model &amp;lt;- svm(Species ~ Sepal.Length + Sepal.Width, data = iris, cost = 2.6, gamma = 2)
library(caret)
confusionMatrix(iris$Species, predict(svm_model))&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;## Confusion Matrix and Statistics
##
## Reference
## Prediction setosa versicolor virginica
## setosa 50 0 0
## versicolor 0 36 14
## virginica 0 10 40
##
## Overall Statistics
##
## Accuracy : 0.84
## 95% CI : (0.7714, 0.8947)
## No Information Rate : 0.36
## P-Value [Acc &amp;gt; NIR] : &amp;lt; 2.2e-16
##
## Kappa : 0.76
## Mcnemar&amp;#39;s Test P-Value : NA
##
## Statistics by Class:
##
## Class: setosa Class: versicolor Class: virginica
## Sensitivity 1.0000 0.7826 0.7407
## Specificity 1.0000 0.8654 0.8958
## Pos Pred Value 1.0000 0.7200 0.8000
## Neg Pred Value 1.0000 0.9000 0.8600
## Prevalence 0.3333 0.3067 0.3600
## Detection Rate 0.3333 0.2400 0.2667
## Detection Prevalence 0.3333 0.3333 0.3333
## Balanced Accuracy 1.0000 0.8240 0.8183&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Como podemos observar, en este caso logramos subir la accuracy en el entrenamiento de 0.82 a 0.84, esto no parece tanto, pero un 2% de incremento por un procedimiento que nos tardó menos de un minuto (¡gracias a la paralelización!) es bastante bueno&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;¡Muchas gracias por llegar hasta el final de este tutorial!&lt;/strong&gt; &lt;strong&gt;Espero sus comentariós y dudas&lt;/strong&gt;&lt;/p&gt;
&lt;/div&gt;</description></item><item><title>Predicting Vascular Plant Richness in a Heterogeneous Wetland Using Spectral and Textural Features and a Random Forest Algorithm</title><link>https://www.juliancabezas.com/publication/lecs-riqueza/</link><pubDate>Sun, 01 May 2016 00:00:00 +0000</pubDate><guid>https://www.juliancabezas.com/publication/lecs-riqueza/</guid><description/></item><item><title>Evaluation of impacts of management in an anthropogenic peatland using field and remote sensing data</title><link>https://www.juliancabezas.com/publication/lecs-carbono/</link><pubDate>Tue, 01 Sep 2015 00:00:00 +0000</pubDate><guid>https://www.juliancabezas.com/publication/lecs-carbono/</guid><description/></item><item><title>How many measurements are needed to estimate accurate daily and annual soil respiration fluxes? Analysis using data from a temperate rainforest</title><link>https://www.juliancabezas.com/publication/lecs-respiracion/</link><pubDate>Tue, 01 Sep 2015 00:00:00 +0000</pubDate><guid>https://www.juliancabezas.com/publication/lecs-respiracion/</guid><description/></item><item><title>Reconstructing the vegetation disturbance history of a biodiversity hotspot in central chile using Landsat, Bfast and Landtrendr</title><link>https://www.juliancabezas.com/publication/igars-samovar/</link><pubDate>Tue, 01 Sep 2015 00:00:00 +0000</pubDate><guid>https://www.juliancabezas.com/publication/igars-samovar/</guid><description/></item></channel></rss>