Modal est une plateforme cloud Python sans serveur pour les charges de travail IA/ML. Vous pouvez exécuter n'importe quel code Python sur un GPU cloud en ajoutant simplement un décorateur sur une fonction. Il n'y a pas de coût d'inactivité par seconde, 100 A 3,72 $/heure. Prenant en charge la , l'inférence par lots et les tâches planifiées, il s'agit du moyen le plus rapide pour les développeurs d'utiliser le cloud GPU.

Modal — Plateforme cloud AI/ML sans serveur native Python

Paramètres et statistiques de base de Modal

Modal est une plateforme cloud Python sans serveur pour les charges de travail IA/ML. Il appartient au type productivité/application côté métier (la forme de livraison principale est une plate-forme de développement cloud de bout en bout) et possède également l'attribut grand modèle/infrastructure API de base (fournissant des ressources informatiques GPU). Les développeurs peuvent exécuter n'importe quel code sur le GPU cloud en ajoutant des décorateurs aux fonctions Python, et il n'y a pas de coût d'inactivité basé sur la facturation à la seconde.

Projets	Informations publiques
Positionnement officiel	Faites en sorte que le cloud computing ressemble à de la programmation Python locale
Modèle de programmation	Décorateurs Python (@app.function, @app.cls, @web_endpoint)
Modèle GPU	T4 (0,76 $/heure), A10G (1,10 $/heure), A100 40 Go/80 Go (3,72 $/heure), H100 (~ 5,96 $/heure)
Granularité comptable minimale	100 millisecondes
Heure de démarrage à froid	Environ 2 à 5 secondes (après l'optimisation v0.70+), prend en charge le préchauffage des conteneurs (Keep Warm)
Nombre maximum de conteneurs parallèles	Des milliers de niveaux (l'opération .map() démarre en quelques secondes)
Stockage persistant	Volume modal (0,10 $/Go/mois), Modal Dict (stockage KV)
Limite de crédit gratuite	30 $ par mois pour les nouveaux utilisateurs Calculer la limite de crédit
Fondateurs	Erik Bernhardsson (ancien auteur principal de l'ingénierie des données Spotify, Luigi), Akshat Bubna
Établi	2021
Siège social	New York, États-Unis
Dernière version	modal v0.70+ conteneur et optimisation de la concurrence (~2024-12)

Différence fondamentale dans les modèles de programmation : Modal n'est pas une autre console de fournisseur cloud, mais une plate-forme déclarative qui intègre les définitions d'infrastructure dans la syntaxe Python. Les développeurs n'ont pas besoin de comprendre Kubernetes, Docker Compose, les politiques IAM ou les configurations d'équilibrage de charge. Il leur suffit d'ajouter le décorateur @app.function(gpu="A100") aux fonctions Python ordinaires, et Modal gère automatiquement l'orchestration des conteneurs, l'allocation GPU, l'expansion et la contraction, ainsi que la collecte de journaux. Ce modèle « code as infrastructure » permet aux équipes d'IA de déployer des charges de travail GPU cloud comme si elles écrivaient des scripts locaux pour la première fois.

Compromis d'ingénierie pour le démarrage à froid : le temps de démarrage à froid de Modal de 2 à 5 secondes est moyen à supérieur à la moyenne parmi les plates-formes GPU sans serveur. La plateforme utilise le mécanisme de préchauffage des conteneurs (Keep Warm), qui permet aux utilisateurs de réserver un certain nombre d'instances de conteneurs inactives, afin de réduire la latence de démarrage à chaud à quelques millisecondes. Cependant, pour les scénarios d'inférence en temps réel qui nécessitent une réponse inférieure à la seconde, la latence du démarrage à froid reste un goulot d'étranglement qui ne peut être ignoré et doit être résolu avec une stratégie de préchauffage ou en passant à une instance GPU dédiée.

Échelle d'adoption liée à la production : selon des informations publiques, Modal a servi des milliers d'entreprises d'IA et d'équipes de développeurs, couvrant des scénarios à différentes échelles, depuis les expériences personnelles jusqu'à l'inférence par lots au niveau de la production. La réputation technique d'Erik Bernhardsson au sein de la communauté de l'ingénierie des données (auteur du framework de workflow Luigi) a suscité une grande confiance dans la plateforme dans le cadre de scénarios de charge de travail d'IA à forte intensité de données.

Utilisateurs et reconnaissance du marché de Modal

La reconnaissance de Modal sur le marché vient principalement du bouche-à-oreille répandu dans la communauté technique et de son adoption approfondie dans des scénarios spécifiques, plutôt que des efforts de marketing à grande échelle ou des données sur les recettes publiques (ces dernières ne sont pas officiellement divulguées).

Popularité de la communauté des développeurs : Modal est fréquemment mentionné dans les blogs Hacker News, de la communauté Python et d'ingénierie ML, et la conception emblématique de l'API du décorateur Python est considérée comme "le moyen le plus intuitif d'utiliser le cloud GPU pour les développeurs". Plusieurs blogs technologiques le classent comme l’une des meilleures expériences de déploiement d’IA de 2024-2025. L'activité de son forum de discussion GitHub et la qualité des réponses aux problèmes sont exceptionnelles parmi les plateformes open source similaires.

Cas d'adoption par les entreprises : Modal a été utilisé par plusieurs sociétés d'IA et instituts de recherche bien connus pour produire une inférence contextuelle par lots, des pipelines de traitement de données et une servitisation de modèles. Les cas d'adoption accessibles au public se concentrent sur trois domaines : l'hébergement d'API LLM d'inférence par lots de vision par ordinateur et le calcul scientifique. Cependant, le responsable n'a pas divulgué une liste détaillée de clients ni de données sur les revenus, et le taux de pénétration du marché au niveau de l'entreprise manque d'indicateurs quantitatifs précis.

Positionnement de référence de l'industrie : Modal est nettement meilleur que les plateformes d'IA cloud traditionnelles telles que AWS SageMaker et GCP Vertex AI dans la dimension "expérience développeur", mais est plus faible que cette dernière en termes d'exhaustivité des fonctions d'entreprise (intégration VPC, certification de conformité, déploiement multi-régions). Il est plus proche de l'expérience « fonctionnelle » de Google Cloud Run, mais est profondément optimisé pour les charges de travail GPU. Dans le segment des GPU sans serveur, Modal est en concurrence directe avec Beam, Banana Dev, Replicate, etc., et s'est constitué un avantage différencié grâce à la simplicité de la syntaxe du décorateur et à la précision de la facturation à la seconde.

Avantage économique du modal

L'avantage en termes de coût de Modal ne vient pas de la remise absolue sur le prix unitaire du GPU, mais de l'effet de superposition de trois dimensions : Facturation à la seconde pour éliminer le gaspillage inactif, Mise à l'échelle automatique pour correspondre à la charge réelle et Aucun coût de main-d'œuvre d'exploitation et de maintenance.

Structure des coûts côté C/utilisateur individuel

Éléments de coût	modale	Cloud GPU traditionnel (horaire)	Épargne (Déduction)
Crédits gratuits	30$/mois (environ 8 heures A100 ou 39 heures T4)	Généralement pas de crédits gratuits	100% de réduction sur les frais d'entrée
Inférence par lots (10 000 fois × 15 secondes/heure, A100)	15,50 $ (en secondes : 0,001 $/seconde × 150 000 secondes)	74,40 $ (en heures : 3,72 $/heure × 20 heures)	Environ 79% d'économies
Expériences intermittentes (2 heures par jour A100, 60 heures par mois)	223,20 $ (facturé à la seconde)	223,20 $ (facturé à l'heure)	Plat (l'avantage disparaît en cas d'utilisation élevée)
Fonctionnement continu 7×24 (carte unique A100)	2 678,40 $/mois (par secondes)	2 678,40 $/mois (par heures)	Plat

Le scénario de valeur réelle de la facturation à la seconde : d'après la comparaison, il ressort de la comparaison que les avantages en termes de coûts de Modal sont concentrés dans les types de tâches avec un temps d'exécution court, une fréquence d'appel élevée et un degré élevé de parallélisme. En prenant comme exemple un pipeline d'inférence par lots typique - 100 000 appels, d'une durée moyenne de 12 secondes chacun, utilisant un GPU A100 - Modal coûte environ 1 200 $/mois (facturé à la seconde), tandis que le même nombre de calculs sur une plate-forme horaire coûterait 4 000 à 6 000 $/mois (car chaque heure complète est louée). La différence vient de l'écart d'utilisation entre « le temps de calcul réel et le temps réservé ».

Structure des coûts de la couche d'appel développeur/API

• Coûts explicites : GPU facturé à la seconde + CPU/mémoire facturé à l'heure + Frais de stockage de volume modal (0,10 $/Go/mois) + frais de trafic sortant du réseau.
• Économies cachées : pas besoin de maintenir un cluster Kubernetes (économie d'au moins 0,5 à 1 sur les coûts de main-d'œuvre DevOps) ; aucun prépaiement ou engagement d'utilisation n'est requis ; L'expansion et la contraction automatiques évitent le gaspillage de GPU inactifs.
• Coût caché : le temps d'attente supplémentaire causé par le démarrage à froid peut s'accumuler en heures d'attente invalide dans les tâches par lots à grande échelle ; dans les scénarios de charge élevée à long terme, le coût total par seconde est supérieur à celui des instances dédiées mensuelles.

Considérations relatives aux coûts au niveau de l'entreprise

L'entreprise envisage d'adopter le modèle de remise sur engagement d'utilisation, et les tarifs spécifiques doivent être confirmés par l'entreprise. Pour les clients plus importants ayant plus de 5 000 heures d'utilisation mensuelle du GPU, la facturation à la seconde de Modal n'est pas moins chère que les instances réservées dans les cloud traditionnels comme AWS sous une charge élevée et soutenue. Les entreprises doivent se concentrer sur trois comptes avant d'acheter :

• Données de base pour l'utilisation actuelle du GPU (l'avantage par seconde de Modal est considérablement réduit si l'utilisation dépasse 60 %) ;
• Si les économies sur les coûts de main-d'œuvre DevOps peuvent couvrir d'éventuelles primes de prix unitaires ;
• La valeur de l'expansion et de la contraction élastiques provoquées par la croissance de l'entreprise - Dans les scénarios où la demande fluctue violemment, l'expansion et la contraction automatiques de Modal évitent un grand nombre d'erreurs de planification de capacité.

Comparaison des prix avec des produits concurrents : en prenant l'exemple de l'A100 40 Go, RunPod coûte environ 2,49 $/heure sur une base horaire, mais le cycle de facturation minimum est horaire et il y a une consommation minimale ; AWS p4d.xlarge coûte 3,91 $/heure sur demande, et les instances réservées peuvent être réduites à 2,35 $/heure mais nécessitent un contrat de 1 à 3 ans. Le coût horaire de 3,72 $ de Modal n'est pas supérieur en termes de prix instantané, mais le coût effectif de la facturation à la seconde dans des scénarios de charge non pleine est généralement inférieur de 40 à 70 %.

Principales fonctions de Modal

La conception fonctionnelle de Modal s'articule autour de l'axe principal du « mappage transparent du code Python à l'exécution du GPU dans le cloud ». Au lieu d'encapsuler les capacités du cloud dans des commutateurs de console couche par couche, il utilise les constructions du langage de programmation lui-même (décorateurs, appels de fonction, gestionnaires de contexte) pour exprimer les intentions d'infrastructure.

• @app.function decorator : l'abstraction centrale. Ajoutez @app.function(gpu="A100", cpu=4.0, memory=32768, timeout=600) à n'importe quelle fonction Python pour la convertir en fonction GPU cloud. Prend en charge la spécification du nombre de cœurs de processeur, de la taille de la mémoire, du délai d'expiration et du nombre maximum de simultanéité du type de GPU. Les paramètres du décorateur eux-mêmes sont des objets Python de type sécurisé, et la saisie semi-automatique et la vérification de type de l'IDE peuvent fonctionner normalement. Avantage : condensé les 30 minutes à heures typiques de travail de configuration du contexte GPU en une seule ligne de code.

• .map() / .starmap() Parallélisme massif : la capacité la plus sous-estimée du modal. Une ligne de code f.map(inputs) applique la fonction à chaque élément de la liste d'entrée en parallèle, et Modal lance automatiquement le nombre requis d'instances de conteneur pour le traitement parallèle. Avec .starmap(), il prend en charge l'expansion multi-paramètres, et avec .for_each(), il prend en charge les opérations par lots sans renvoyer de résultats. Valeur d'utilisation : les tâches de traitement par lots qui nécessitent à l'origine Apache Spark ou une orchestration manuelle des tâches Kubernetes sont simplifiées en un appel de méthode, et l'équipe peut profiter de milliers de niveaux de parallélisme sans connaissance supplémentaire de l'infrastructure informatique distribuée.

• Intégration de Web Endpoints avec ASGI : publiez des fonctions Python directement en tant que points de terminaison d'API HTTPS hébergés via @app.function().web_endpoint(method="POST") ou @app.asgi_app(). Gère automatiquement les certificats SSL, les noms de domaine, l'équilibrage de charge, ainsi que l'expansion et la contraction, et prend en charge le routage personnalisé des frameworks ASGI tels que FastAPI et Starlette. Synergie : la combinaison de Web Endpoints + .map() est particulièrement puissante : une requête frontale déclenche une fonction Web, qui appelle en interne .map() pour démarrer des centaines de traitements GPU parallèles, et les résultats sont agrégés et renvoyés, et l'ensemble du processus est transparent pour l'appelant.

• Définition déclarative du conteneur d'image : utilisez modal.Image.debian_slim().pip_install("torch", "transformers").apt_install("ffmpeg") pour déclarer les dépendances du conteneur dans le code Python, et Modal construit, met en cache et distribue automatiquement les images Docker. Prend en charge la construction en plusieurs étapes de l'image de base GPU (CUDA 12.x) et la couverture Dockerfile personnalisée. Mécanisme->Effet : Les déclarations de dépendances et le code métier sont stockés dans le même fichier, et le contrôle de version est naturellement associé ; la mise en cache hiérarchique permet généralement de terminer les builds incrémentielles en 10 à 30 secondes, ce qui est beaucoup plus rapide que le processus infime de build + push manuel de Docker.

• @app.cls Stateful Service : le décorateur de méthodes de classe introduit dans la v0.70+ permet aux classes Python (y compris les constructeurs, les variables membres et les méthodes) d'être déployées en tant que services avec état. Les instances de classe restent actives pendant le cycle de vie du conteneur, ce qui convient aux scénarios dans lesquels vous devez charger des modèles en mémoire, gérer des pools de connexions ou gérer des caches d'inférence. Valeur d'utilisation : il résout le problème du « chargement à chaud du modèle » qui est difficile à gérer pour les plates-formes sans serveur purement fonctionnelles : le modèle est chargé une fois dans le constructeur et les appels de méthode suivants utilisent directement le modèle chargé, évitant ainsi la surcharge de chargements répétés pour chaque requête.

• Persistance Modal Volume et Modal Dict : Volume fournit un volume de système de fichiers persistant conforme à POSIX pour stocker de grands poids de modèle, des ensembles de données et des points de contrôle, qui est partagé entre les appels de fonction et peut être monté sur n'importe quel conteneur ; Dict fournit un stockage KV distribué, adapté à la mise en cache légère, au partage d'état et au transfert de configuration. Importance technique : les poids des modèles n'ont pas besoin d'être retéléchargés depuis HuggingFace à chaque démarrage à froid. Les poids d'un modèle 7B (environ 14 Go) peuvent être directement montés lors des appels ultérieurs après le premier chargement, réduisant ainsi la phase de « chargement du modèle » de démarrage à froid de quelques minutes à quelques secondes.

• Planifier une tâche planifiée : ajoutez @app.function(schedule=modal.Period(hours=6)) ou @app.function(schedule=modal.Cron("0 3 * * *")) à la fonction pour créer une tâche GPU pour une exécution planifiée. Convient à l'évaluation planifiée de modèles, à l'extraction de pipelines de données et à la génération de rapports. Lien implicite : la combinaison de tâches planifiées + Volume peut créer un pipeline d'IA automatisé complet : le script de formation est déclenché régulièrement, le point de contrôle du modèle est écrit dans le volume et le point de terminaison Web charge automatiquement les dernières pondérations pour fournir des services, sans intervention manuelle dans l'ensemble du processus.

• Sortie de streaming en streaming : prend en charge la fonction Python Generator (yield) en tant que point de terminaison modal pour implémenter la sortie de streaming jeton par jeton. Pour l'API d'inférence LLM, cela signifie que les appelants peuvent commencer à recevoir des résultats partiels avant que le modèle ne génère une réponse complète, réduisant ainsi considérablement la latence perçue. Utilisez-le avec Web Endpoint pour créer une API d'inférence qui prend en charge les réponses en streaming en moins de 5 minutes.

Evolution du modèle et de la version de Modal

En tant que plateforme d'infrastructure, l'évolution des versions de Modal s'articule autour de trois axes principaux : l'optimisation des performances des conteneurs, l'expansion du modèle de programmation et le suivi écologique du GPU, plutôt que l'itération des versions du modèle lui-même.

Itération de l'architecture du produit

Jalons	Calendrier	Changements fondamentaux	Impact pratique sur les développeurs
Modal Labs a été fondé	2021-06	Co-fondé par Erik Bernhardsson et Akshat Bubna	Concept de produit établi : expérience de cloud computing natif Python
Phase bêta fermée	2021-2022	Développement de l'architecture de base, tests utilisateurs invités limités	L'API et l'architecture sont peaufinées en fonction des premiers commentaires des utilisateurs, et la syntaxe du décorateur est finalisée
Version bêta publique publiée	2022-09	@stub.function(gpu="A100") La version bêta publique de Grammar est en ligne	Ouvert sur le monde extérieur pour la première fois, déclenchant rapidement des discussions au sein de la communauté Python
Points de terminaison Web publiés	2023-03	Prend en charge les fonctions de publication directement en tant qu'API HTTPS	Extension de « Calcul de fonctions GPU » à « Plateforme complète de déploiement d'applications IA »
Version officielle (GA)	2023-06	SLA et système de facturation améliorés, accès client d'entreprise	Marquage de la disponibilité au niveau de la production, une condition préalable aux achats des entreprises
GPU H100 en ligne	2024-06	GPU SXM H100 80 Go officiellement disponible	Répondez aux exigences en matière de mémoire graphique pour la formation et l'inférence de grands modèles
@app.cls Service avec état	~2024-09	Décorateur de méthode de classe, prend en charge le déploiement avec état	Résoudre le problème du « chargement à chaud du modèle » des plates-formes sans serveur
v0.70+ optimisation des conteneurs	~2024-12	Démarrage à froid réduit de 5-10 secondes à 2-3 secondes	Expérience interactive considérablement améliorée et efficacité des tâches courtes
Version officielle du volume modal	~2024-12	Stockage persistant GA, partagé entre les appels	La persistance des poids du modèle et des ensembles de données n'est plus un problème d'ingénierie

Logique technique d'évolution de version

L'itération de la version de Modal reflète une voie technique claire consistant à « d'abord faire les choses correctement, puis les faire rapidement, puis les développer » :

2021-2022 (période de preuve de concept) : Le travail principal consiste à vérifier la faisabilité du « décorateur Python pilotant le GPU cloud ». Le défi à ce stade n'est pas la richesse des fonctionnalités, mais de rendre la syntaxe du décorateur sémantiquement « aussi naturelle que le code natif ». L'expérience d'Erik Bernhardsson avec les abstractions de workflow dans le framework Luigi a joué un rôle clé à ce stade.

2023 (période d'extension des capacités) : Après la sortie de GA, le lancement de Web Endpoints est un tournant dans le positionnement du produit de Modal : il ne s'agit plus d'un simple "calcul de fonction GPU", mais d'une plateforme complète de déploiement d'applications d'IA. Une autre tâche importante à ce stade est l'amélioration du système de facturation et de SLA au niveau de l'entreprise, afin que la plate-forme dispose des conditions de base pour entrer en production.

2024 (Période d'optimisation des performances) : Le lancement du H100 suit de près le rythme de la chaîne d'approvisionnement de NVIDIA. @app.cls et Volume résolvent les deux principales lacunes des services avec état et de la persistance. L'optimisation du démarrage à froid dans la version 0.70+ réduit la latence moyenne de 5 à 10 secondes à 2 à 3 secondes, et l'investissement d'ingénierie sous-jacent comprend l'échauffement du cache d'image du conteneur, l'optimisation de la latence de montage réseau et le préchargement du pilote GPU.

Les avantages techniques du Modal

L'avantage technique de Modal ne réside pas dans l'échelle de calcul GPU ou la couverture du centre de données - qui sont toutes deux bien inférieures à AWS/GCP - mais dans la capacité d'abstraire la complexité de l'infrastructure cloud dans une couche sémantique Python et d'atteindre une utilisation des ressources quasi extrême dans des scénarios GPU sans serveur.

Infrastructure en tant que décorateur : la plus grande innovation technique de Modal consiste à combiner les trois niveaux de configuration de la configuration déclarative de Kubernetes, l'empaquetage de conteneurs de Docker et la découverte du service d'équilibrage de charge dans un décorateur Python. @app.function(gpu="A100", cpu=4.0, memory=32768) est sémantiquement équivalent à "créer un pod contenant les ressources spécifiées, le monter sur le service et l'exposer en tant que point de terminaison d'API", mais les développeurs n'ont besoin d'écrire qu'une seule ligne de code. Le principe de fonctionnement de cette couche d'abstraction est le suivant : Modal CLI analyse les fonctions décorées avec « @app » dans le module Python lors du « déploiement modal », les compile en images de conteneurs indépendantes, puis les transmet automatiquement au registre de conteneurs de Modal. Enfin, l'orchestrateur de Modal démarre et détruit dynamiquement les instances de conteneur en fonction du nombre de requêtes.

Mise en œuvre technique de la facturation au niveau de la milliseconde : la granularité de facturation de 100 ms de Modal n'est pas une simple « heure de début et heure de fin de l'enregistrement », mais est implémentée via un système de comptabilité des ressources au niveau du conteneur. Chaque instance de conteneur est enregistrée auprès du service de facturation lors de son démarrage, et le type de GPU, la quantité d'allocation CPU/mémoire et l'horodatage de démarrage sont enregistrés ; la facture définitive est remise lors de la destruction du conteneur. Le système prend en charge l'interruption préventive (recyclage automatique des ressources lorsque le solde du compte utilisateur est insuffisant ou que le quota dépasse la limite) pour éviter des dépenses inattendues causées par une fuite de ressources. Pour les développeurs, cela signifie que les appels de fonction de Modal n'entraîneront pas de facturation continue en raison de l'oubli de fermer le contexte - le retour de fonction, la destruction du conteneur et l'arrêt de la facturation sont strictement synchronisés.

Stratégie d'optimisation pour la mise en cache hiérarchique des images de conteneur : le système de construction d'images de Modal s'appuie sur le mécanisme de mise en cache hiérarchique de Docker mais apporte trois améliorations pour les scénarios d'IA : Premièrement, Pré-cache d'image de base - images de base d'IA couramment utilisées (CUDA 12.x + PyTorch + Transformers) dans Modal. Il existe déjà un cache pré-construit dans le registre de conteneurs, les utilisateurs n'ont donc pas besoin de le créer à partir de zéro ; la seconde est la mise en cache incrémentielle de la résolution des dépendances - des instructions telles que pip_install("torch==2.1.0") sont mises en cache dans une couche dédiée après la première installation, et torch ne sera pas réinstallé même si d'autres dépendances sont modifiées ultérieurement ; le troisième est le partage de cache entre utilisateurs - la couche de dépendance avec le même hachage est partagée dans les builds de tous les utilisateurs, ce qui signifie que si un membre d'une équipe a déjà construit la couche d'image de la torche, d'autres peuvent la réutiliser directement. L'effet combiné : la première génération d'une application d'IA typique prend environ 2 à 5 minutes, les versions incrémentielles suivantes prenant généralement 10 à 30 secondes.

.map() Conception d'une architecture parallèle à grande échelle : l'exécution parallèle de Modal ne repose pas sur la réponse lente de Kubernetes HPA (mise à l'échelle automatique horizontale), mais utilise une architecture de planification instantanée basée sur des files d'attente de messages. Lorsque le développeur appelle « f.map(inputs) », le planificateur de Modal divise la liste d'entrée en plusieurs unités de travail (morceaux), et chaque unité est transmise à la file d'attente de messages interne à haut débit ; Ensuite, le planificateur démarre dynamiquement l'instance de conteneur en fonction de la profondeur de la file d'attente, et chaque instance extrait l'unité de travail de la file d'attente pour l'exécution. Ce modèle « axé sur les messages + consommation compétitive » permet à Modal de lancer des milliers d'instances de conteneurs parallèles en 2 à 5 secondes, alors que le temps de réponse d'expansion et de contraction du Kubernetes HPA traditionnel prend généralement 30 à 90 secondes. Cependant, le principe de performance de cette architecture est que le temps d'exécution de chaque unité de travail doit être nettement supérieur au temps de démarrage du conteneur (recommandé > 10 secondes), sinon la surcharge de démarrage du conteneur diluera l'efficacité parallèle.

Éléments manquants au niveau de l'entreprise : le manque de fonctions au niveau de l'entreprise de Modal est une dimension qui ne peut être ignorée lors de la sélection de la technologie : il ne prend pas en charge les connexions de réseau privé VPC, ne prend pas en charge le déploiement multirégional (actuellement principalement aux États-Unis), le statut des certifications de conformité telles que SOC2/GDPR n'est pas divulgué et il n'existe pas d'option de déploiement privatisé. Cela signifie que l’applicabilité de Modal est fondamentalement limitée dans les scénarios industriels qui nécessitent un contrôle de souveraineté des données, tels que la finance, les soins médicaux et les affaires gouvernementales.

Comment utiliser Modal

Modal offre une expérience de développement à double entrée du SDK CLI + Python. Le flux de travail principal est "codage local → débogage de l'exécution modale → déploiement modal en ligne".

Comment utiliser	Convient aux personnes	Caractéristiques	Coût
SDK CLI + Python	Tous les développeurs Python	pip install modal, modal token new peuvent être utilisés après la certification	Facturation à l'utilisation + quota gratuit de 30 $/mois
Console Web	Rôles d'exploitation et de surveillance	Afficher les journaux de fonctions, l'historique d'exécution, les statistiques d'utilisation	Gratuit (entrée console)
débogage local à exécution modale	stade de développement	exécution à distance d'un appel local, édition de code dans l'IDE local, exécution d'un GPU cloud	paiement à l'utilisation
déploiement modal Déploiement formel	Contexte de production	Publiez des fonctions en tant que points de terminaison d'API persistants, gérez automatiquement l'expansion et la contraction	Facturation à l'utilisation

Démarrez rapidement : déployez une API d'inférence LLM

importation modale
à partir de l'importation modale Image, application

# Déclarer les dépendances du conteneur
app = App("llm-inférence")
image = Image.debian_slim().pip_install(
    "transformateurs>=4.38.0",
    "torche>=2.1.0",
    "accélérer>=0.27.0"
)

# Définir la fonction d'inférence avec GPU
@app.function(gpu="A100", image=image, containers_idle_timeout=300, timeout=600)
def generate (invite : str, température : float = 0,7) -> str :
    à partir des transformateurs, importez AutoModelForCausalLM, AutoTokenizer
    # Le modèle est chargé au premier appel et réutilisé lors des appels suivants (grâce à @app.cls ou au préchauffage du conteneur)
    modèle = AutoModelForCausalLM.from_pretrained(
        "mistralai/Mistral-7B-Instruct-v0.2",
        device_map="auto",
        torch_dtype="auto"
    )
    tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")
    entrées = tokenizer(prompt, return_tensors="pt").to("cuda")
    sorties = model.generate(**inputs, température=température, max_new_tokens=512)
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# Publier en tant que point de terminaison de l'API
@app.function(gpu="A100", image=image).web_endpoint(method="POST")
def api_generate(data : dict) -> dict :
    réponse = generate.remote(data["prompt"], temperature=data.get("temperature", 0.7))
    return {"réponse": réponse}

Commande de déploiement : exécutez modal déployer app.py dans le répertoire racine du projet. Vous obtiendrez l'URL de l'API HTTPS dans environ 2 à 5 minutes (la première fois que vous créez l'image).

Conseil d'optimisation du démarrage à froid : Dans l'exemple ci-dessus, le paramètre container_idle_timeout=300 contrôle le conteneur à recycler après avoir été inactif pendant 300 secondes. Grâce au mécanisme de préchauffage de la plateforme, le délai d'appel à chaud peut être réduit à 50-200 ms. Pour les environnements de production, il est recommandé d'encapsuler la logique de chargement du modèle dans le constructeur de @app.cls, de sorte que le modèle ne soit chargé qu'une seule fois lorsque la classe est instanciée et que les appels de méthode ultérieurs soient directement déduits.

Prix des produits pour Modal

Le modèle tarifaire de Modal est entièrement basé sur l'utilisation, sans distinction entre prépayé et postpayé, sans consommation minimale et sans engagement d'utilisation (sauf pour les forfaits d'entreprise).

Crédit gratuit : les nouveaux utilisateurs reçoivent 30 $ par mois en crédits informatiques après l'inscription, qui peuvent être utilisés pour toutes les ressources GPU/CPU/stockage, ce qui équivaut à environ 8 heures d'utilisation de l'A100 ou 39 heures d'utilisation du T4. Il n'est pas nécessaire de lier une carte de crédit pour s'inscrire à l'expérience, ce qui abaisse le seuil d'évaluation, mais signifie également que les utilisateurs d'essai ne peuvent pas utiliser les fonctionnalités de niveau entreprise qui nécessitent une vérification de carte de crédit.

Liste de prix de facturation GPU par seconde :

Modèle GPU	Mémoire vidéo	Prix ​​par heure	Prix ​​par seconde	Utilisations typiques
T4	16 Go	0,76 $/heure	~0,00021 $/seconde	Raisonnement léger, classification d'images, génération d'intégration
A10G	24 Go	1,10 $/heure	~0,00031$/seconde	Inférence et réglage fin de modèles à moyenne échelle
A100 40 Go	40 Go	3,72 $/heure	~0,00103$/seconde	Inférence LLM grand public, modèle de diffusion, inférence par lots
A100 80 Go	80 Go	4,76 $/heure	~0,00132 $/seconde	Inférence de grand modèle Ajustement LoRA, traitement par lots importants
H100	80 Go	~5,96 $/heure	~0,00166 $/seconde	Formation, inférence de top model, API haut débit

Tarifs du processeur et du stockage : cœur de processeur 0,12 $/heure/cœur, mémoire 0,015 $/heure/Go. Stockage de volume modal 0,10 $/Go/mois. Sortie réseau 0,12 $/Go (inférieur à la plage de 0,12 à 0,23 $/Go d'AWS/GCP). Le trafic entrant sur le réseau est gratuit.

Forfait Entreprise : les clients ayant plus de 5 000 heures d'utilisation mensuelle du GPU peuvent contacter Business pour bénéficier de remises sur engagement d'utilisation. Le forfait Entreprise comprend également un canal d'assistance Slack dédié, le paiement des factures et un SLA personnalisé. Cependant, les besoins courants des entreprises tels que l'intégration VPC, le déploiement multirégional et le déploiement privatisé ne sont pas clairement pris en charge dans les informations publiques.

Comparaison des prix avec des produits concurrents :

Dimensions	modale	AWS SageMaker	GCP Vertex AI	RunPod
Granularité de facturation	100 ms	Secondes (à partir de 1 minute)	Secondes (à partir de 1 minute)	Horaires
Prix ​​horaire A100 40 Go	3,72 $	3,91 $+ (y compris les frais d'hébergement)	3,89 $+ (y compris les frais de nœud)	2,49 $
Scénario de tâche courte (15 secondes/temps)	0,0155 $/heure (par secondes)	0,0978 $/heure (en minutes)	Semblable à SageMaker	2,49 $/heure (par heures)
Mise à l'échelle automatique sans serveur	Prise en charge native	Configuration supplémentaire requise	Configuration supplémentaire requise	Non pris en charge (commutateur manuel requis)
Dépenses minimales	Aucun	Aucun (mais commence à partir de 1 minute)	Aucun (mais commence à partir de 1 minute)	Oui
Crédit gratuit	30$/mois	Aucun	Crédit nouvel utilisateur de 300 $	Aucun

La comparaison montre que Modal présente des avantages de coût évidents dans des scénarios avec des tâches courtes, une fréquence élevée et un parallélisme élevé, mais le prix unitaire lui-même n'est pas inférieur à celui des fournisseurs de cloud établis. Sa vraie valeur réside dans l'élimination des coûts d'inactivité et dans un coût d'exploitation et de maintenance nul, et non dans le prix unitaire inférieur du non-GPU.

Scénarios d'application modale

Les scénarios applicables de Modal se concentrent entre « exiger de la puissance de calcul GPU mais ne pas vouloir gérer l'infrastructure GPU » : calcul intensif mais sans état, temps d'exécution allant de quelques secondes à quelques minutes et degré élevé de parallélisabilité.

Déduction quantitative de la réduction des coûts et de l'amélioration de l'efficacité

Les déductions quantitatives suivantes sont basées sur les tarifs publics et les estimations typiques de la charge de travail et sont considérées comme des déductions plutôt que comme des engagements officiels :

• Pipeline d'inférence par lots d'AI Company : un pipeline de traitement d'images traite 500 000 images par jour, chaque inférence prenant environ 8 secondes (GPU T4). Sur Modal : 0,76 $/heure ÷ 3 600 secondes × 8 secondes × 500 000 fois ≈ 84,4 $ par jour, et le coût mensuel est d'environ 2 533 $. La même charge doit réserver au moins 2 T4 pour un fonctionnement d'une journée complète sur la plateforme de facturation horaire, et le coût est d'environ 1 094 $/mois/carte × 2 cartes = 2 188 $/mois. Cependant, une élasticité et une marge d'exploitation et de maintenance supplémentaires de 50 % sont généralement requises, et le coût réel est plus élevé. La mise à l'échelle automatique de Modal augmente l'utilisation de 60 % à plus de 95 %. Conclusion de déduction : le coût mensuel est réduit de 3 200 $+ (plan traditionnel) à 2 500 $ (Modal), ce qui permet d'économiser environ 22 %, tout en éliminant la main-d'œuvre DevOps.

• L'API modèle de l'équipe de start-up est en ligne : le temps moyen nécessaire à l'équipe ML de 3 personnes entre la fin de la formation du modèle et le lancement de l'API appelable à l'aide de Modal est d'environ 1 à 2 heures (y compris la première création d'image de conteneur) ; l'utilisation de la solution traditionnelle Kubernetes + GPU Node prend en moyenne 3 à 5 jours (y compris la configuration de l'environnement et la configuration CI/CD de l'ouverture du réseau). Conclusion de déduction : le cycle en ligne est raccourci de 3 à 5 jours à 1 à 2 heures, ce qui permet d'économiser plus de 96 % du temps de déploiement.

• Expériences intermittentes pour les chercheurs : les doctorants réalisent des expériences 3 à 5 fois par semaine, en utilisant l'A100 pendant environ 1 heure à chaque fois, pour une utilisation mensuelle d'environ 15 à 20 heures. Le mode modal coûte environ 55 à 74 $/mois (par seconde) et les instances GPU mensuelles coûtent environ 500 à 800 $/mois (taux d'inactivité élevé). Déduction : la facturation à la seconde réduit le coût de l'utilisation intermittente de 85 à 90 %.

Explication détaillée des scénarios typiques

Scénario 1 : Pipeline d'inférence d'IA par lots (scénario d'attaque par réduction de dimensionnalité)

Les équipes de données utilisent l'opération .map() de Modal pour effectuer une inférence par lots sur des ensembles de données à grande échelle. Le principal avantage est que Modal permet de diviser l'entrée en unités de travail de n'importe quelle granularité et de l'attribuer automatiquement à des milliers de conteneurs parallèles. Les développeurs doivent uniquement se concentrer sur la logique de traitement d'une seule donnée, et la complexité de la planification parallèle est entièrement supportée par la plateforme.

Conseil de mise en œuvre : Il est essentiel de choisir la bonne taille d'unité de travail : il est recommandé que le temps d'exécution de chaque unité de travail soit compris entre 10 et 60 secondes pour équilibrer les frais de démarrage du conteneur et l'efficacité parallèle. Pour les unités de moins de 10 secondes, envisagez de fusionner plusieurs entrées en un seul lot avant de les soumettre.

Scénario 2 : Prototypage rapide et lancement de l'API du modèle d'IA (scénario d'attaque par réduction de dimensionnalité)

Des poids de modèle formés à l'API REST appelable, le chemin conventionnel nécessite la configuration du framework Web (FastAPI/Flask), la création d'une image Docker, la configuration de l'équilibrage de charge et de la mise à l'échelle automatique, ainsi que l'enregistrement DNS et SSL. Modal compresse l'ensemble du processus en trois étapes : "écrire la fonction d'inférence → ajouter le décorateur @web_endpoint → déployer modal en ligne".

Conseil de mise en œuvre : les points de terminaison Web sont accessibles par défaut sur l'Internet public. Si vous devez l'appeler dans un réseau privé, Modal ne prend actuellement pas en charge les connexions privées VPC et ne peut contrôler l'accès que via l'authentification par jeton API et la liste blanche IP. Pour les scénarios nécessitant une isolation du réseau privé, vous devez attendre les capacités réseau d'entreprise de Modal ou envisager des alternatives.

Scénario 3 : Pipeline de données planifié et mise à jour du modèle

Les tâches d'arrière-plan des applications d'IA (analyse régulière des dernières données d'entraînement, réévaluation des performances du modèle et génération de rapports hebdomadaires) sont implémentées sur Modal via le décorateur Schedule. @app.function(schedule=modal.Cron("0 6 * * 1")) peut créer une tâche GPU qui se déclenche tous les lundis à 6 heures du matin.

Conseils de mise en œuvre : La combinaison de tâches planifiées et de volume modal peut créer un pipeline d'opérations d'IA entièrement automatique : collecte de données → prétraitement → évaluation du modèle → génération de rapports → poussée des résultats. Chaque étape est une fonction modale indépendante. Les résultats intermédiaires sont partagés via Volume et Schedule connecte l'ensemble du processus. Mais attention : la planification ne garantit pas un déclenchement strict à temps (il existe un écart de planification d'environ quelques secondes) et elle ne convient pas aux scénarios qui nécessitent un déclenchement précis au deuxième niveau.

Scénario 4 : Système de raisonnement concurrent multimodèle (scénario d'effet de synergie)

Pour les applications complexes qui doivent exécuter plusieurs modèles d'IA tels que l'intégration de texte, la recherche sémantique, la génération de langage et la compréhension d'images en même temps, utilisez Modal pour encapsuler chaque modèle en tant qu'instance de classe @app.cls indépendante. Étant donné que les modèles de charge des différents modèles sont différents (les modèles intégrés sont appelés fréquemment mais nécessitent une petite quantité de calculs à la fois, et les modèles générés sont appelés fréquemment mais nécessitent une grande quantité de calculs), l'expansion et la contraction automatiques de Modal maintiendront un nombre différent d'instances de conteneur pour chaque modèle.

Conseils de mise en œuvre : dans les scénarios où plusieurs modèles coexistent, vous devez faire attention aux conflits de mémoire GPU. Si les besoins totaux pondérés en mémoire vidéo des deux modèles dépassent la capacité d'une seule carte, Modal allouera automatiquement différentes instances de GPU, mais cela signifie également une utilisation matérielle inférieure et un coût total plus élevé. Il est recommandé d'attribuer des modèles ayant des besoins en mémoire similaires au même type de GPU pour maximiser l'utilisation.

Groupes de modaux applicables

Limite de la collaboration homme-machine

Pour les scénarios d'utilisation modale, il est nécessaire de bien distinguer les sections qui peuvent être automatisées et les sections qui doivent être confirmées manuellement :

• Peut être 100 % automatisé : déploiement de fonctions, construction de conteneurs, allocation de GPU, décisions d'expansion et de contraction, collecte de journaux et calcul de facture. Ces sections sont automatiquement complétées par la plateforme Modal sans que les développeurs n'interviennent.
• Human-in-the-loop requis : distribution et rotation des jetons API, définition du seuil d'avertissement de coût, sélection des dépendances de base de l'image du conteneur, délai d'attente des fonctions et réglage des paramètres de concurrence. Ces décisions mesurées ont un impact direct sur la sécurité, les coûts et la stabilité.
• Approbation de conformité forte : avant le lancement de la production, il est recommandé que l'équipe de sécurité vérifie si les points de terminaison de l'API exposent des données sensibles ; dans les scénarios impliquant le traitement des données des clients, il est nécessaire de confirmer que les données ne seront pas traitées dans des zones non désignées.

Adaptez-vous à la foule

Scientifiques des données Python et ingénieurs ML : il s'agit de la base d'utilisateurs principale de Modal. La caractéristique est qu’ils maîtrisent les frameworks Python et ML mais manquent d’expérience DevOps. Dans le passé, ils devaient confier le code du modèle à l'équipe d'ingénierie pour le déploiement, et l'efficacité des itérations était limitée par la communication entre les équipes. Modal permet aux data scientists de mener à bien de manière indépendante l'ensemble du processus, du développement du modèle au lancement de l'API. Le flux de travail typique passe de « écrire du code → soumettre PR → attendre le déploiement DevOps → débogage conjoint → rechercher des problèmes → répéter » à « écrire du code → déploiement modal → problèmes de retour d'information → modifier → déploiement modal ».

Ingénieur full-stack pour les startups d'IA : pour les startups d'IA de 3 à 10 personnes, les ingénieurs assument simultanément plusieurs rôles de développement de modèles, de services back-end et de gestion de l'infrastructure. Modal réduit la complexité de l'infrastructure au point où « une seule personne peut la gérer », permettant aux petites équipes d'itérer rapidement des produits d'IA même en l'absence de personnel DevOps professionnel. Conseil de mise en œuvre : l'équipe de démarrage recommande d'utiliser le quota gratuit de 30 $/mois pour vérifier l'adéquation du produit au marché (PMF), puis de sélectionner un plan de mise à niveau en fonction de l'échelle après confirmation.

Chercheurs et étudiants en IA : ils ont besoin d'une puissance de calcul GPU intermittente pour réaliser des expériences, et le modèle de paiement à l'utilisation évite le gaspillage de ressources inutile causé par la location à long terme d'instances GPU. Le crédit gratuit de 30 $/mois est suffisant pour prendre en charge 2 à 3 heures d’utilisation de l’A100 par semaine. Conseils de mise en œuvre : L'exigence typique des scénarios de recherche est de « nécessiter occasionnellement une puissance de calcul à grande échelle ». L'opération .map() de Modal convient à la recherche parallèle d'hyperparamètres et à l'évaluation de modèles, mais ne convient pas aux tâches de formation distribuées qui nécessitent une exécution continue à long terme (> 24 heures).

Ingénieur en traitement de données par lots : ingénieurs qui traitent des données d'image, de texte ou d'audio à grande échelle, l'opération parallèle .map() de Modal a un seuil de déploiement bien inférieur à celui d'Apache Spark ou Dask. Principe applicable : la logique de traitement des données doit être « divisible en unités sans état ». S'il existe un grand nombre de dépendances d'état entre lots ou d'opérations de brassage complexes dans le pipeline de données, le modèle fonctionnel de Modal peut ne pas être applicable.

Ne convient pas à la foule et à la scène

• Services en ligne nécessitant un raisonnement en temps réel à faible latence (<200 ms) : le délai de démarrage à froid de Modal (2 à 5 secondes) et la surcharge du réseau le rendent inadapté aux scénarios extrêmement sensibles à la latence (tels que l'IA vocale en temps réel, le trading haute fréquence, l'IA de jeu interactif). Dans ces scénarios, le déploiement du modèle sur un serveur GPU dédié côté client (tel que NVIDIA Triton Inference Server) est un choix plus raisonnable.

• Services volumineux qui doivent fonctionner à pleine charge 24h/24 et 7j/7 : si l'utilisation du GPU est stable au-dessus de 80 %, le coût total de facturation par seconde de Modal dépassera les instances dédiées mensuelles. En supposant une utilisation 24h/24 et 7j/7 d'une carte A100 unique, Modal coûte environ 2 678 $ par mois, tandis qu'une instance réservée d'un an pour AWS p4d coûte environ 1 700 $ par mois. Dans un scénario de charge continue continue, les instances réservées ou le bare metal des GPU cloud traditionnels sont plus adaptés.

• Équipe de développement de pile non Python : Modal ne prend actuellement en charge que le SDK Python. Si l'équipe utilise principalement Go, Java, Rust ou Node.js, les avantages de la syntaxe du décorateur de Modal ne peuvent pas être reflétés, et il est nécessaire de trouver des alternatives qui correspondent à l'écosystème linguistique (comme le SDK Java de Beam ou le support multilingue de Google Cloud Run).

• Entreprises nécessitant un déploiement privatisé ou un contrôle de souveraineté des données : Modal ne prend pas en charge le déploiement privatisé (sur site) et ne prend pas clairement en charge les connexions de réseau privé VPC dans les informations publiques. Pour des secteurs tels que la finance, la santé et le gouvernement, qui sont soumis à des réglementations strictes en matière de souveraineté des données, le modèle de livraison uniquement cloud de Modal constitue une limitation fondamentale, et les solutions prenant en charge le déploiement privatisé (comme le cloud privé de RunPod ou NVIDIA AI Enterprise) doivent être prioritaires.

Résumé et perspectives de Modal

Avec le concept de conception consistant à « faire en sorte que le cloud computing ressemble à du Python local », Modal crée une expérience de développement différenciée dans le domaine du déploiement cloud IA/ML. L'élégance syntaxique de l'API du décorateur Python, la précision des coûts de facturation au niveau de la milliseconde et la simplicité des opérations parallèles .map() la rendent nettement supérieure aux produits GPU cloud traditionnels en termes de réputation technique.

Principales barrières concurrentielles : le véritable avantage de Modal n'est pas le prix unitaire du GPU ou l'échelle de puissance de calcul, mais la qualité de conception de la couche d'abstraction sémantique : la capacité d'encoder uniformément les concepts d'infrastructure cloud tels que les conteneurs, l'orchestration, la facturation et la surveillance dans la sémantique Python. Cette abstraction permet aux équipes d’IA d’acquérir des capacités cloud GPU de niveau production sans faire appel à du personnel DevOps dédié. La réputation technique d'Erik Bernhardsson dans le domaine de l'ingénierie des données (auteur du framework Luigi) a renforcé la confiance de la communauté dans son jugement technique, qui a un effet levier irremplaçable dans les premières étapes d'adoption des outils de développement.

Limites et incertitudes actuelles : Le délai de démarrage à froid (2 à 5 secondes) limite fondamentalement les limites de ses scénarios d'application en temps réel ; le manque de fonctionnalités au niveau de l'entreprise (VPC, multirégion, certification de conformité, déploiement privatisé) rend discutable son applicabilité dans les secteurs réglementés ; le manque de prise en charge des langages non Python limite le plafond d'expansion de la base d'utilisateurs. En outre, la viabilité financière à long terme de Modal en tant que startup – qu’elle soit acquise ou qu’elle ajuste considérablement sa stratégie de prix – sont également des facteurs de risque que les entreprises doivent prendre en compte lors de l’achat.

Points d'observation de suivi :

• La possibilité de réduire le démarrage à froid de 2 à 3 secondes à un niveau inférieur à la seconde est une condition préalable à l'ouverture du marché de l'inférence en temps réel ;
• L'inclusion ou non de SDK multilingues (Go, TypeScript, Rust) dans la feuille de route déterminera la rapidité avec laquelle la base d'utilisateurs se développera ;
• L'achèvement de l'intégration VPC et de la certification de conformité d'entreprise (SOC2) est le seuil clé pour entrer sur le marché des entreprises ;
• Le fait que le support de formation distribué (formation parallèle de plusieurs nœuds et plusieurs GPU) soit complet détermine s'il peut passer des scénarios d'inférence aux scénarios de formation ;
• La profondeur de l'intégration native avec les frameworks d'applications d'IA (LangChain, LlamaIndex, Haystack) affectera sa niche dans l'écosystème de développement d'applications d'IA.

Évaluation des risques d'approvisionnement et d'adoption : pour les développeurs individuels et les chercheurs indépendants, le quota gratuit de 30 $/mois offre un chemin d'évaluation sans risque. À ce stade, cela vaut la peine d’essayer Modal comme l’une des options privilégiées pour le cloud GPU. Pour les startups d'IA, il est recommandé d'utiliser d'abord Modal pour vérifier l'adéquation produit-marché sur les processus non essentiels, puis d'évaluer s'il convient d'étendre les processus de base de production après avoir confirmé le nombre d'utilisateurs et les exigences de stabilité. (À l'heure actuelle, il est nécessaire de se concentrer sur le calcul du coût d'une charge continue à long terme et d'évaluer s'il convient de passer à la solution d'instance réservée). Pour les entreprises des secteurs réglementés, avant que Modal n'obtienne la certification VPC et de conformité, il est recommandé de limiter Modal à l'environnement de R&D et d'expérimentation des données non sensibles. Le processus principal de production des données doit encore être déployé dans le réseau privé de la plateforme cloud traditionnelle. Avant de prendre une décision d'achat, il est recommandé d'effectuer une comparaison en niveaux de gris pendant au moins deux semaines : exécuter un véritable pipeline commercial en parallèle sur Modal et la plateforme existante, et comparer les différences dans les trois dimensions de la répartition des délais, des fluctuations des coûts et du nombre d'interventions d'exploitation et de maintenance. <｜fin de la réflexion｜>

<｜｜DSML｜｜tool_calls> <｜｜DSML｜｜invoke name="read_file"> <｜｜DSML｜｜parameter name="filePath" string="true">C:\Users\Administrator\Desktop\aistartmap\docs\submission\output\tools\modal\tool-modal.md

Outils associés : Visage câlin, replicate

Informations de version

• Conteneur Modal v0.70+ et optimisation de la concurrence ：Les versions de la série Modal v0.70+ apportent une optimisation significative de la vitesse de démarrage des conteneurs (le temps de démarrage à froid est réduit d'une moyenne de 5 à 10 secondes à 2 à 3 secondes). Le nouveau décorateur de méthodes de classe @app.cls prend en charge le déploiement de services avec état et améliore la logique de traitement simultané pour réduire le gaspillage de ressources. Le GPU H100 est officiellement lancé pour répondre aux besoins de formation et d'inférence de grands modèles. Le stockage persistant Modal Volume est lancé en même temps pour résoudre le problème de la persistance des appels croisés des poids de modèle et des ensembles de données. （~2024-12）
• Sortie de la version bêta publique modale ：La plate-forme Modal est entrée en phase bêta publique, ouvrant pour la première fois aux développeurs externes des services cloud GPU sans serveur basés sur des décorateurs Python. La syntaxe concise de `@stub.function(gpu="A100")` a suscité de nombreuses discussions au sein de la communauté des développeurs et est connue comme « la manière la plus intuitive d'utiliser les GPU cloud pour les développeurs Python », accumulant rapidement un grand nombre d'utilisateurs précoces. （2022-09）
• Sortie de la version officielle modale (GA) ：Modal a annoncé la sortie de la version officielle de la plateforme (Disponibilité générale), a mis fin à la phase bêta publique et a amélioré le SLA et le système de facturation. Dans le même temps, il a lancé la fonction Web Endpoints, qui prend en charge la publication directe de fonctions Python en tant que points de terminaison d'API HTTPS sans avoir besoin de configurer des serveurs Web et des équilibreurs de charge, permettant à Modal de passer du « calcul de fonctions GPU » à une « plate-forme complète de déploiement d'applications d'IA ». （2023-06）