Setting up Libtorch in a Simple Docker Environment

Este articulo cobra como hacer un ambiente reutilizable de Docker para usar en todos tus proyectos de Libtorch.

Unas condiciones previas:

Necesitás Docker instalado. (Si estás usando esta guía para trabajo, averiqua que tenés una licencia o usa algo como Lima o Colima)
Familiaridad con Bash. Necesitás saber lo básico de usar un terminal y los comandos para navegar.

Al Primero, Hacemos Un Ambiente Virtual

No importa si usas Python, C++ o cualquier otra idioma de programación, tener un ambiente virtual siempre te va a ayudar. Quizás compras una computadora nueva o abras un proyecto viejo después de un rato, y de repente no funciona por un problema con un librario, o cualquiera cosa. En cualquiera caso, es mejor tener un ambiente virtual que no.

Mi preferencia personal es Docker porque se puede controlar el OS y el orden de los comandos como cuando instalas a modulos. También, es compatible con servicios como Kubernetes y AWS, pero no nos preocupamos con eso en este momento.

The Dockerfile

Ok, empezamos con la guía. Al primero, hacemos un Dockerfile. Abrá el directorio y hace un archivo que se llama Dockerfile. Notá que no necesita una extensión como ".txt" o algo así. Ahora podés copiar el texto debajo y ponerlo en tu Dockerfile. Dockerfile. Note that it does not need an extension like .txt or anything. Then inside that file feel free to copy this.

FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04

RUN apt update && apt -y install cmake

WORKDIR /code

FROM dice a Docker que querés usar el Docker imágen Nvidia/Cuda Ubuntu 22.04 (que probablemente será descargado cuando haces el ambiente). Es un imágen official hecho por Nvidia.
WORKDIR dice que Docker deber hacer el directorio primario /codeCuando usas ssh para entrar al contenedor (el ambiente) después, estarás en el directorio /code .
RUN se ejecuta unos comandos durante el proceso de construcción de Docker. En este caso, nos estamos ejecutando apt update y después instalando cmake que necesitás para hacer tu proyecto de Libtorch.

The DoCKER-COMPOse.yaml File

Para acompañar el Dockerfile, también necesitás un archivo docker-compose.yaml. Dos archivos parace mucho para un ambiente, pero Docker Compose hace el proceso mucho mas simple. Si no, tendrías que añadir tags al comando de docker para especificar volumes y otras cosa y eso hace que los comandos se vuelvan muy grandes y complicado. Con Docker Compose, todos las configuraciones para hacer el ambiente están en un archivo que podés poner un tu git repo.

El archivo es así:

version: "3.9"
services:
  app:
    build: .
    tty: true
    volumes:
      - .:/code

La versión refiere a la versión de docker-compose que usás. 3.9 es perfecto en casi todos los casos.
Siempre necesitás una sección de services, pero el parte notar es app adentro de servicesPodés usar cualquier nombre que querés en lugar de appcomo model o el nombre de tu proyecto. Mejor que elegís algo fácil así que cuando conectás vas a tener que usar este nombre en el comando.
build dice al Docker el directorio para usar para construir el ambiente.
tty hace que tu contenedor sigue funcionando después de que terminan todos los procesos. Si no lo pones, el contenedor termina después del proceso de construcción.
volumes dice al contenedor de Docker cuales directorios debe añadir al contenedor como volumes. Un volume es un directorio que está accessible por el contenedor y también por tu computadora afuera del ambiente. Cualquier cambia que haces a un archivo en el volume será reflejado en tu computadora también.

Después de hacer los dos archivos, podés hacer este comando en el directorio de tu proyecto para empecer el contenedor (el ambiente virtual).

docker-compose up -d

El -d notifica Docker crear el contenedor en el fondo. Si dejas de añadirlo, el comando seguirá mostrando el log en el terminal y no vas a poder hacer comandos nuevos hasta que termine el contenedor.

Después del comando de crear, entra el comando de entrar al contenedor:

docker-compose exec app bash

¿Ves como usé app aqui? Es porque usé el nombre app en mi archivo docker-compose.yaml. Si este comando no funciona, averigua que el contenedor esta corriendo por el comando docker container ls en el terminal. Si funciona debés ver un contenedor con un parte del nombre incluyendo el nombre del proyecto.

Si funcionaba, ahora debés estar adentro del contenedor, en que ejecutamos el resto de los comandos desde este punto en la guía. Si necesitas salir del contenedor, podés usar el comando exit y poner Enter.

Instalando Libtorch y Preparando El Archivo Cmake

Instalando Libtorch

Ahora que tenemos un contenedor de Docker, va al sitio de PyTorch y descarga el zip de Libtorch. Recordáte que gcc es un imágen Linux, así que para usar Libtorch adentro del contenedor, necesitás la versión Linux.

Elegí la versión cxx11 ABI. Moválo al proyecto y haz unzip. Yo prefiero ponerlo adentro de un directorio que se llama include.

Preparando el archivo CMake

En este momento debés tener:

Un directorio include que contiene libtorch .
Un Dockerfile
Un archivo docker-compose.yaml

Después vamos a hacer un archivo CMakeLists.txt. Este archivo está basado en la guía oficial con unas diferencias pequeñas. Podés copiar el contendio debajo en tu propio archivo CMakeLists.txt:

cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
project(demo)

list(APPEND CMAKE_PREFIX_PATH "${CMAKE_SOURCE_DIR}/include/libtorch")
find_package(Torch REQUIRED)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")

add_executable(demo src/demo.cpp)
target_link_libraries(demo "${TORCH_LIBRARIES}")
set_property(TARGET demo PROPERTY CXX_STANDARD 14)

Acá, estoy llamando mi proyecto demo pero podés usar cualquier nombre que querés. Recordáte cambiar todos las otras lineas que contiene demo a cualquier nombre que elegís.

La diferencia más importante entre mi versión y la de la guía oficial es la linea list(APPEND CMAKE_PREFIX_PATH "${CMAKE_SOURCE_DIR}/include/libtorch") . En la guía oficial te dicen añadir -DCMAKE_PREFIX_PATH al comando cmake, pero yo creo que es un poco difícil recordar y por eso lo pongo en el archivo en lugar del comando.

Haciendo Tu Proyecto

Mi archivo primario de código es demo.cpp que ahora tenemos que hacer. Al primero, hacemos un directorio nuevo con nombre src y adentro ponemos el archivo demo.cpp . Ves en "add_executable" que hemos escribido "src/demo.cpp".

Para empezar, usa el código de la guía official en tu archivo demo.cpp.

#include <torch/torch.h>
#include <iostream>

int main() {
  torch::Tensor tensor = torch::rand({2, 3});
  std::cout << tensor << std::endl;
}

Haciendo Build Y Ejecutando El Proyecto

Ahora tenemos un ambiente de Docker, un archivo demo, y un archivo CMakeLists.txt que describe como cmake debe hacer el build del proyecto. Al final tenemos que hacer build. Esto es el primer comando:

cmake -S . -B build

Este comando configura cmake y hace un directorio build en que el proyecto estará hecho.

Después, ejecutamos el comando build:

cmake --build build

Este comando ejecuta el proceso actual para hacer el build y hace el programa completo adentro de del directorio build . Necesitás hacer este comando cada vez que hacés cambios al código..

Al fin, el proyecto está hecho! Ahora podemos ejecutarlo. Usá el comando debajo para ejecutar el programa:

build/demo

Si usaste el código demo, debés ver un tensor imprimido en el terminal, y con esto concluimos este articulo.

Conclusión

Después de hacer todo esto, podés usar este ambiente docker y archivo CMakeLists.txt en otros proyectos de Libtorch también! Si empezás haciendo proyectos con más archivos, es posible que vas a necesitar más que un CMakeLists.txt o que vas a tener que añadir al CMakeLists.txt que hicimos, pero esto es algo de que podemos hablar en el futuro. Por ahora, probá cambiar unas cosas del código y ve como funciona, o quizás podés leer mi articulo "Getting Started" si querés.

Si tenés preguntas o pedidos por contendio, por favor escribáme un comento!

Un Ambiente Docker Simple Para Libtorch