Guía de variables de entorno para data scientists

Quizá te hayas topado con algún software que te pide permiso para modificar tu variable PATH, o con instrucciones de instalación que, de forma un tanto críptica, te dicen que tienes que "configurar correctamente la variable LD_LIBRARY_PATH".

Como data scientist, puedes encontrarte con otros problemas relacionados con variables de entorno al trabajar con tu stack de cómputo (sobre todo si no lo controlas por completo, como me pasa a mí). Este artículo pretende desmitificar qué es una variable de entorno y cómo se usa en un contexto de ciencia de datos.

¿Qué es una variable de entorno?

Para empezar, déjame explicarte qué es una variable de entorno profundizando en la variable PATH. Te animo a ejecutar aquí los comandos en tu terminal bash (con las adaptaciones necesarias: lee el texto para entender qué estoy haciendo).

Cuando inicias sesión en tu sistema, ya sea en la terminal de tu ordenador o en un servidor remoto por SSH, tu intérprete bash necesita saber dónde buscar ciertos programas, como nano (el editor de texto), git (tu software de control de versiones) o tu ejecutable de Python. Esto lo controla la variable PATH. En ella se especifican las rutas a las carpetas donde se encuentran los programas ejecutables.

Por convención histórica, los programas de línea de comandos, como nano, which y top, se encuentran en el directorio /usr/bin. (También por convención, la carpeta /bin es para binarios, de ahí el nombre /bin.) Estos suelen venir con tu sistema operativo y, por ello, requieren permisos especiales para actualizarse.

Pruébalo en tu terminal:

$ which which
/usr/bin/which
$ which top
/usr/bin/top
Con la tecnología de

Otros programas se instalan (por distintos motivos) en /bin. ls es un ejemplo:

$ which ls
/bin/ls
Con la tecnología de

Y otros pueden estar en directorios especiales:

$ which nano
/usr/local/bin/nano
Con la tecnología de

¿Cómo sabe tu terminal Bash dónde buscar cada cosa? Usa la variable de entorno PATH. Suele verse así:

$ echo $PATH
/usr/bin:/bin:/usr/local/bin
Con la tecnología de

Lo más importante que debes recordar de la variable PATH es que está "delimitada por dos puntos". Es decir, cada ruta de directorio está separada por el carácter dos puntos (:). El orden de búsqueda de programas va de izquierda a derecha:

• /usr/bin
• /bin
• /usr/local/bin

En mi ordenador, cuando escribo ls, el intérprete bash mira primero en /usr/bin. Como ls no está en /usr/bin, pasa al siguiente directorio, /bin. Como mi ls está en /bin, ejecuta el programa desde ahí.

Como ves, esto es a la vez muy flexible para personalizar tu entorno de cómputo, pero también potencialmente frustrante si algún programa modifica tu variable PATH sin que te enteres.

¿Se puede modificar la variable PATH? Sí, y hay varias formas de hacerlo.

Cómo modificar la variable PATH

Usando una sesión de Bash

La primera forma es transitoria, o temporal, y solo afecta a tu sesión actual de bash. Puedes dar prioridad a una carpeta sobre las rutas existentes "anteponiéndola" a la variable PATH:

$ export PATH=/path/to/my/folder:$PATH
$ echo $PATH
/path/to/my/folder:/usr/bin:/bin:/usr/local/bin
Con la tecnología de

O puedes darle menor prioridad "añadiéndola al final" de la variable PATH:

$ export PATH=$PATH:/path/to/my/folder
$ echo $PATH
/usr/bin:/bin:/usr/local/bin:/path/to/my/folder
Con la tecnología de

Esto es temporal porque solo lo exportas durante tu sesión actual de bash.

Archivo bashrc o .bash_profile

Si quieres que los cambios sean algo más permanentes, inclúyelos en tu archivo .bashrc o .bash_profile (te recomiendo usar .bashrc). El archivo .bashrc/.bash_profile vive en tu directorio personal (lo indica tu variable de entorno $HOME) y es un archivo que tu intérprete bash ejecuta al iniciar. Ejecutará todos los comandos que haya dentro. Esto significa que puedes cambiar tu variable PATH simplemente añadiendo a tu .bashrc:

...otras cosas arriba...
# Da mayor prioridad a /path/to/folder
export PATH=/path/to/folder:$PATH

# Da menor prioridad a /path/to/other/folder
export PATH=$PATH:/path/to/folder
...otras cosas abajo...
Con la tecnología de

Data science y la variable de entorno PATH

Bien, ¿qué tiene que ver esto con las personas que trabajan en ciencia de datos? Si haces ciencia de datos, es muy probable que uses Python y que tu intérprete venga de la distribución Anaconda (altamente recomendable). El instalador de Anaconda da prioridad a la carpeta /path/to/anaconda/bin en la variable de entorno PATH. Puede que tengas otros intérpretes de Python instalados en tu sistema (por ejemplo, Apple incluye el suyo). Sin embargo, esta modificación de PATH garantiza que cada vez que escribas python en la terminal, se ejecute el intérprete de Python de Anaconda. En mi caso, tras instalar Anaconda, mi PATH queda así:

$ echo $PATH
/Users/ericmjl/anaconda/bin:/usr/bin:/bin:/usr/local/bin
Con la tecnología de

Aún mejor: cuando activas entornos de conda, se antepone la ruta a la carpeta de binarios del entorno mientras esté activo. Por ejemplo, para mi blog, uso un entorno llamado lektor. Así...

$ echo $PATH
/Users/ericmjl/anaconda/bin:/usr/bin:/bin:/usr/local/bin
$ which python
/Users/ericmjl/anaconda/bin/python
$ source activate lektor
$ echo $PATH
/Users/ericmjl/anaconda/envs/lektor/bin:/Users/ericmjl/anaconda/bin:/usr/bin:/bin:/usr/local/bin
$ which python
/Users/ericmjl/anaconda/envs/lektor/bin/python
Con la tecnología de

Fíjate en cómo la terminal ahora elige con preferencia el Python del entorno lektor, que tiene mayor prioridad.

Si has llegado hasta aquí, habrás visto que hay unos cuantos conceptos importantes. Resumamos:

• PATH es una variable de entorno almacenada como una cadena de texto plano que usa el intérprete bash para saber dónde encontrar programas ejecutables.
• PATH está delimitada por dos puntos; los directorios con mayor prioridad están a la izquierda y los de menor prioridad a la derecha.
• Puedes modificar PATH anteponiendo o añadiendo directorios a la variable. Puede hacerse de forma temporal en una sesión de bash ejecutando el comando export en la línea de comandos, o de forma persistente entre sesiones añadiendo una línea export en tu .bashrc o .bash_profile.

Otras variables de entorno de interés

¿Qué otras variables de entorno puede encontrarse un data scientist? Aquí tienes algunas que podrías ver y que quizá tengas que ajustar, especialmente si tu equipo de sistemas está de vacaciones (o tarda en responder).

Para el uso general, te interesará saber dónde está tu carpeta HOME: en Linux suele ser /home/username, y en macOS, /Users/username. Puedes ver qué vale HOME con:

$ echo $HOME
/Users/ericmjl
Con la tecnología de

Si usas Python, la variable PYTHONPATH puede ser útil. La usa el intérprete de Python y especifica dónde buscar módulos/paquetes de Python.

Si trabajas con librerías de C++, conocer tu variable de entorno LD_LIBRARY_PATH va a ser importante. No domino lo suficiente este tema como para explicarlo con detalle, así que te remito a este sitio web para más información sobre buenas prácticas con LD_LIBRARY_PATH.

Si trabajas con Spark, te interesará la variable PYSPARK_PYTHON. Básicamente le dice a Spark qué Python usar tanto para el driver como para los workers; también puedes establecer PYSPARK_DRIVER_PYTHON de forma separada de PYSPARK_PYTHON, si lo necesitas.

Trucos con tus variables de entorno

¡Aquí viene lo divertido! Sigue leyendo para ver algunas cosas que puedes hacer "hackeando" tus variables de entorno.

Truco 1: habilitar el acceso a PyPy. De vez en cuando sigo la evolución de PyPy, pero como aún no es el intérprete de Python por defecto y no se puede conda install-ar, lo tengo en su propio directorio $HOME/pypy/bin. Para poder usar el intérprete de PyPy, tengo que asegurarme de que mi /path/to/pypy esté presente en la variable PATH, pero con menor prioridad que mi intérprete CPython habitual.

Truco 2: habilitar el acceso a otros intérpretes/compiladores. Es análogo a PyPy. En una ocasión probé el intérprete JIT de Lua para usar Torch en deep learning, y tuve que añadir su ruta en mi .bashrc.

Truco 3: instalar paquetes de Python en tu directorio personal. En sistemas Linux compartidos que usan el sistema de modules en lugar de entornos de conda, puede que el modulefile que cargas esté configurado con un entorno virtual que no tienes permisos para modificar. Si necesitas instalar un paquete, quizá te convenga hacer pip install --user my_pkg_name. Esto lo instalará en $HOME/.local/lib/python-[version]/site-packages/. En este caso, es importante que tu PYTHONPATH incluya $HOME/.local/lib/python-[version]/site-packages con suficiente prioridad.

Truco 4: depurar cuando algo falla. Si aparece un error o un comportamiento inesperado —por ejemplo, que no se encuentre correctamente el intérprete de Python tras cargar todos tus módulos de Linux—, una forma de depurar es establecer temporalmente tu variable PATH con unos "valores por defecto" sensatos y hacer source de ellos, "reiniciando" efectivamente tu PATH, para luego anteponer/añadir rutas manualmente mientras depuras.

Para ello, coloca las siguientes líneas en un archivo llamado .path_default en tu directorio personal:

export PATH=""  # reinicia PATH a una cadena vacía.
export PATH=/usr/bin:/bin:/usr/local/bin:$PATH  # valor por defecto sensato; personaliza si es necesario.
Con la tecnología de

Cuando algo falle, puedes restablecer tu variable PATH usando el comando "source":

$ echo $PATH
/some/complicated/path:/more/complicated/paths:/really/complicated/paths
$ source ~/.path_default
$ echo $PATH
/usr/bin:/bin:/usr/local/bin
Con la tecnología de

Nota: también puedes ejecutar exactamente los mismos comandos directamente en tu sesión de bash; la interactividad puede ser útil.

Conclusión

Espero que te haya gustado el artículo y que te dé, ejem, una buena ruta a seguir cuando te cruces con estas variables de entorno.