Archivo de la categoría: Manual

Resumen del paper: Análisis de datos topológicos

Recientemente me encontré un par de papers relevantes para la minería de datos (data mining). Incluso hay una empresa que basa su business model en este concepto (Ayasdi). El concepto como habéis podido leer en el titulo es análisis de datos topológicos. ¿Que significa esto? La ida principal, tal y como se expone en la Figura 1 (sacada del paper [1]), se basa en que los datos tienen forma y la forma es consistente. Por ejemplo, la letra “A” seguirá siendo la misma letra a pesar de que le apliquemos distintas transformaciones ya que la información obtenida es calculada en base a las distancias relativas. Podemos rotar los datos, hacia un lado u otro. Podemos cambiar la tipografía o la forma (aplastarla o extenderla) que seguirá siendo la misma letra. Al final la letra “A” esta formada por millones de puntos que no vemos. Quizás perdemos algo de detalle especifico pero se gana en visión global.

descripción gráfica de la letra A
Figura 1: Transformaciones aplicadas a la letra A siguen formando la misma letra. Extraído de [1]
El primer paso consiste en agrupar en sub-poblaciones en bins (contenedores). En el segundo paso estas divisiones son analizadas. Cada uno de los contenedores contiene puntos que son similares el uno al otro. Como los bins han sido divididos de tal forma que solapan entre ellos por lo que cada punto de nuestros datos pueden estar en más de un grupo. Finalmente para construir la red (network) dibujamos un link entre los distintos clusters de la network final.

Para empezar a construir la red tenemos que escoger la métrica y la lente. La métrica la usaremos para medir la similitud (o distancia) entre dos puntos mientras que la lente es una función matemática para observar los datos. Cualquier métrica que sirva para producir un numero de un punto puede ser una lente. Una lente puede ser la media, max, min, el centro, PCA-score, distancia SVM, entre otros. Se pueden agrupar los resultados de distintas lentes multiplicando el resultado de los outputs.

El vector unitario producido por a lente es dividido en subgrupos que se solapan. Todos los puntos que tienen valores de lentes en el mismo subgrupo se agrupan juntos en un contenedor. De esta forma distintas particiones son obtenidas para todos los puntos gracias al resultado de la lente. Como las lentes producen sets que solapan es posible que un punto este en múltiples contenedores. Todos los puntos en un contenedor son agrupados ya que todos los puntos son altamente similares entre si y este grupo representa un simple nodo de nuestra red. El color que le asignaremos es la media del color de la lente de este grupo. El nodo en su representación gráfica tiene un tamaño proporcional al numero de puntos que tenga el cluster.

Habiendo hecho lo pasos anteriores tendremos distintos nodos en nuestra red, con diferentes tamaños y colores. Los nodos se conectaran entre si cuando tengan puntos en común. Estos links generaran la red topológica final.

Tenemos que tener en cuenta que esta implementación tiene dos parámetros. Uno es la resolución que indica el numero de contenedores en los cuales vamos a partir los datos. Una baja resolución genera unos pocos nodos gruesos sintetizando la información generada por el algoritmo. Contrariamente si la incrementamos genera muchísimos nodos pero de un tamaño mas pequeño perdiendo similitud entre nodos incluso generando clusters aislados. El segundo parámetro se llama ganancia y controla las regiones que se solapan entre contenedores. Como mas grande sea la ganancia mas aristas (conexiones entre nodos) vas a obtener el tu red. Este parámetro resalta las relaciones entre los elementos de tus datos.

No hay unos valores óptimos para la resolución y la ganancia. Cada red es singular y sus parámetros tienen que ser escogidos acordemente. También depende de lo que se quiera observar en la red. Por lo que cada análisis requerire una afinación (tuning). Tened en cuenta que una resolución alta no siempre es lo mejor, ya que al final lo que puede producir un resultado muy similar al observar los datos directamente

Ya hemos explicado todas las ventajas ahora toca exponer algunas de sus desventajas. No es ninguna “magic bullet” puede funcionar para muchos casos pero hay otros en los que este algoritmo no sea el mejor para nuestros datos. No hay una sola solución que sea buena para todos los casos. Parte del problema es que es una ciencia con un alto componente matemático. Como los principios del deep learning, hasta que no haya implementaciones eficientes y fáciles de usar, la “gente normal” se va a abstener de usarlo. Finalmente, el coste computacional. Calcular todos los pasos es extremadamente costoso ya que se tienen que hacer distintos barridos sobre los datos e incluso calcular las distancias entre pares.

Para los que os vaya la marcha os dejo un vídeo de youtube. Se trata de un seminario en Standford donde se explica extremadamente bien el concepto (en ingles). Luego os dejo una presentación en slideshare donde se explica el concepto detalladamente. Y para terminar os dejo tres referencias que he usado para escribir este post y que si entendéis inglés las recomiendo encarecidamente que les echéis un vistazo.

 

 

Archivos multimedia para profundizar en el TDA

 

Referencias:

 

  1. Offroy, M., & Duponchel, L. (2016). Topological data analysis: A promising big data exploration tool in biology, analytical chemistry and physical chemistry. Analytica chimica acta910, 1-11.
  2. Nielson, J. L., Paquette, J., Liu, A. W., Guandique, C. F., Tovar, C. A., Inoue, T., … & Lum, P. Y. (2015). Topological data analysis for discovery in preclinical spinal cord injury and traumatic brain injury. Nature communications6, 8581.
  3. Chazal, F., & Michel, B. (2017). An introduction to Topological Data Analysis: fundamental and practical aspects for data scientists. arXiv preprint arXiv:1710.04019.

Restaurar la programación de artículos en WordPress

Hace poco me fui de viaje y vi que todas las entradas programadas para mi blog fallaron. El motivo por el cual la programación de los artículos en WordPress falla normalmente es por el uso de plugins. En especifico por el uso de plugins que cachean las páginas. Al cachear las páginas no se ejecuta el cron de WordPress y si no se ejecuta el cron entonces WordPress no publica los artículos programados.

Como no quiero perder toda la velocidad de carga que obtengo cacheando las páginas de mi blog he encontrado un método para arreglar el problema sin tener que desinstalar ningún plugin. Puedes instalar OTRO plugin para solucionar el problema o añadir un cronjob. En este artículo voy a explicar como arreglar la programación perdida de los artículos añadiendo un cronjob.

Hay hostings que puedes añadir el cronjob usando el panel de control (lo vas a tener que buscar tu en la pagina de ayuda de tu hosting) o si tienes control entero sobre tu servidor vas a poder añadir el conjob tu mismo. Básicamente se trata de ejecutar periódicamente el siguiente link

http://tudominio.com/wp-cron.php?doing_wp_cron

En condiciones normales este link se carga cada vez que un usuario entra en el blog pero si usamos cache la página no se carga y perdemos las publicaciones. Para poder publicar las entradas programadas y mantener nuestra cache tendremos que ejecutar este link de modo automático gracias al cronjob.

Un cronjob requiere de un comando (no de un link). Así que lo que he escrito un comando para que el link sea cargado sin guardar el HTML en ningún sitio:

wget -O /dev/null http://tudominio.com/wp-cron.php?doing_wp_cron

Personalmente lo he puesto cada hora, pero lo puedes poner cada 5minutos. No usa casi recursos así que difícilmente vas a sobrecargar el blog.

Recuerda que la primera vez que accedas al link después de los errores de programación, todas las entradas falladas se van a publicar a la vez. Consecuentemente es interesante que revises la programación de los posts antes de acceder al link.

Como hacer una copia de seguridad completa de nuestro servidor, base de datos y WordPress

Los backups son necesarios para cualquier sistema para prevenir la pérdida de datos. Siguiendo un poquito con la tónica de los últimos posts, instalar wordpress en un servidor propio y usar certificados SSL para nuestro WordPress, esta vez lo que haremos será un backup completo de nuestro WordPress. En este post lo que hago es crear un cronjob, osease un script que se ejecute a diario y haga una copia completa de nuestra base de datos juntamente con distintas carpetas que queramos conservar de nuestro blog.

Generamos un dump de todas las bases de datos

La base de datos es uno de los componentes más importantes de cualquier sistema. Es donde históricamente se ha guardado la información. Para hacer una copia de la base de datos necesitaremos mysqldump. Esto nos permitirá sacar una copia consistente de la base de datos.  Para obtener la copia de todas las bases de datos ejecutaremos el comando

mysqldump -u[usuario] -p[contraseña] --single-transaction --quick --all-databases > output.sql

El fichero output.sql contendrá toda la información en la base de datos.

Agruparemos todos los directorios y documentos en un solo archivo

Una vez ya tengamos generado el dump de nuestra base de datos lo que tendremos que hacer es crear un archivo único para mejorar la transportabilidad del backup. En mi caso también lo comprimo usando gzip para ahorrar espacio, ya que raramente se consultan/usan los backups y así ahorro espacio. En mi caso he usado tar (para una introducción podéis leer mi anterior post a tar) para mantener los permisos de cada archivo.

tar cfz /home/donde/quieras/archivo.tar.gz /var/www/ /directorio/hacia/backup/output.sql

En el comando anterior vemos que hemos creado un archivo comprimido que contiene el directorio var/www, y el dump que hemos hecho de la base de datos /directorio/hacia/backup/output.sql

Subiremos el archivo comprimido a un servidor externo

Para asegurarnos que cualquier problema que pueda tener nuestra máquina no afecte a nuestros backups subiremos el archivo comprimido a un servidor externo. Imagínate que haces sólo los backups pero los dejas en tu ordenador y el disco duro se estropea. Si pasa eso no podrías recuperar la información. Por esto es importante guardar copias de seguridad en distintos sitios.

Para este apartado he creado como un mini-script con las instrucciones para que el cliente FTP lo ejecute y haga la copia. En mi caso lo voy a guardar con el nombre ftp.txt

open [url o IP]
user usuario contraseña
passive #algunas veces requerido
put /home/donde/tenías_el/archivo.tar.gz nombre_del_archvo_en_el_ftp.tar.gz
bye

Finalmente ejecutaremos este trozo de código con

 ftp -n < ftp.txt

Asignaremos un cronjob que haga backups y los salvaguarde

A partir de la segunda vez que tienes que realizar una tarea uno tiene que empezar a pensar de que modo puede optimizar el proceso. Lo que he decidido hacer es crear un cronjob para que haga una copia de seguridad a diario y la suba al servidor externo mediante FTP.

echo "Starting script: $(date)"
day=$(date +"%d")

echo "Doing the mysql dump of all tables"
mysqldump -u[usuario] -p[contraseña] --single-transaction --quick --all-databases > output.sql

echo "Compressing the websites and the mysql dump into one file"
tar cfz /home/donde/quieras/archivo.tar.gz /var/www/ /directorio/hacia/backup/output.sql

echo "open url o IP 
user usuario contraseña 
passive #algunas veces requerido 
put /home/donde/tenías_el/archivo.tar.gz nombre_del_archvo_en_el_ftp.tar.gz 
bye" > ftp.txt

echo "Executing FTP and uploading the file"
ftp -n < ftp.txt

rm ftp.txt

Este vendría a ser el script que va a ejecutar el cronjob. Pero para ejecutar el script de forma automática tendremos que guardarlo propiamente como cronjob. Para esto usaremos el siguiente comando para editar los cronjobs de nuestro sistema.

crontab -e

y dentro del fichero, al final, escribiremos el siguiente comando

00 4 * * * sh /camino/hacia/cronjobs/cron_backup.txt > /dev/null 2>&1

Este comando ejecuta el script en /camino/hacia/cronjobs/cron_backup.txt cada día (los asteriscos) a las 4:00 (am) sin guardar el output (> /dev/null 2>&1). Ahora guardaremos el fichero y ya lo tendremos inicializado.

Para aprender un poquito más sobre los cronjobs podéis leer mi entrada anterior dónde lo explico más detalladamente.

Finalmente para recuperar los archivos

Cuando lo más temido pasa, cuando se nos estropea el ordenador y tenemos que ir a buscar los backups, lo tendremos todo preparado.

Primero nos logearemos con el cliente FTP y nos descargaremos el archivo con los backups.

ftp [url o IP]

pondremos el nombre de usuario y contraseña cuando nos lo pida. Una vez logueados descargaremos el fichero con el backup en nuestro ordenador local

get Nombre_del_backup.tar.gz

Saldremos de la sesión para descomprimir y extraer los archivos

tar xf Nombre_del_backup.tar.gz

Todo lo que sea blogs WordPress tendremos que copiar los ficheros en /var/ww/ otra vez y volver a configurar el apache. En cuanto la base de datos tendremos que importar el dump

mysql -u[usuario] -p output.sql

Y de este modo ya habremos recuperado todo lo que temíamos haber perdido.

Cómo forzar WordPress para que use un certificado SSL gratis mediante un plugin

En los posts anteriores hemos instalado WordPress y hemos alojado varios sitios en un mismo servidor. En este post lo que haremos será mejorar la seguridad de nuestro blog y las SERPs en Google. Hace ya un tiempo Google recomendó a los webmasters dejar de usar http y pasar a https para hacer la web más segura. Para forzar un poco el brazo Google ofreció mejoras en los rankings a aquellas webs que usaran un certificado SSL. Como no es fácil para todos los bloggers comprar un certificado SSL lo que propongo es obtener gratuitamente un certificado de SSL gracias a cloudflare y así poder ofrecer nuestro blog de forma más segura para los usuarios.  Para conseguirlo solo tenemos que seguir los siguientes pasos.

Instalar el plugin para el certificado SSL en wordpress

Para instalar el plugin WordPress podemos ir al apartado de plugins y buscar “WordPress HTTPS” e instalarlo usando el panel de control. También podemos instalarlo manualmente mediante FTP, subiéndolo directamente a la carpeta de /wp-content/plugins/ e instalándolo como cualquier otro complemento. Una vez instalado lo activaremos.

Conseguir el certificado SSL gratis

La mayoría de certificados son de pago pero cloud cloudflare fare nos permite usar un certificado SSL gratis para proyectos más modestos. Lo único que tenemos que hacer es registrarnos y añadir la página web cuando nos la pidan. Finalmente cambiaremos los name servers en nuestro registrador de dominios.

Actualizar los ficheros de configuración de WordPress

Finalmente iremos a ajustes generales en la sección de ajustes de nuestro blog wordpress y cambiaremos http por https dejando el resto de la url intacta. Por algún motivo que desconozco he tenido que cambiar el fichero wp-config.php. Justo antes de /* That’s all, stop editing! Happy blogging. */ he tenido que añadir

define('FORCE_SSL_ADMIN', false);

para poder acceder al wp-admin.

Espero que esto os haya servido para mejorar la seguridad del blog y los rankings de las SERPs.

Instalar WordPress en un servidor propio

Como ya vimos el otro día, podemos alojar varios sitios web en un mismo servidor. En mi caso para lo que los quería era para instalar distintas instancias de WordPress (osease distintos blogs). Pero para usar WordPress requerimos distintas aplicaciones para las diferentes partes del sistema.

PHP

Primero instalaremos PHP para que los scripts de WordPress puedan ser ejecutados.

sudo apt-get install php apache2 libapache2-mod-php php-mcrypt php-mysql

Base de datos

Ahora instalaremos la base de datos

sudo apt-get install mysql-server
 sudo mysql_secure_installation
 sudo mysql_install_db

y crearemos los usuarios para cada uno de nuestro blog. Primero nos logearemos como root para poder crear usuarios

mysql -u root -p

crearemos el usuario

GRANT ALL PRIVILEGES ON *.* TO 'user'@'localhost' IDENTIFIED BY 'pass';

Saldremos de la conexión con la base de datos con el root, y nos logearemos con el nuevo usuario

 mysql -u user -p

y crearemos una nueva base de datos para el blog

CREATE DATABASE db_wordpress;

Scripts de WordPress

Nos bajaremos la última versión de WordPress. La descomprimiremos y la pondremos en /var/www/directorio-de-tu-blog/. Para terminar de configurar el apache podéis seguir esta guía.

Finalizar

Para finalizar y que los cambios tengan efecto reiniciaremos apache

sudo systemctl restart apache2
 apt-cache search php- | less

y accederemos a la url de nuestro blog. Allí se nos pedirá que ingresemos los datos de la base de datos y otra información básica sobre el blog.

Optimizadores de tensor flow

Continuando el anterior post dónde introducí tensor flow hoy vengo con los optimizadores de funciones. Tensor flow ofrece optimizadores que cambian las variables para minimizar la funcion de perdida (loss function). El más simple es el de gradiente descendiente. Computan las derivadas simbólicas (symbolic derivatives) simplemente usando el modelo y la función tf.gradients. Por ejemplo:

[code language=”python”]
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
sess.run(init) # reset values to incorrect defaults.
for i in range(1000):
sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})
print(sess.run([W, b]))
los resultados finales
[array([-0.9999969], dtype=float32), array([ 0.99999082],
dtype=float32)]
[/code]

El modelo completo para la regresión linal es:

[code language=”python”]
import numpy as np
import tensorflow as tf
# Model parameters
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
# Model input and output
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)
# loss
loss = tf.reduce_sum(tf.square(linear_model – y)) # suma de los cuadrados
# optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# training data
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]
# training loop
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
sess.run(train, {x:x_train, y:y_train})
# evaluate training accuracy
curr_W, curr_b, curr_loss  = sess.run([W, b, loss], {x:x_train, y:y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))
# When run, it produces
#W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11
[/code]
tf.contrib.learn te simplifica la vida con las funciones: ejecución, entrenamiento, iteraciones, evaluaciones entre otros

[code language=”python”]
import tensorflow as tf
import numpy as np
features = [tf.contrib.layers.real_valued_column("x", dimension=1)]
estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)
x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x}, y, batch_size=4,
num_epochs=1000)
estimator.fit(input_fn=input_fn, steps=1000)
print(estimator.evaluate(input_fn=input_fn))
# Result: {‘global_step’: 1000, ‘loss’: 1.9650059e-11}
[/code]

Introducción a TensorFlow

La web oficial de TensorFlow tiene muy buenos recursos. En esencia lo que hay en este post proviene del “get started” de la web oficial.

En el primer ejemplo importaremos TensorFlow. Crearemos dos constantes y las imprimiremos en pantalla.

[code language=”python”]
import tensorflow as tf
node1 = tf.constant(3.0, tf.float32)
node2 = tf.constant(4.0) # También tf.float32 de forma implícita
sess = tf.Session()
print(sess.run([node1, node2]))
node3 = tf.add(node1, node2)
print("node3: ", node3) #Esta linea muestra las propiedades del tensor
print("sess.run(node3): ",sess.run(node3)) # Aquí se imprime el resultado[/code]

También podemos aplicar operaciones a los tensors. Las operaciones producen más tensores. En el siguiente ejemplo sumamos dos variables (tensores) y luego las sumamos. Un tensor es capaz de procesar listas también como veremos.

[code language=”python”]
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b
print(sess.run(adder_node, {a: 3, b:4.5})) # 7.5
print(sess.run(adder_node, {a: [1,3], b: [2, 4]})) # Itera sobre la lista: 3 y 7
[/code]

Podemos multiplicar

[code language=”python”]
add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))
[/code]

E incluso podemos crear modelos lineales

[code language=”python”]
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b
[/code]

Las constantes son inicializadas con tf.constant, y su valor no puede ser cambiado. Contrariamente las variables son creadas usando tf.Variable y no son inicializadas en el inicio. Para inicializar las variables  tenemos que usar una función especial como en el siguiente ejemplo:

[code language=”python”]
init = tf.global_variables_initializer()
sess.run(init)
[/code]

Lo importante es usar init. Es un “handle” que inicia el grafo, inicializando las variables que hasta entonces habían permanecido sin inicializar.

Ya que la X es la variable podemos evaluar el modelo usando distintos valores simultáneamente de la siguiente manera:

[code language=”python”]
print(sess.run(linear_model, {x:[1,2,3,4]}))
# Output: [ 0, 0.30000001, 0.60000002, 0.90000004]
[/code]

La función de pérdida (loss function) puede medir la distancia entre el modelo actual y los datos proporcionados. Usaremos la función de pérdida estándar para hacer una regresión lineal que sume los cuadrados de las distancias entre el modelo actual y los datos. El modelo crea un vector en el que cada posición corresponde a una distancia de error. Cuando usamos tf.square estamos elevando al cuadrado el error. Luego sumamos los errores para crear un simple escalar que abstrae el error de todos los puntos usando tf.reduce_sum:

[code language=”python”]
y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model – y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))
[/code]

El valor producido es:  23.66

Podríamos mejorar el modelo manualmente asignando nuevos valores a W para obtener resultados perfectos de -1 y 1. Una variables es inicializada por el valor proporcionado por tf.Variable pero puede ser cambiada si usamos operaciones como tf.assign. Por ejemplo, W=-1 y b=1 son los parámetros óptimos de nuestro modelo. Podemos cambiar W y b acordemente:

[code language=”python”]
fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]})
#resultado: 0
[/code]

Hemos adivinado el valor perfecto para W i b aunque este no es el objetivo de  machine learning. El objetivo es encontrar los parámetros correctos para el modelo automáticamente. Pero esto lo vais a encontrar en la próxima entrega 😉

Bonus: En matemáticas y en física, un tensor es cierta clase de entidad algebraica de varias componentes, que generaliza los conceptos de escalar, vector y matriz de una manera que sea independiente de cualquier sistema de coordenadas elegido. ( wikipedia )

Texmaker al estilo de Sublime text (monokai)

Sublime text, aunque es un editor de texto que me gusta mucho, he estado buscando alternativas. He encontrado textmaker. Texmaker es  un editor de latex que nos permite compilar el documento pdf además de añadir otras interesantes features. Lo que no me gustaba era el tema (theme) que tenía por defecto. Así que buscando di con la solución. Usar el theme de Sublime text, llamado monokai.

Para cambiarlo simplemente tenemos que ir a $HOME/.config/xm1 (tanto en linux, como en MacOS y editar el fichero texmaker.ini y reemplazar las siguientes lineas de la principio del fichero:

Color\Background=@Variant(\0\0\0\x43\x1\xff\xff\0\0++66\0\0)
Color\Command=@Variant(\0\0\0\x43\x1\xff\xff&&\x8b\x8b\xd2\xd2\0\0)
Color\Comment=@Variant(\0\0\0\x43\x1\xff\xffllqq\xc4\xc4\0\0)
Color\Highlight=@Variant(\0\0\0\x43\x1\xff\xff\a\a66BB\0\0)
Color\Keyword=@Variant(\0\0\0\x43\x1\xff\xff\xdc\xdc\x32\x32//\0\0)
Color\KeywordGraphic=@Variant(\0\0\0\x43\x1\xff\xff\x85\x85\x99\x99\0\0\0\0)
Color\Line=@Variant(\0\0\0\x43\x1\xff\xff\a\a66BB\0\0)
Color\Math=@Variant(\0\0\0\x43\x1\xff\xff**\xa1\xa1\x98\x98\0\0)
Color\NumberGraphic=@Variant(\0\0\0\x43\x1\xff\xff\xcb\xcbKK\x16\x16\0\0)
Color\Standard=@Variant(\0\0\0\x43\x1\xff\xff\x83\x83\x94\x94\x96\x96\0\0)
Color\Todo=@Variant(\0\0\0\x43\x1\xff\xff\xd3\xd3\x36\x36\x82\x82\0\0)
Color\Verbatim=@Variant(\0\0\0\x43\x1\xff\xff\xb5\xb5\x89\x89\0\0\0\0)

Generar una barra de progreso en ipython notebooks

Manual con código para generar una barra de progreso en nuestro código para saber en que porcentaje de compleción estamos sin llenar el output con números. Muchos de los que usáis jupyter (el nuevo ipython notebooks) podéis imprimir por pantalla la iteración en la que vuestro loop reside. Eso es solo posible para una cantidad pequeña de iteraciones. Cuando llegamos a varios miles se puede generar un output bastante engorroso. Googleando un poco encontré la solución. Este código nos genera una clase que luego podemos llamar para obtener la barra de progreso junto con el porcentaje completado.

[code language=”python”]
import sys, time
try:
    from IPython.core.display import clear_output
    have_ipython = True
except ImportError:
    have_ipython = False

class ProgressBar:
    def __init__(self, iterations):
        self.iterations = iterations
        self.prog_bar = ‘[]’
        self.fill_char = ‘*’
        self.width = 40
        self.__update_amount(int(0))
        if have_ipython:
            self.animate = self.animate_ipython
        else:
            self.animate = self.animate_noipython

    def animate_ipython(self, iter):
        try:
            clear_output()
        except Exception:
            # terminal IPython has no clear_output
            pass
        print ‘\r’, self,
        sys.stdout.flush(),
        self.update_iteration(iter + 1)
        
    def update_iteration(self, elapsed_iter):
        self.__update_amount((elapsed_iter / float(self.iterations)) * 100.0)
        self.prog_bar += ‘  %d of %s complete’ % (elapsed_iter, self.iterations)

    def __update_amount(self, new_amount):
        percent_done = int(round((new_amount / 100.0) * 100.0))
        all_full = int(self.width – 2)
        num_hashes = int(round((percent_done / 100.0) * all_full))
        self.prog_bar = ‘[‘ + self.fill_char * num_hashes + ‘ ‘ * (all_full – num_hashes) + ‘]’
        pct_place = int((len(self.prog_bar) / 2) – len(str(percent_done)))
        pct_string = ‘%d%%’ % percent_done
        self.prog_bar = self.prog_bar[0:pct_place] + \
            (pct_string + self.prog_bar[pct_place + len(pct_string):])

    def __str__(self):
        return str(self.prog_bar)
        

[/code]

Y el siguiente código vemos un ejemplo de como llamaremos la clase para obtener la funcionalidad deseada

[code language=”python”]
c = ProgressBar(1000)
for i in range(1000):
    c.animate_ipython(i)
[/code]

Para los interesados encontré el código aquí.

Instalar ubuntu desde un USB

Instalar Ubuntu (o la mayoría de distribuciones más o menos conocidas) puede hacerse utilizando un USB sin necesidad de quemar (burn) un CD. Es mucho más simple de lo que parece si se siguen los puntos de la lista:

  1. El primer paso es descargar Ubuntu.
  2. Comprobar el md5um
    • Usar el siguiente el comando en la terminal: md5sum ubuntu-11.10-dvd-i386.iso
    • Comprobar el hash que te da como resultado con los hashes oficiales de canonical.
  3. Para finalizar preparar Ubuntu en un USB vacío. Para esto usaremos UNetbootin y seguiremos las “instrucciones”.

Más fácil imposible. Para más info la página oficial.