Cog : conteneurs pour l'apprentissage automatique

Cog est un outil open source qui vous permet de regrouper des modèles d'apprentissage automatique dans un conteneur standard prêt pour la production.

Vous pouvez déployer votre modèle packagé sur votre propre infrastructure ou pour le répliquer.

Points forts

Conteneurs Docker sans douleur. Écrire votre propre Dockerfile peut être un processus déroutant. Avec Cog, vous définissez votre environnement avec un simple fichier de configuration et il génère une image Docker avec toutes les meilleures pratiques : images de base Nvidia, mise en cache efficace des dépendances, installation de versions Python spécifiques, valeurs par défaut des variables d'environnement raisonnables, etc.
Fini l'enfer CUDA. Cog sait quels combos CUDA/cuDNN/PyTorch/Tensorflow/Python sont compatibles et tout configurera correctement pour vous.
Définissez les entrées et sorties de votre modèle avec Python standard. Ensuite, Cog génère un schéma OpenAPI et valide les entrées et sorties avec Pydantic.
Serveur de prédiction HTTP automatique : Les types de votre modèle sont utilisés pour générer dynamiquement une API HTTP RESTful à l'aide de FastAPI.
Travailleur de file d'attente automatique. Les modèles d'apprentissage profond à long terme ou le traitement par lots sont mieux architecturés avec une file d'attente. Les modèles Cog le font immédiatement. Redis est actuellement pris en charge, et d'autres sont en préparation.
Stockage en nuage. Les fichiers peuvent être lus et écrits directement sur Amazon S3 et Google Cloud Storage. (À venir.)
Prêt pour la production. Déployez votre modèle partout où les images Docker sont exécutées. Votre propre infrastructure, ou Répliquer.

Comment ça marche

Définissez l'environnement Docker dans lequel votre modèle s'exécute avec cog.yaml :

 build : gpu : vrai system_packages :
    - "libgl1-mesa-glx"
    - "libglib2.0-0" version_python : "3.12" python_packages :
    - "torch==2.3"predict : "predict.py:Predictor"

Définissez la manière dont les prédictions sont exécutées sur votre modèle avec predict.py :

 from cog import BasePredictor, Input, Pathimport torchclass Predictor(BasePredictor): def setup(self): """Charger le modèle en mémoire pour rendre l'exécution de plusieurs prédictions efficace""" self.model = torch.load("./weights. pth") # Les arguments et les types que le modèle prend en entrée def predict(self, image: Path = Input(description="Grayscale input image")
    ) -> Chemin : """Exécuter une seule prédiction sur le modèle"""process_image = preprocess(image) output = self.model(processed_image) return postprocess(output)

Vous pouvez désormais exécuter des prédictions sur ce modèle :

 $ cog predict -i [email protected]> Création d'une image Docker...--> Exécution de la prédiction...--> Sortie écrite dans output.jpg

Ou créez une image Docker pour le déploiement :

 $ cog build -t my-colorization-model--> Création d'une image Docker...--> Construit mon-model-colorization:latest$ docker run -d -p 5000:5000 --gpus all my-colorization-model$ curl http://localhost:5000/predictions -X POST  -H 'Content-Type : application/json'  -d '{"input": {"image": "https://.../input. jpg"}}'

Pourquoi construisons-nous cela ?

Il est très difficile pour les chercheurs de mettre en production des modèles d’apprentissage automatique.

Une partie de la solution est Docker, mais il est tellement complexe de la faire fonctionner : fichiers Docker, pré-/post-traitement, serveurs Flask, versions CUDA. Le plus souvent, le chercheur doit s’asseoir avec un ingénieur pour déployer cette foutue chose.

Andreas et Ben ont créé Cog. Andreas travaillait chez Spotify, où il a créé des outils pour créer et déployer des modèles ML avec Docker. Ben a travaillé chez Docker, où il a créé Docker Compose.

Nous avons réalisé qu'en plus de Spotify, d'autres entreprises utilisaient également Docker pour créer et déployer des modèles d'apprentissage automatique. Uber et d'autres ont construit des systèmes similaires. Nous créons donc une version open source pour que d'autres personnes puissent également le faire.

Contactez-nous si vous souhaitez l'utiliser ou si vous souhaitez collaborer avec nous. Nous sommes sur Discord ou envoyez-nous un e-mail à [email protected].

Conditions préalables

macOS, Linux ou Windows 11 . Cog fonctionne sur macOS, Linux et Windows 11 avec WSL 2
Docker . Cog utilise Docker pour créer un conteneur pour votre modèle. Vous devrez installer Docker avant de pouvoir exécuter Cog. Si vous installez Docker Engine au lieu de Docker Desktop, vous devrez également installer Buildx.

Installer

Si vous utilisez macOS, vous pouvez installer Cog à l'aide de Homebrew :

 brasser installer un rouage

Vous pouvez également télécharger et installer la dernière version à l'aide de notre script d'installation :

 # fish shellsh (curl -fsSL https://cog.run/install.sh | psub)# bash, zsh et autres shellssh <(curl -fsSL https://cog.run/install.sh)# télécharger avec wget et exécutez dans une commande distinctewget -qO- https://cog.run/install.sh
sh ./install.sh

Vous pouvez installer manuellement la dernière version de Cog directement depuis GitHub en exécutant les commandes suivantes dans un terminal :

 sudo curl -o /usr/local/bin/cog -L "https://github.com/replicate/cog/releases/latest/download/cog_$(uname -s)_$(uname -m)" sudo chmod +x /usr/local/bin/cog

Alternativement, vous pouvez créer Cog à partir des sources et l'installer avec ces commandes :

 makesudo make install

Ou si vous êtes sur Docker :

RUN sh -c "INSTALL_DIR="/usr/local/bin" SUDO="" $(curl -fsSL https://cog.run/install.sh)"

Mise à niveau

Si vous utilisez macOS et que vous avez déjà installé Cog avec Homebrew, exécutez ce qui suit :

 rouage de mise à niveau de brassage

Sinon, vous pouvez effectuer une mise à niveau vers la dernière version en exécutant les mêmes commandes que celles utilisées pour l'installer.

Prochaines étapes

Commencez avec un exemple de modèle
Commencez avec votre propre modèle
Utiliser Cog avec des blocs-notes
Utiliser Cog avec Windows 11
Jetez un œil à quelques exemples d’utilisation de Cog
Déployer des modèles avec Cog
Référence cog.yaml pour apprendre à définir l'environnement de votre modèle
Référence de l'interface de prédiction pour savoir comment fonctionne l'interface Predictor
Référence de l'interface de formation pour apprendre à ajouter une API de réglage fin à votre modèle
Référence de l'API HTTP pour savoir comment utiliser l'API HTTP servie par les modèles