Instalación de la versión de desarrollo de scikit-learn¶

Esta sección presenta cómo instalar la rama principal de scikit-learn. Esto se puede hacer ya sea instalando una compilación nocturna o compilando desde el código fuente.

Instalación de compilaciones nocturnas¶

Los servidores de integración continua del proyecto scikit-learn compilan, prueban y suben paquetes wheel para la versión más reciente de Python cada noche.

Instalar una compilación nocturna es la forma más rápida de:

probar una nueva característica que será enviada en la próxima versión (es decir, una característica de una solicitud de pull que fue recientemente fusionada con la rama principal);
comprobar si un error detectado ha sido corregido desde la última versión.

pip install --pre --extra-index https://pypi.anaconda.org/scipy-wheels-nightly/simple scikit-learn

Compilando desde la fuente¶

Es necesario compilar desde el código fuente para trabajar en una contribución (corrección de errores, nueva función, mejora del código o de la documentación).

Usa Git para revisar la última fuente del repositorio scikit-learn en Github.:
```
git clone git://github.com/scikit-learn/scikit-learn.git  # add --depth 1 if your connection is slow
cd scikit-learn
```
Si planeas enviar una solicitud de pull, deberías clonar desde su bifurcación.
Instala un compilador con soporte OpenMP para su plataforma. Ver instrucciones para Windows, macOS, Linux y FreeBSD.
Opcional (pero recomendado): crear y activar un entorno virtual dedicado o conda.

Instala Cython y compila el proyecto con pip en Modo editable:

pip install cython
pip install --verbose --no-build-isolation --editable .

Comprueba que el scikit-learn instalado tiene un número de versión que termina con .dev0:
```
python -c "import sklearn; sklearn.show_versions()"
```
Por favor, consulta Guía del Desarrollador y Alias e indicadores útiles de pytest para ejecutar las pruebas en el módulo de tu elección.

Nota

Tendrás que ejecutar el comando pip install --no-build-isolation --editable . cada vez que se actualice el código fuente de un archivo Cython (que termine en .pyx o .pxd). Utilice la bandera --no-build-isolation para evitar compilar todo el proyecto cada vez, sólo los archivos que ha modificado.

Dependencias¶

Dependencias de ejecución¶

Scikit-learn requiere las siguientes dependencias tanto en tiempo de compilación como en tiempo de ejecución:

Python (>= 3.6),
NumPy (>= 1.13.3),
SciPy (>= 0.19.1),
Joblib (>= 0.11),
threadpoolctl (>= 2.0.0).

Esas dependencias son instaladas automáticamente por pip si faltaban al compilar scikit-learn desde el origen.

Nota

Para ejecutarse en PyPy, PyPy3-v5.10+, se requieren Numpy 1.14.0+, y scipy 1.1.0+. Para PyPy, solo se aplican las instrucciones de instalación con pip.

Dependencias de compilación¶

La compilación de Scikit-learn también requiere:

Cython >= 0.28.5
Un compilador C/C++ y una biblioteca de tiempo de ejecución OpenMP correspondiente. Consulta las instrucciones específicas del sistema de la plataforma para obtener más detalles.

Nota

Si OpenMP no es compatible con el compilador, la compilación se hará con las funcionalidades de OpenMP desactivadas. Esto no es recomendable ya que forzará a algunos estimadores a ejecutarse en modo secuencial en lugar de aprovechar el paralelismo basado en hilos. Establecer la variable de entorno SKLEARN_FAIL_NO_OPENMP (antes de la cythonización) forzará la compilación a fallar si OpenMP no es compatible.

Desde la versión 0.21, scikit-learn detecta y utiliza automáticamente la biblioteca de álgebra lineal utilizada por SciPy en tiempo de ejecución. Por lo tanto, Scikit-learn no depende de implementaciones BLAS/LAPACK como OpenBlas, Atlas, Blis o MKL.

Dependencias de prueba¶

Las pruebas en ejecución requieren:

pytest >= 5.0.1

Algunas pruebas también requieren pandas.

Compilar una versión específica de una etiqueta¶

Si desea compilar una versión estable, puede git checkout <VERSION> para obtener el código para esa versión en particular, o descargar un archivo zip de la versión desde github.

Modo editable¶

Si ejecutas la versión de desarrollo, es engorroso reinstalar el paquete cada vez que actualices las fuentes. Por lo tanto, se recomienda que instales con el ``pip install –no-build-isolation –editable . ` , que te permite editar el código en su lugar. Esto compila la extensión en su lugar y crea un enlace al directorio de desarrollo (ver los documentos pip).

Esto es fundamentalmente similar a usar el comando python setup.py develop (ver el archivo setuptool docs). Sin embargo, se prefiere usar pip.

En sistemas semejantes a Unix, puede escribir equivalentemente make in desde la carpeta de nivel superior. Echa un vistazo a Makefile para utilidades adicionales.

Instrucciones específicas de la plataforma¶

Aquí están las instrucciones para instalar un compilador C/C++ en funcionamiento con soporte OpenMP para compilar extensiones scikit-learn de Cython para cada plataforma soportada.

Windows¶

Primero, instala Herramientas de compilación para Visual Studio 2019.

Advertencia

NO necesitas instalar Visual Studio 2019. Sólo necesitas las «Herramientas de compilación para Visual Studio 2019», en «Todas las descargas» -> «Herramientas para Visual Studio 2019».

En segundo lugar, averigua si estás ejecutando Python de 64 o 32 bits. El comando de compilación depende de la arquitectura del intérprete de Python. Puedes comprobar la arquitectura ejecutando lo siguiente en la consola cmd o powershell:

python -c "import struct; print(struct.calcsize('P') * 8)"

Para Python de 64 bits, configura el entorno de compilación ejecutando los siguientes comandos en cmd o un Anaconda Prompt (si utilizas Anaconda):

$ SET DISTUTILS_USE_SDK=1
$ "C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Auxiliary\Build\vcvarsall.bat" x64

Reemplaza x64 por x86 para compilar por Python de 32-bits.

Por favor, ten en cuenta que la ruta anterior puede ser diferente de usuario a usuario. El objetivo es apuntar al archivo «vcvarsall.bat» que establecerá las variables de entorno necesarias en la línea de comandos actual.

Finalmente, compila scikit-learn a partir de esta línea de comandos:

pip install --verbose --no-build-isolation --editable .

macOS¶

El compilador C predeterminado en macOS, Apple clang (alias confusamente como /usr/bin/gcc), no soporta directamente OpenMP. Presentamos dos alternativas para habilitar el soporte OpenMP:

instala conda-forge::compilers con conda;
o instala libomp con Homebrew para extender el compilador predeterminado de Apple clang.

Para el hardware Apple Silicon M1, sólo se sabe que el método conda-forge siguiente funciona en el momento de la escritura (enero de 2021). Puedes instalar la distribución macos/arm64 de conda usando el miniforge installer

compiladores macOS de conda-forge¶

Si utilizas el gestor de paquetes conda (versión >= 4.7), puede instalar el meta-paquete compilers desde el canal conda-forge, el cual proporciona compiladores C/C++ habilitados para OpenMP basados en la toolchain llvm.

Primero instale las herramientas de línea de comandos de macOS:

xcode-select --install

Se recomienda utilizar un conda environment dedicado para compilar scikit-learn desde el código fuente:

conda create -n sklearn-dev -c conda-forge python numpy scipy cython \
    joblib threadpoolctl pytest compilers llvm-openmp
conda activate sklearn-dev
make clean
pip install --verbose --no-build-isolation --editable .

Nota

Si obtienes algún mensaje de error de dependencia en conflicto, intenta comentar cualquier configuración de conda personalizada en el $HOME/.condarc. En particular, se sabe que la directiva channel_priority: strict causa problemas en esta configuración.

Puedes comprobar que los compiladores personalizados están correctamente instalados desde conda forge usando el siguiente comando:

conda list

que debe incluir compilers y llvm-openmp.

El meta-paquete de los compiladores establecerá automáticamente variables de entorno personalizadas:

echo $CC
echo $CXX
echo $CFLAGS
echo $CXXFLAGS
echo $LDFLAGS

Apuntan a archivos y carpetas de tu entorno conda sklearn-dev (en particular en las subcarpetas bin/, include/ y lib/). Por ejemplo -L/path/to/conda/envs/sklearn-dev/lib debería aparecer en LDFLAGS.

En el registro, deberías ver la extensión compilada que se está construyendo con los compiladores clang y clang++ instalados por conda con la bandera de línea de comando -fopenmp.

compiladores macOS de Homebrew¶

Otra solución es habilitar el soporte OpenMP para el compilador clang que se envía por defecto en macOS.

Primero instale las herramientas de línea de comandos de macOS:

xcode-select --install

Instalar el gestor de paquetes Homebrew para macOS.

Instalar la biblioteca OpenMP de LLVM:

brew install libomp

Establece las siguientes variables de entorno:

export CC=/usr/bin/clang
export CXX=/usr/bin/clang++
export CPPFLAGS="$CPPFLAGS -Xpreprocessor -fopenmp"
export CFLAGS="$CFLAGS -I/usr/local/opt/libomp/include"
export CXXFLAGS="$CXXFLAGS -I/usr/local/opt/libomp/include"
export LDFLAGS="$LDFLAGS -Wl,-rpath,/usr/local/opt/libomp/lib -L/usr/local/opt/libomp/lib -lomp"

Finalmente, compila scikit-learn en modo verbose (para comprobar la presencia de la bandera -fopenmp en los comandos del compilador):

make clean
pip install --verbose --no-build-isolation --editable .

Linux¶

Compiladores Linux del sistema¶

Instalar scikit-learn desde el código fuente sin usar conda requiere que haya instalado las cabeceras de desarrollo de Python y un compilador C/C++ de trabajo con soporte OpenMP (normalmente la herramienta GCC).

Instala dependencias de compilación para sistemas operativos basados en Debian, por ejemplo, Ubuntu:

sudo apt-get install build-essential python3-dev python3-pip

luego procede como de costumbre:

pip3 install cython
pip3 install --verbose --editable .

Cython y las wheels precompiladas para las dependencias de tiempo de ejecución (numpy, scipy y joblib) deberían instalarse automáticamente en $HOME/.local/lib/pythonX.Y/site-packages. También puedes ejecutar los comandos anteriores desde un virtualenv o un conda environment para obtener el aislamiento completo de los paquetes Python instalados a través del empaquetador del sistema. Cuando se utiliza un entorno aislado, pip3 debe ser reemplazado por pip en los comandos anteriores.

Cuando las wheels precompiladas de las dependencias de tiempo de ejecución no están disponibles para tu arquitectura (por ejemplo, ARM), puedes instalar las versiones del sistema:

sudo apt-get install cython3 python3-numpy python3-scipy

En Red Hat y clones (por ejemplo, CentOS), instala las dependencias usando:

sudo yum -y install gcc gcc-c++ python3-devel numpy scipy

Compiladores Linux de conda-forge¶

Alternativamente, instala una versión reciente de la toolchain del compilador de C GNU (GCC) en la carpeta de usuario usando conda:

conda create -n sklearn-dev -c conda-forge python numpy scipy cython \
    joblib threadpoolctl pytest compilers
conda activate sklearn-dev
pip install --verbose --no-build-isolation --editable .

FreeBSD¶

El compilador clang incluido en los sistemas base FreeBSD 12.0 y 11.2 no incluye soporte OpenMP. Necesitas instalar la librería openmp desde paquetes (o puertos):

sudo pkg install openmp

Esto instalará archivos de cabecera en /usr/local/include y libs en /usr/local/lib. Dado que estos directorios no son buscados por defecto, puedes establecer las variables de entorno a estas ubicaciones:

export CFLAGS="$CFLAGS -I/usr/local/include"
export CXXFLAGS="$CXXFLAGS -I/usr/local/include"
export LDFLAGS="$LDFLAGS -Wl,-rpath,/usr/local/lib -L/usr/local/lib -lomp"

Finalmente, compila el paquete usando el comando estándar:

pip install --verbose --no-build-isolation --editable .

Para las próximas versiones de FreeBSD 12.1 y 11.3, OpenMP será incluido en el sistema base y estos pasos no serán necesarios.

Compiladores alternativos¶

El comando:

pip install --verbose --editable .

compilará scikit-learn usando el compilador predeterminado de C/C++. Si deseas construir scikit-learn con otro compilador manejado por distutils o por numpy.distutils, utiliza el siguiente comando:

python setup.py build_ext --compiler=<compiler> -i build_clib --compiler=<compiler>

Para ver la lista de compiladores disponibles ejecutar:

python setup.py build_ext --help-compiler

Si tu compilador no aparece aquí, puedes especificarlo a través de las variables de entorno CC y LDSHARED (no funciona en Windows):

CC=<compiler> LDSHARED="<compiler> -shared" python setup.py build_ext -i

Compilar con Intel C Compiler (ICC) usando oneAPI en Linux¶

Intel proporciona acceso a todos sus kits de herramientas y paquetes oneAPI a través de un repositorio público de APT. En primer lugar, es necesario obtener e instalar la clave pública de este repositorio:

wget https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB
sudo apt-key add GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB
rm GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB

Luego, añade el repositorio oneAPI a tus repositorios APT:

sudo add-apt-repository "deb https://apt.repos.intel.com/oneapi all main"
sudo apt-get update

Instala ICC, empaquetado con el nombre intel-oneapi-icc:

sudo apt-get install intel-oneapi-icc

Antes de usar ICC, necesitas configurar las variables de entorno:

source /opt/intel/oneapi/setvars.sh

Finalmente, puedes compilar scikit-learn. Por ejemplo en Linux x86_64:

python setup.py build_ext --compiler=intelem -i build_clib --compiler=intelem

Compilaciones paralelas¶

Es posible construir extensiones compiladas de scikit-learn en paralelo mediante la configuración y la variable de entorno como sigue, antes de llamar a pip install o comandos python setup.py build_ext:

export SKLEARN_BUILD_PARALLEL=3
pip install --verbose --no-build-isolation --editable .

En una máquina con 2 núcleos de CPU, puede ser beneficioso utilizar un nivel de paralelismo de 3 para solapar las tareas ligadas a la E/S (lectura y escritura de archivos en el disco) con las tareas ligadas a la CPU (compilación real).