Etiqueta: R

Cultivando información de la web

«Manitas de buda»
[Fotografía de Miguel Andrade]. (Rancho Viejo, Veracruz. 2019).

Minando artistas amigos

Antes que nada le doy las gracias a mi compañera de vida y mejor amiga Ladrón de Mar, quien me asistió en la grabación del video siguiendo la actividad generando dudas y aclaraciones.

Preámbulo

Que tal queridas personas. Espero que se encuentren llenas de salud y amor en estos tiempos de cambio. Esta entrada del blog fue inspirada por el canal de facebook Coronatv (@CoronaTV2020) y particularmente por una lectura realizada por Hunaac-cel: Músico, rapero y distinguido miembro del grupo. La lectura fue acerca de “La dictadura de los datos: La verdadera historia desde dentro de Cambridge Analytica y cómo el Big Data, Trump y Facebook corrompieron la democracia, y cómo puede volver a pasar”, libro de Brittany Kaiser, y nos platicó un poco acerca de cómo se crean perfiles psicológicos a partir de la información que dejamos tirada como basura en redes sociales (sí, likes y toda esa mierda). Resulta escalofriante la exactitud con la que pueden conocernos una vez que tienen suficientes datos, como recomendación podemos dar «Me gusta» y «Seguir» a cosas que no nos gustan para que no tengan un perfil tan preciso. Hacer esto también ayuda a que la información que se te presente (noticias, anuncios, etc.) no esté sesgada al tema definido de forma algorítmica como «de tu agrado».

Al finalizar esta actividad habremos aprendido:

  1. Algo de programación
  2. Raspar información de la web
  3. codificar y ejecutar un script

Introducción


Hoy platicaremos un poco acerca de cómo extraer información de la red, utilizaremos el lenguaje de programación R. Este lenguaje de programación tiene un enfoque al análisis estadístico y ha evolucionado tanto que ya puedes hacer casi cualquier cosa con su ayuda. Los invito a visitar este par de páginas web que construímos con R.

Coronavirus (Web app para ver tasa de infectados/muertos que raspa información diariamente de OMS)

Nicómaco (Web app para analizas números naturales y jugar con espirales de números primos)

Instalación

Si no tienes R puedes descargarlo aquí:

para Windows:

https://cran.r-project.org/bin/windows/base/

para Mac:

https://cran.r-project.org/bin/macosx/

instale R y prosiga con la actividad.

Resumen

Comenzaremos con un ejercicio sencillo obteniendo información de la URL

http://www.discogs.com

El cual es una base de datos de la música. Pero, la idea al fondo de esta actividad, es sembrar los conocimientos básicos para que cada quien pueda hacer sus propios proyectos de cultivo de datos.

En esta actividad, construiremos un script (archivo con serie de líneas de código que realiza una tarea específica al ser ejecutado) que al ejecutarlo nos pida el nombre de una artista y el programa automáticamente entre a la página del artista en discogs y extraiga la información de artistas que han colaborado con el artista buscado. A continuación agrego una captura de una ejecución del script en donde género la lista de «artistas amigos» o «colaboradores» de el artista buscado: Lassi Nikko.

La actividad es sencilla y se realiza paso a paso de manera que pueda seguirse sin mucho esfuerzo y esta destinada a cualquier público, sin importar si tiene o no conocimientos de programación. El video se realiza junto con un asistente que nos apoyará con generar dudas y preguntas durante la actividad de manera que sirva de ayuda a cualquiera que llegue a frenar su avance en la actividad debido a confusión o mal interpretación.

Actividad

Video de actividad, síguenos en Youtube.

Si eres de los que prefiere leer, aquí puedes consultar la actividad desarrollada en forma textual, que también puede servir como material de apoyo para resolver alguna duda del video.

http://www.mediafire.com/file/8wt0u9bsnhc3658/Mining_artist_friends.html/file

Dicho esto, no dejen de escribir con sus dudas, comentarios, sugerencias, correcciones. Las cuales leo y contesto con mucho gusto.

Me despido con los mejores deseos para todos ustedes.

– Atl Tlachinolli

Aplicaciones web educativas en R

Proporción de factores primos del numero 123123

R Shiny: herramienta en potencia para facilitar el proceso de enseñanza-aprendizaje

¡Hola a todos amigos!

En esta hermosa tarde de noviembre, aprovecharemos para platicarles un poco acerca del lenguaje de programación R y la poderosa librería Shiny, con la cual puedes diseñar tu propia aplicación web interactiva de manera increíblemente sencilla, te invitamos a conocer el poder de R Shiny probando la siguiente app, con la que podrás conocer entre otras cosas, las propiedades de los primeros diez millones de números naturales:

https://atltl.shinyapps.io/niko/

En la imagen de portada (al inicio), se muestra una grafica de pastel con cinco rebanadas, las cuales representan la proporción de los factores primos del numero 123123, los cuales son:
3, 7, 11, 13 y 41.

Si hacemos el producto de los factores primos de un numero, reconstruimos el numero original:

3 x 7 x 11 x 13 x 41 = 123123

Nota curiosa:

¿Recuerdan algo así como?

«El orden de los factores no altera el producto»

Esta oración habla específicamente de una multiplicación (producto). Los factores no son mas que los elementos que se multiplican. Pero esto no aplica para cualquier operación. Por ejemplo, en la división. Cuando no hay alteración por el orden de operado, decimos que la operación es conmutativa.

La aplicación fue bautizada con el nombre «Nicómaco», en honor al filósofo y matemático Nicómaco de Gerasa (primero en clasificar los números naturales en abundantes, deficientes y perfectos, según la suma de sus divisores propios) te permite conocer tanto los divisores propios de un número como la suma de los mismos. Obtener los factores primos y su clasificación según de Gerasa, entre otras cosas.

Con Nicómaco, podemos introducir los conceptos de número natural, numero primo y compuesto, de divisores y factores, entre otros, de una manera didáctica, interactiva y divertida. Aprovechando la tecnología que ofrece la amplia paquetería de librerías de R y unas cuantas funciones propias.

Además, Nicómaco contiene un espiral de Ulam interactivo, con el que se puede, una vez comprendidas las definiciones de números primos y compuestos (y saber que no existe una «fórmula» para obtener el n-ésimo primo) sumergirnos en la curiosidad visual del aparente orden en el caos de distribución primal sobre estos fabulosos espirales, donde podrá controlar tanto el número de vueltas cómo el número de entradas.

Espiral con 7107 entradas, 2470 vueltas.

A continuación presentamos una intrigante animación del espiral de Ulam que se obtuvo variando el numero de entradas mientras se mantenía un numero de vueltas constante, con 10 capturas por segundo…

Aquí dejamos el script con las funciones que se utilizaron para generar gifs de este tipo.
A la función create_gif() se le indica intervalo [a,b] y numero de vueltas. Se crean (b-a) imágenes en el directorio de trabajo en el que se encuentre. Con las que puede generar un gif con ayuda de una aplicación como PicGif (OSX).

## Script que genera b-a graficas para creac gif
## Function that plots Ulam Arquimedian Spiral (Pseudo Stach spiral, Stach gives 1 turn por cada cuadrado perfecto)
prime.spiral <- function(obs,vueltas){
  vueltas <- vueltas * 2  
  data.frame(x = seq(0, vueltas * pi, length.out = obs), primo = sapply(1:obs,chkp)) %>% mutate(theta = x %% (2 * pi), r = x) %>%
  ggplot() + aes(x = theta, y = r, colour = primo) +
  coord_polar(start = - pi / 2, direction = - 1) + 
  ggtitle(expression(Espiral~r == theta)) + geom_point() +
  ylim(0, vueltas * pi) + xlim(0, 2 * pi) +
  labs(x = NULL, y = NULL)
}

create_gif <- function(a,b,vueltas){
	v <- a:b
	for(n in v){
		myplot <- prime.spiral(n, vueltas) 
		png(paste("plot", n, ".png", sep = ""))
		print(myplot)
		dev.off()
	}
}

Se recomienda crear una carpeta especial para almacenar los archivos png creados por create_gif() y asignarla como directorio de trabajo. Una vez hecho esto basta con introducir las funciones anteriores y hacer:

create_gif(num_entradas_inicial, num_entradas_final, num_vueltas)

Ejemplo:

create_gif(100, 150, 20)

crea (150-100) = 50 imágenes de un espiral de veinte vueltas. iniciando con 100 entradas y aumentando de una en una hasta 150. Con estas 50 imágenes se puede crear un gif como el mostrado arriba con ayuda de algún software que genere gifs a partir de un conjunto de imágenes, software muy común hoy en día.

¡Espero que les haya parecido interesante y les deseo lo mejor!

–Atl Tlachinolli

Programación en R

Los primeros cuatro primos se encuentran entre el uno y el diez. Si los sumas, el resultado es 17

Números: primos, primos relativos perfectos y amigos

Aprendiendo R con curiosidades matemáticas

Preámbulo

¿Qué tal Tlachinollis?

En lo personal, por acá se podría decir que somos mas adeptos de ANSI C pero debemos comentar que nos estamos enamorando de R. Este poderoso, intuitivo y eficaz lenguaje, te permite aprender a programar evitando conceptos complicados como declaración de variables, apuntadores y asignación de memoria, es la herramienta perfecta para el estudiante de ciencias e ingenierías o para cualquiera con una curiosidad inherente por los números.

Confesaremos ser novatos en R, lo poquito que hemos escrito son unas funciones muy sencillas para el manejo de tablas generadas por sistemas de rastreo deportivo ZXY (ZXY Sport tracking systems), las cuales pueden hallarse aquí:

R ZXY Sport Tracking data edition tools

esto ya fue hace tres años y a hachazos, sin saber mucho de R se fue implementando en unos tres días por que así fue el plazo de trabajo, hicimos lo que se pidió… pero digamos que sin aprender de forma adecuada, o al menos como hubiésemos deseado en caso de haber tenido mas tiempo.

Ahora estamos desempolvando o más bien re-aprendiendo con paciencia y con ayuda de un par de libros excelentes para iniciarse, los cuales se encuentran en la red en varios sitios, aquí les dejo la lista con los enlaces por si les interesa:

La mejor manera de aprender es con las manos a la obra. Después de refrescarnos un poco de la sintaxis de R para quitarnos el chip ANSI C, algunos resultados fueron las siguientes funciones que sirven para revisar curiosidades matemáticas como números primos, números perfectos, números amigos y primos relativos, que son funciones muy básicas que presentan un buen ejercicio para el aprendizaje de un nuevo lenguaje de programación, además pueden llegar a ser de utilidad para estudiantes de cursos cómo fundamentos de álgebra . En fin, quisimos compartirlas, esperamos que a alguien le sean útiles.

Código

A continuación se muestra el código fuente y explicaremos como pueden usarse las funciones para pasar un buen rato.

¡Hágalo usted mismo!

Tan solo copie y pegue el siguiente código en la consola de R y presione introducir, con lo que estará listo para jugar con las funciones :

# R Qurra packet
# functions to test primes, relative primes, perfect and friend numbers
# This package may be useful for undergraduate students in Fundaments of Algebra courses
# where you are usually introduced deeply into this concepts and their properties
# tlachinolliatl@gmail.com
#########################################################################

# Function that checks for primality
# returns TRUE in case n prime, FALSE instead
# try checking primality for first 100 natural numbers like this:
# > chkrprime(1:100)
chkprime <- function(x){
	primo <- vector()
	j <- 1
	for(n in x){
		primo[j] <- T
		for(i in 2:(sqrt(n))){
			if(n%%i==0 && n!=2){
				primo[j] <-F
				break
			}
		}
	j <- j+1		
	}
return(primo)
}
# Function that returns a list of proper divisors of a given set of numbers
# divp stands for (div)isores (p)ropios
#
divp <- function (x){
	k <- 1
	lista <- list()
	for(n in x){
		divisores <- vector()
		j <- 1	
		for(i in 2:(n/2)){
			if(chkprime(n)) break # not looping if n is prime
			if(n%%i==0){
				divisores[j] <-i
				j <- j+1
			}
		}
	lista[[k]] <- c(1,divisores)
	k <- k + 1			
	}
return(lista)
}

# Function that checks if a pair of numbers are friends between them
# if friends, testfrnd returns TRUE, else it will return FALSE
#
#  Muhammad Baqir Yazdi found the pair (9363584,9437056) in the XVII century 
# Checking this pair took a couple of minutes for my old Intel Core 2 Duo at 2.13 GHz
# Try with  (1184, 1210) for faster computation
testfrnd <- function(x,y){
	divpx <- unlist(divp(x)) # is the same divp(x)[[1]]?
	divpy <- unlist(divp(y))
	sumx <- sum(divpx)
	sumy <- sum(divpy)
	if(sumx==y && sumy==x){
		return(T)
	}else return(F)
}
#Function that checks if two numbers x,y are relative primes between them
# i.e. MCD(x,y) = 1 i.e. they have no common proper divisors between them !=1
# if relative primes, testrprime returns TRUE, else it will return FALSE
testrlpr <- function(x,y){
	divpx <- unlist(divp(x))
	divpy <- unlist(divp(y))
	if(length(divpx)==1 && divpx[1]==1 || length(divpy)==1 && divpy[1]==1){
		return(T)
	}else
	if(any(divpx[2:length(divpx)]==divpy[2:length(divpy)])){
		return(F)
	}else return(T)
}

#Function that checks if a number is perfect
# i.e the sum of his proper divisors (including one) add up to the same number
# Example: proper divisors of 6 are 1, 2, 3 wich sum 1+2+3 = 6 the number itself
# RETURNS TRUE IF NUMBER IS PERFECT FALSE INSTEAD 
# Find the perfectos between 1:10000 with a crazy R loop like this:
# > for(i in 1:10000) if(testprfc(i)) print(i)
# be patient it may take a while
testprfc <- function(x){
	divpx <- unlist(divp(x))
	sumx <- sum(divpx)
	if(sumx==x){
		return(T)
	}else return(F)
}

En el siguiente video se muestra como sacarle un poco de jugo a estas funciones desde la consola de R, lo cual puede ser una práctica para cualquiera que se esté iniciando en este lenguaje:

Si tienes comentarios para mejorar el código o algún consejo de R relacionado con las funciones anteriores será muy apreciado.

¡Nos despedimos con los mejores deseos!

De los números he aprendido:

«Si quieres llegar a ser perfecto comienza por ser tu propio amigo»

– E.P. del Cerro

Gráfica y regresión local de temperatura interna LG M2762D

Se observa un comportamiento logarítmico con una posible asíntota en y = 35ºC tras dos horas de funcionamiento después de la reparación de Pierre y Atl mod.

Graficando datos capturados por sensor LM35 en Arduino Monitor Serie

Mah xipano

Problema

Insatisfechos con las gráficas obtenidas por el Arduino Serial Plotter, con sus raras escalas y repleta de interferencias generadas por las variaciones de voltaje (capturadas por el sensor LM35 durante los registros), decidimos hacer nuestras propias gráficas en R.

Resumen

Se modificó nuestro bosquejo de Arduino, de modo que lo único que se imprimiera en el Monitor Serie fueran pares ordenados X1, X2.
Donde X1 = segundos transcurridos y X2 = temperatura registrada en tiempo X1.
Después se realizaron tres pruebas, dos con un tiempo de 3600 segundos y una de 7200 (con distintos aparatos: Apple Tv, Philips DVD, Wii U), durante las cuales se registraron las medidas de temperatura por segundo con el bosquejo mencionado, todas las pruebas fueron realizadas con una luz de fondo al 100%. A continuación se copio la información del Monitor Serie y se guardó en un archivo de texto con extensión .csv para su futura exportación a R en donde se realizaron las graficas respectivas junto con una regresión local de el paquete lattice encontrado en librería de R.

La televisión pudo utilizarse por un periodo de 2h sin alcanzar los 35ºC (temperatura máxima de funcionamiento recomendada en el manual de usuario oficial de LG).

Existen diferencias en el comportamiento del aumento de la temperatura interna dependiendo del equipo que se esté utilizando o quizás dependiendo de la naturaleza de las imágenes presentadas durante las pruebas, aparentemente, el menor aumento de temperatura por unidad de tiempo se obtiene mediante transmisión por RGB observando videos en youtube, mientras el mayor se observa jugando Wii U conectado mediante HDMI. Dicho esto, aclaramos que la afirmación del párrafo anterior sigue siendo válida en ambos casos.

Requerimientos

  1. Computadora, Arduino, Sensor LM35, R.
  2. Bosquejo de Arduino para capturar datos:
    Bosquejo
  3. Archivo de datos capturados en extensión .csv, se obtiene con bosquejo anterior
    Ejemplo
  4. Script de R para graficar datos con regresión local:
    Script

Procedimiento

Con el sensor LM35 instalado en el interior de la TV, aislado y apartado lo suficiente para evitar cortos circuitos (ver esta entrada para mas información). Se importó el nuevo bosquejo a nuestro Arduino, el cual se colocó en la parte posterior del televisor de manera que pudieramos conectar el LM35 (hicimos una perforación en la parte trasera de la tele para dar salida a los cables del LM35 instalado adentro) y se realizaron tres experimentos para los cuales se mantuvo abierto el Monitor Serie de Arduino y al finalizar cada experimento se copio la información del Monitor en Serie y se pasó a un archivo de texto para guardarla con extensión .csv para después importarlas a R.

Se obtuvieron estos tres archivos:

https://www.mediafire.com/folder/23vzusy97i6eg/

Después se realizó el script de R que se presenta a continuación:

  
#R Plot - Graficando regresión local a partir de medidas con interferencia
#Medidas de temperatura de interior de TV LG m2762d tomadas con transistor LM35
#instalado en su interior, datos capturados con Arduino.
#Bosquejo de Arduino, apunta un par ordenado x,y donde x = segundo, y = temperatura
#en el monitor en serie. Uno por línea, estos datos fueron después copiados y pegados
#En un editor de texto y guardados con extensión .csv para su futura manipulación en R
#EL SIGUIENTE SCRIPT ESTÁ DESARROLLADO PARA GRAFICAR LOS DATOS CAPTURADOS JUNTO CON UNA
#REGRESIÓN LOCAL. LA FINALIDAD ES LA PRESENTACIÓN DE UNA CURVA DE TEMPERATURA
#CONTRA TIEMPO PARA ESTE EQUIPO DESPUÉS DE LA REPARACIÓN DE PIERRE Y MODIFICACIÓN ATL
#CON EL OBJETIVO DE PREVER FUTURAS PROBLEMÁTICAS EN LA PLACA DEL INVERSOR
#COMO USAR:
#
#------------------------------------------------------------------------------------
#Importando archivo:
#/Users/Administrador/Desktop/prueba_temperatura_8_jul_appletv
plotdata <- read.csv("directorio_de_archivo/archivo.csv")


#Graficando con regresión local (LOESS) con ayuda de lattice (librería de R)

#importando libreria de lattice
library(lattice)


#panel function pa' paintar pimped líneas
panel_fn <- function(x, y, ...)
{
    panel.xyplot(x, y,col = "cornflowerblue" ...)
    panel.xyplot(x, y, type = "smooth", col = "gray33", lwd ="4", ...)
    #panel.abline(v = 3600, col="darkorange")
    panel.abline(h = 35, col="orangered")
	
}


#plotting you menso!

xyplot(plotdata$X2 ~ plotdata$X1, panel = panel_fn, pch=".", cex = "2",xlab = "Etiqueta X", ylab = "Etiqueta Y" , main = "Título principal", xlim=c(0, max(plotdata$X2)), ylim = c(20,40) )

Basta sustituir <directorio_de_archivo/archivo.csv> por la ruta hacia tu archivo en la primera línea del código y correr el script para obtener la gráfica.

Resultados

Prueba 1. Apple TV, aprox 60 minutos

Línea naranja-roja horizontal en y = 32ºC. Supuesta asíntota según entrada anterior bajo una prueba por RGB de 1 hora 40 minuots. Aquí ya la está alcanzando en 1 hora. ¿Es RGB más cool?

Prueba 2. Philips DVD, aprox 60 minutos

Se puede apreciar que a pesar de que la Prueba 2 inició a una temperatura menor que la Prueba 1, se alcanzó la misma temperatura al cabo de 1 hora.
¿A qué se debe?

Prueba 3. Wii U, aprox 2 horas

Aparentemente se calienta mas rápido con Wii U. Podemos ver que en menos de una hora ya se rebasó la «asíntota» de 32ºC. También podemos ver que no parecen existir interferencias, debe ser por el convertidor AC/DC del Wii U.
¿Bonito no?

Conclusiones

Todavía no estamos seguros de nada en específico pero podríamos afirmar lo siguiente:

O utilizar la televisión por RGB es lo que menos genera estrés por temperatura y utilizarla con Wii U es lo que más.

Ó cada vez se está calentando más rápido nuestra televisión.

Debemos mencionar que en la prueba de 2 horas se comenzó a percibir un olor peculiar cómo a plancha caliente alrededor del segundo 6000. No era un olor a quemado, pero tampoco muy agradable. Pienso que quizás es buena idea dejar reposar la PCB dentro de agua destilada después de la reparación y limpieza (nosotros utilizamos alcohol isopropílico para limpiar después de las reparaciones) para eliminar cualquier residuo químico que pudiera despedir gases no deseables.

Secuela

En un par de semanas más, dándole uso a nuestra televisión vamos a abrirla nuevamente para ver el estado de nuestra PCB del inversor (pieza reparada) y de una vez crearemos un manual con instrucciones para realizar la reparación de Pierre y la modificación de Atl paso por paso, reuniendo las recomendaciones y advertencias que se conocieron durante la experimentación documentada en este, nuestro Blog de Vida.

Por otro lado, me parece intrigante la belleza que presentan los patrones de interferencias en las pruebas de Apple Tv y Philips DVD, y estamos pensando en traducir algunas secciones superiores de estas interferencias para escucharlas en forma de música.

Ahí hay un mensaje oculto…

¡Saludos amigos!

–Atl Tlachinolli