El podcast de Linux Hispano – #062 – GNU/Linux en vez de Linux

Guionista y locutor: Manuel Ignacio López Quintero.
Fecha de publicación: diciembre de 2016.

Opinión:

- Llamar al sistema operativo GNU/Linux en vez de Linux.

Calcular si un año es bisiesto en python 3

Aquí os dejo un pequeño código en Python 3 para empezar a trabajar las condicionales anidadadas:

año = int(input('Introduce un año: '))

if año % 4 == 0:
    if año % 100 == 0:
        if año % 400 == 0:
            print('El año es bisiesto')
        else:
            print('El año no es bisiesto')
    else:
        print('El año es bisiesto.')
else:
    print('El año no es bisiesto.')

Anaconda – Distribución Python

anaconda_logo

Anaconda es una distribución Python que contiene una gran cantidad de paquetes, la mayoría enfocados al mundo científico y al procesado de datos.

Viene incluído además uno de mis IDE favoritos para Python: Spyder.

Instalar Anaconda es muy sencillo y viene con todos los paquetes que personalmente yo necesito y me evito de usar decenas de comandos apt-get o de entornos virtuales.

Y vosotros, ¿habéis probado Anaconda? ¿Qué os parece?

Enlace: Página oficial de Anaconda.
Enlace: Página oficial de descargas de Anaconda.
Enlace: Página oficial de paquetes incluídos en Anaconda.

Instalar OpenCV 3.1 en Ubuntu 16.04 LTS

Hace aproximadamente un año y medio que publiqué un tutorial sobre cómo Instalar OpenCV 3.0.0 en Ubuntu 14.04 LTS.

En este caso os traigo el mismo tutorial, en inglés pero muy fácil de seguir, pero verificado para instalar OpenCV 3.1.0 en Ubuntu 16.04 LTS. Éste es el enlace: Install OpenCV on Ubuntu or Debian.

El script de instalación incluído en el tutorial ha sido verificado para los siguientes sistemas operativos y versiones de OpenCV:

· Ubuntu 14.04 LTS.
· Ubuntu 16.04 LTS.
· Debian 8 "Jessie".

· OpenCV 3.0.0.
· OpenCV 3.1.0.

¿Qué tiene que mejorar primordialmente Linux de escritorio para ganar cuota de mercado?

Nota: en aras de la simplificidad, usaré el término Linux de escritorio a una distribución de escritorio GNU/Linux. Como es conocido, la controversia sigue presente siendo respetable cada una de las opiniones, hasta aquellas que defienden denominaciones como GNU/Apache/etcétera/Linux.

No hay un referente claro para determinar el porcentaje de usuarios que utilizan Linux de escritorio. Hay varios informes como el que ofrece StatCounter Global Stats. Otro informe se puede ver en la encuesta sobre hardware y software que Steam que hace periódicamente. En estas dos se puede observar claramente cómo Linux de escritorio está en porcentajes por debajo del 7 % o por debajo del 1 %. Incluso en la encuesta a los desarrolladores en Stack Overflow, Linux de escritorio está por debajo de Windows y OS X.

Está claro que Linux de escritorio necesita un obtener una mayor cuota de uso. La pregunta es, ¿cuál sería el principal y primer objetivo para obtener un avance considerable en número de usuarios? Existen muchísimos enfoques, hay algunos que pueden emprenderse gracias a la comunidad de Linux, pero otros sólo dependen de las empresas. Los interrogantes para encontrar el principal problema y superarlo son muchos:

  • ¿Ofrecer a los compradores de un PC nuevo la oportunidad de elegir el sistema operativo Linux de escritorio?
  • ¿Facilitar aún más al usuario la instalación y uso de drivers, plugins, dispositivos, etc.?
  • ¿Que publiquen más juegos compatibles con Linux de escritorio?
  • ¿Que adopten programas profesionales como Adobe Photoshop, AutoCAD, Pro Tools, etc.?

Como se puede ver, estos son algunos ejemplos, pero hay muchísimos más.

Para ti, ¿qué tiene que mejorar primordialmente Linux de escritorio para ganar cuota de mercado?

Crea un vídeo a partir de imágenes desde tu terminal Linux

Para mostrar claramente los resultados de mis experimentos, he tenido que realizar vídeos que muestren de manera clara los resultados de mis ejecuciones.

Para ello, he usado una de las herramientas más versátiles: ffmpeg. Para instalarlo sólo tienes que ejecutar:

sudo apt-get install ffmpeg

Para mostrar el uso de ffmpeg para convertir imágenes a vídeo os lo mostraré mediante un ejemplo que podéis modificar a vuestro antojo.

Con este ejemplo se crea un vídeo de 5 segundos a 30 FPS utilizando 15 imágenes. Para dicho ejemplo, las imágenes deben seguir la secuencia: 000.png, 001.png, 002.png, etc.

Una vez metidas las imágenes dentro de una carpeta, entra en dicha carpeta desde la termianl y ejecuta:

ffmpeg -r 3 -i %03d.png -r 30 out.mp4

Donde -r 3 sería el número de imágenes por segundo (que sería 3 ya que queremos hacer un vídeo de 5 segundos con 15 imágenes), -i %03d.png sería la entrada, -r 30 sería la salida de vídeo a 30 Hz (o 30 FPS).

Aplicar una máscara binaria en una imagen en Python

Si trabajas en Visión Artificial, muchas veces es necesario aplicar una segmentación en una imagen mediante una máscara binaria.

En un principio sólo necesitas las librerías de Numpy y Matplotlib de Python.

Aquí os dejo un script de ejemplo donde uso Scipy para cargar una máscara desde GNU Octave/MATLAB:

import numpy as np
import scipy.io as sio # Permite cargar un fichero de GNU Octave/MATLAB
from matplotlib import pyplot as plt

image = plt.imread('entrada.png')
bin_mask = sio.loadmat('mask.mat')['bin_mask'].astype('bool')

mask = np.dstack((bin_mask, bin_mask, bin_mask))

image[~mask] = 0
plt.imsave('salida.png', image)

Creo que ésta es la manera más elegante de hacerlo. Si alguien conoce alguna alternativa más reducida o con menos módulos cargados estaré encantado de que la comparta.

Renombrar ficheros a números en orden ascendente en Python

Últimamente para mis scripts, en vez de utilizar Bash u otras alternativas como GNU/Octave, estoy usando el lenguaje de programación Python. Para mí, Python es un lenguaje robusto y muy potente donde destaca en él algo que me fascina: la facilidad para leer código y reusarlo.

En este caso me gustaría compartir con vosotros un script que he creado hoy en el que he tenido que renombrar unas imágenes el siguiente orden: '00000.jpg', '00001.jpg', '00002.jpg', '00003.jpg', etc. Para ello se lee en una carpeta por orden nominal las imágenes jpg que lo contienen y después se procede a renombrarlos numéricamente y ascedentemente según el identificador que le hayamos pasado que en este caso es el 0.

Aquí os dejo el script modificado ligeramente para que sea más entendible:

import glob
import os

identificador = 0
ruta_carpeta = '/home/nacho/fotos'

lista_fotos = sorted(glob.glob(ruta_carpeta + '/*.jpg'))

for i in lista_fotos:   
    nuevo_nombre = ruta_carpeta + '/' + str(identificador).zfill(5) + '.jpg'        
    identificador = identificador + 1
    os.rename(i, nuevo_nombre)

Este código funciona para Python 2 y Python 3.

Extraer o descomprimir una imagen ISO desde la terminal

Cuando trabajamos en un ordenador con GNU/Linux que no tenga interfaz gráfica y necesitamos extraer o descomprimir una imagen ISO desde la terminal, lo mejor es recurrir a la aplicación 7-Zip.

Primero comprueba que tienes instalado 7-Zip (por ejemplo en Debian o Ubuntu) y todas sus utilidades:

sudo apt-get install p7zip p7zip-full

Por último, descomprime la imagen ISO desde la terminal:

7z x nombre_de_la_imagen.iso

Si el archivo no es muy grande, en pocos minutos tendrás extraído la imagen ISO en tu disco duro.

Ian Murdock, fundador de Debian, ha fallecido

ian_murdock

Ian Murdock, fundador del proyecto Debian, ha fallecido a la edad de 42 años.

Hace tiempo que me pasé de Ubuntu, que no deja de ser un derivado de Debian, a Debian dando 5 razones por aquel entonces. Con el tiempo mis razones se cuentan por decenas.

Tanto para trabajo como para ocio, paso prácticamente todos los días horas y horas delante de Debian.

Por todo esto y mucho más, muchísimas gracias, Ian, de verdad.

El podcast de Linux Hispano – #061 – Avance moderado en GNU/Linux

Guionista y locutor: Manuel Ignacio López Quintero.
Fecha de publicación: diciembre de 2015.

Opinión:

- Continuum gana en 2015 la convergencia a Ubuntu.
- Progresión sosegada con las nuevas versiones de Mesa, Beignet y GCC.
- Perspectivas no tan optimistas para 2016 en el mundo de GNU/Linux y el Software Libre.

Raspberry Pi Zero, el ordenador de 5 dólares

La Raspberry Pi Foundation ha anunciado la Raspberry Pi Zero, un ordenador de 5 dólares que hará las delicias de los amantes de los Micro-PCs.

Las características son las siguientes:

· Procesador Broadcom BCM2835.
· Núcleo 1 GHz ARM11 (40% más rápido que la Raspberry Pi 1).
· 512MB de LPDDR2 SDRAM.
· Un conector para tarjetas micro-SD.
· Un puerto mini-HDMI con 1080p60 de salida de vídeo.
· 2 Micro-USB sockets para datos y alimentación.
· 40-pin GPIO.
· Dimensiones de 65 mm x 30 mm x 5 mm.

Personalmente, pienso que ha sido una jugada acertadísima de la fundación. Sin embargo, todavía hay aspectos que mejorar: que el hardware sea completamente libre.

Y vosotros, ¿qué opináis?

Intel Skylake Graphics: Windows 10 aplasta a Ubuntu en rendimiento

Desde casi siempre, el rendimiento en GNU/Linux sobrepasa al de Windows en todos los aspectos. Sin embargo, Michael Larabel, de Phoronix, ha realizado varios Benchmarks y ha demostrado, muy a pesar de todos nosotros, que Windows 10 gana por goleada a Ubuntu en cuestión de rendimiento gráfico.

Lo que compara Michael es la última generación de los procesadores gráficos de Intel, exactamente un Core i5 6600K HD Graphics 530, con los siguientes sistemas operativos: Windows 10 Pro y Ubuntu 15.10, ambos de 64 bits. Para comparar cómo funciona el procesador gráfico en uno y otro sistema operativo se utiliza las últimas implementaciones de OpenGL: Intel 20.19.15.4300 graphics driver para Windows y Mesa 11.1-devel para Ubuntu (con el núcleo Linux 4.3.0 stable).

0

Aquí están la una buena parte de las pruebas. Compara los fotogramas por segundo (FPS) en las diferentes pruebas, por tanto cuanto mayor sea el FPS, mejor es el rendimiento:

1

2

3

Os recomiendo enormemente que veáis el Benchmarks entero de Michael Larabel. La verdad es que me sorprende los resultados, acostumbrado a que fuera al revés pero no me extraña, la cantidad de recursos invertidos en la implementación de librerías y drivers cambia muchísimo a favor de Windows 10.

Enlace: Artículo original.

Curso breve de aprendizaje supervisado con Theano en Linux Hispano

El aprendizaje supervisado es la tarea de aprendizaje de una máquina para inferir una función a partir de datos de entrenamiento etiquetados.

Theano es una librería que te permite definir, optimizar y evaluar expresiones matemáticas de manera eficiente. Al estar basado en Python, resulta una herramienta muy útil y fácil de usar para el desarrollo de modelos mediante aprendizaje supervisado, entre otras muchas más cosas.

Desde Linux Hispano, te presentamos un breve curso donde aprenderás a crear una regresión lineal, una regresión logística y varias redes neuronales artificales.

Enlace: Curso breve de aprendizaje supervisado con Theano.

Red neuronal convolucional – Theano

Aquí os dejo con un ejemplo (red_neuronal_convolucional.py) muy sencillo y claro para realizar una red neuronal convolucional.

import theano
from theano import tensor as T
from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams
import numpy as np
from Load import mnist
from theano.tensor.nnet.conv import conv2d
from theano.tensor.signal.downsample import max_pool_2d

srng = RandomStreams()

def floatX(X):
    return np.asarray(X, dtype=theano.config.floatX)

def init_weights(shape):
    return theano.shared(floatX(np.random.randn(*shape) * 0.01))

def rectify(X):
    return T.maximum(X, 0.)

def softmax(X):
    e_x = T.exp(X - X.max(axis=1).dimshuffle(0, 'x'))
    return e_x / e_x.sum(axis=1).dimshuffle(0, 'x')

def dropout(X, p=0.):
    if p > 0:
        retain_prob = 1 - p
        X *= srng.binomial(X.shape, p=retain_prob, dtype=theano.config.floatX)
        X /= retain_prob
    return X

def RMSprop(cost, params, lr=0.001, rho=0.9, epsilon=1e-6):
    grads = T.grad(cost=cost, wrt=params)
    updates = []
    for p, g in zip(params, grads):
        acc = theano.shared(p.get_value() * 0.)
        acc_new = rho * acc + (1 - rho) * g ** 2
        gradient_scaling = T.sqrt(acc_new + epsilon)
        g = g / gradient_scaling
        updates.append((acc, acc_new))
        updates.append((p, p - lr * g))
    return updates

def model(X, w, w2, w3, w4, p_drop_conv, p_drop_hidden):
    l1a = rectify(conv2d(X, w, border_mode='full'))
    l1 = max_pool_2d(l1a, (2, 2))
    l1 = dropout(l1, p_drop_conv)

    l2a = rectify(conv2d(l1, w2))
    l2 = max_pool_2d(l2a, (2, 2))
    l2 = dropout(l2, p_drop_conv)

    l3a = rectify(conv2d(l2, w3))
    l3b = max_pool_2d(l3a, (2, 2))
    l3 = T.flatten(l3b, outdim=2)
    l3 = dropout(l3, p_drop_conv)

    l4 = rectify(T.dot(l3, w4))
    l4 = dropout(l4, p_drop_hidden)

    pyx = softmax(T.dot(l4, w_o))
    return l1, l2, l3, l4, pyx

trX, teX, trY, teY = mnist(onehot=True)

trX = trX.reshape(-1, 1, 28, 28)
teX = teX.reshape(-1, 1, 28, 28)

X = T.tensor4(dtype='float64')
Y = T.matrix()

w = init_weights((32, 1, 3, 3))
w2 = init_weights((64, 32, 3, 3))
w3 = init_weights((128, 64, 3, 3))
w4 = init_weights((128 * 3 * 3, 625))
w_o = init_weights((625, 10))

noise_l1, noise_l2, noise_l3, noise_l4, noise_py_x = model(X, w, w2, w3, w4, 0.2, 0.5)
l1, l2, l3, l4, py_x = model(X, w, w2, w3, w4, 0., 0.)
y_x = T.argmax(py_x, axis=1)


cost = T.mean(T.nnet.categorical_crossentropy(noise_py_x, Y))
params = [w, w2, w3, w4, w_o]
updates = RMSprop(cost, params, lr=0.001)

train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)
predict = theano.function(inputs=[X], outputs=y_x, allow_input_downcast=True)

for i in range(100):
    for start, end in zip(range(0, len(trX), 128), range(128, len(trX), 128)):
        cost = train(trX[start:end], trY[start:end])
    print(np.mean(np.argmax(teY, axis=1) == predict(teX)))

Recuerda que para ejecutar este ejemplo necesitas preprocesar la base de datos MNIST. Las instrucciones para el archivo Load.py y la base de datos MNIST las puedes encontrar en el tutorial de Theano sobre regresión logística.

Por último, para ejecutar el código simplemente ejecuta: python3 red_neuronal_convolucional.py.

Éste código puede tardar bastantes horas (incluso días dependiendo del ordenador). Puedes configurar Theano para que funcione en la GPU de tu PC y así reducir el tiempo de ejecución. También puedes parar el proceso en cualquier momento con Ctrl + C o simplemente cerrando la terminal.


1 2 22 23