Container Compute Service:Build a distributed inference service for the full-capability DeepSeek-R1 model with ACS GPU compute

Partitionnement du modèle

Le modèle DeepSeek-R1 compte 671 milliards de paramètres. Un GPU unique dispose généralement de 96 GiB de mémoire au maximum et ne peut donc pas charger le modèle entier. Le partitionnement du modèle est par conséquent indispensable. Cette rubrique présente un déploiement distribué sur deux instances de conteneur GPU, adoptant une stratégie combinant parallélisme de pipeline (PP=2) et parallélisme de tenseurs (TP=8). La figure suivante illustre ce partitionnement.

Le parallélisme de pipeline (PP=2) divise le modèle en deux étapes, chacune s'exécutant sur une instance de conteneur GPU distincte. Par exemple, un modèle M peut être scindé en M1 et M2. M1 traite l'entrée sur la première instance et transmet les résultats intermédiaires à M2 pour les opérations suivantes sur la seconde instance.

Le parallélisme de tenseurs (TP=8) répartit les opérations de calcul de chaque étape du modèle (comme M1 et M2) sur 8 GPU. Dans l'étape M1, lorsque les données d'entrée arrivent, elles sont divisées en 8 parties et traitées simultanément sur 8 GPU. Chaque GPU traite une petite portion des données, puis les résultats sont combinés.

Architecture de déploiement distribué

Cette solution utilise ACS pour déployer un service d'inférence DeepSeek-R1 distribué et complet via vLLM et Ray. Elle emploie LWS pour gérer le déploiement Leader-Worker et Fluid pour la mise en cache distribuée afin d'accélérer le chargement du modèle. vLLM s'exécute sur deux Pods de 8 GPU, chacun fonctionnant comme un groupe Ray (Head et Workers) pour améliorer le débit. Notez que les modifications d'architecture affectent les variables YAML telles que tensor-parallel-size et LWS_GROUP_SIZE.

Étape 1 : Préparer les fichiers du modèle DeepSeek-R1

En raison de leur nombre massif de paramètres, les LLM nécessitent un espace disque important pour les fichiers de modèle. Nous vous recommandons de créer un volume NAS ou OSS pour le stockage persistant de ces fichiers. Cette rubrique prend OSS comme exemple.

1. Exécutez les commandes suivantes pour télécharger le modèle DeepSeek-R1 depuis ModelScope.

   Remarque

   Assurez-vous que le plugin git-lfs est installé. Installez-le en exécutant yum install git-lfs ou apt-get install git-lfs. Pour d'autres méthodes d'installation, consultez Installer git-lfs.

   git lfs install
   GIT_LFS_SKIP_SMUDGE=1 git clone https://www.modelscope.cn/deepseek-ai/DeepSeek-R1.git
   cd DeepSeek-R1/
   git lfs pull

2. Créez un répertoire dans OSS et envoyez le modèle vers OSS.

   Remarque

   Pour plus d'informations sur l'installation et l'utilisation d'ossutil, consultez Installer ossutil.

   ossutil mkdir oss://<your-bucket-name>/models/DeepSeek-R1
   ossutil cp -r ./DeepSeek-R1 oss://<your-bucket-name>/models/DeepSeek-R1

3. Une fois le modèle stocké dans OSS, deux méthodes de chargement s'offrent à vous.

   1. Monter directement le modèle via un PVC et un PV : Cette méthode convient mieux aux modèles plus petits et aux applications sans exigences strictes concernant le démarrage des pods ou la vitesse de chargement du modèle.

      Console

      Le tableau suivant décrit la configuration de base d'un PV exemple :

      Élément de configuration	Description
      Type de volume	OSS
      Nom	llm-model
      Certificat d'accès	Configurez l'AccessKey ID et l'AccessKey secret pour accéder à OSS.
      ID du Bucket	Sélectionnez le bucket OSS créé à l'étape précédente.
      Chemin OSS	Sélectionnez le chemin où se trouve le modèle, par exemple /models/DeepSeek-R1.

      Le tableau suivant décrit la configuration de base d'un PVC exemple :

      Élément de configuration	Description
      Type de Persistent Volume Claim (PVC)	OSS
      Nom	llm-model
      Mode d'allocation	Sélectionnez un volume existant.
      Volume existant	Cliquez sur le lien Select an existing PV et sélectionnez le PV créé.

      kubectl

      L'exemple YAML suivant illustre cette configuration :

      apiVersion: v1
      kind: Secret
      metadata:
        name: oss-secret
      stringData:
        akId: <your-oss-ak> # The AccessKey ID for accessing OSS.
        akSecret: <your-oss-sk> # The AccessKey secret for accessing OSS.
      ---
      apiVersion: v1
      kind: PersistentVolume
      metadata:
        name: llm-model
        labels:
          alicloud-pvname: llm-model
      spec:
        capacity:
          storage: 30Gi 
        accessModes:
          - ReadOnlyMany
        persistentVolumeReclaimPolicy: Retain
        csi:
          driver: ossplugin.csi.alibabacloud.com
          volumeHandle: llm-model
          nodePublishSecretRef:
            name: oss-secret
            namespace: default
          volumeAttributes:
            bucket: <your-bucket-name> # The bucket name.
            url: <your-bucket-endpoint> # The endpoint, such as oss-cn-hangzhou-internal.aliyuncs.com.
            otherOpts: "-o umask=022 -o max_stat_cache_size=0 -o allow_other"
            path: <your-model-path> # In this example, /models/DeepSeek-R1/.
      ---
      apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
        name: llm-model
      spec:
        accessModes:
          - ReadOnlyMany
        resources:
          requests:
            storage: 30Gi
        selector:
          matchLabels:
            alicloud-pvname: llm-model

   2. Accélérer le chargement du modèle avec Fluid : Cette approche est recommandée pour les modèles volumineux et les applications exigeant des temps de démarrage de pod et de chargement de modèle rapides. Pour plus d'informations, consultez Utiliser Fluid pour accélérer l'accès aux données.

      1. Dans la place de marché d'applications ACS, installez le composant ack-fluid à l'aide de Helm. La version du composant doit être 1.0.11-* ou ultérieure. Pour plus d'informations, consultez Utiliser Helm pour créer une application.

      2. Activez le mode privilégié pour le Pod ACS en soumettant un ticket.

      3. Créez un Secret pour accéder à OSS.

         apiVersion: v1
         kind: Secret
         metadata:
           name: mysecret
         stringData:
           fs.oss.accessKeyId: xxx
           fs.oss.accessKeySecret: xxx

         Dans le code précédent, fs.oss.accessKeyId et fs.oss.accessKeySecret correspondent à l'AccessKey ID et à l'AccessKey Secret utilisés pour accéder au bucket OSS.

      4. Créez un Dataset et un JindoRuntime.

         apiVersion: data.fluid.io/v1alpha1
         kind: Dataset
         metadata:
           name: deepseek
         spec:
           mounts:
             - mountPoint:  oss://<your-bucket-name>       # Replace <your-bucket-name> with the actual value.
               options:
                 fs.oss.endpoint: <your-bucket-endpoint>    # Replace <your-bucket-endpoint> with the actual value.
               name: deepseek
               path: "/"
               encryptOptions:
                 - name: fs.oss.accessKeyId
                   valueFrom:
                     secretKeyRef:
                       name: mysecret
                       key: fs.oss.accessKeyId
                 - name: fs.oss.accessKeySecret
                   valueFrom:
                     secretKeyRef:
                       name: mysecret
                       key: fs.oss.accessKeySecret
         ---
         apiVersion: data.fluid.io/v1alpha1
         kind: JindoRuntime
         metadata:
           name: deepseek
         spec:
           replicas: 16    # Adjust as needed.
           master:
             podMetadata:
               labels:
                 alibabacloud.com/compute-class: performance
                 alibabacloud.com/compute-qos: default
           worker:
             podMetadata:
               labels:
                 alibabacloud.com/compute-class: performance
                 alibabacloud.com/compute-qos: default
               annotations:
                 kubernetes.io/resource-type: serverless
             resources:
               requests:
                 cpu: 16
                 memory: 128Gi
               limits:
                 cpu: 16
                 memory: 128Gi
           tieredstore:
             levels:
               - mediumtype: MEM
                 path: /dev/shm
                 volumeType: emptyDir
                 ## Adjust as needed.
                 quota: 128Gi
                 high: "0.99"
                 low: "0.95"

         Après la création des ressources, exécutez la commande kubectl get pod | grep jindo pour vérifier si les pods sont dans l'état Running. Résultat attendu :

         deepseek-jindofs-master-0    1/1     Running   0          3m29s
         deepseek-jindofs-worker-0    1/1     Running   0          2m52s
         deepseek-jindofs-worker-1    1/1     Running   0          2m52s
         ...

      5. Mettez le modèle en cache en créant un DataLoad.

         apiVersion: data.fluid.io/v1alpha1
         kind: DataLoad
         metadata:
           name: deepseek
         spec:
           dataset:
             name: deepseek
             namespace: default
           loadMetadata: true

      6. Exécutez la commande suivante pour vérifier l'état du cache.

         kubectl get dataload

         Résultat attendu :

         NAME       DATASET    PHASE       AGE     DURATION
         deepseek   deepseek   Executing   4m30s   Unfinished

         Une valeur PHASE définie à Executing indique que le processus est en cours. Patientez environ 20 minutes, puis exécutez à nouveau la commande. Si l'état passe à Complete, la mise en cache a réussi. Utilisez la commande kubectl logs $(kubectl get pods --selector=job-name=deepseek-loader-job -o jsonpath='{.items[0].metadata.name}') | grep progress pour obtenir le nom du job et consulter les journaux afin de suivre la progression.

         Paramètres de la ressource Fluid DataLoad

         Paramètre	Description	Valeur d'exemple
         Name	Nom de la tâche de chargement des données.	deepseek
         Dataset	Nom du jeu de données associé.	deepseek
         Phase	État de la tâche de chargement des données (par exemple, Complete signifie terminé).	Executing, Complete
         Age	Temps écoulé depuis la création de la tâche de chargement des données.	4m30s
         Duration	Durée de la tâche de chargement des données.	Unfinished, 16m29s

      7. Exécutez la commande suivante pour vérifier la ressource Dataset.

         kubectl get datasets

         Résultat attendu :

         NAME       UFS TOTAL SIZE   CACHED    CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
         deepseek   1.25TiB          1.25TiB   2.00TiB          100.0%              Bound   21h

         Paramètres de la ressource Fluid Dataset

         Paramètre	Description	Valeur d'exemple
         Name	Nom du jeu de données.	deepseek
         UFS Total Size	Taille totale du jeu de données dans le stockage sous-jacent.	1.25TiB
         Cached	Quantité de données actuellement mises en cache.	1.25TiB
         Cache Capacity	Capacité totale du cache.	2.00TiB
         Cached %	Pourcentage de données mises en cache.	100.0%
         Phase	État du jeu de données (par exemple, Bound indique qu'il est lié).	Bound
         Age	Temps écoulé depuis la création de la ressource de jeu de données.	21h

Étape 2 : Déployer le modèle à l'aide de la puissance de calcul GPU ACS

1. Dans la place de marché d'applications ACS, installez le composant lws à l'aide de Helm. Pour plus d'informations, consultez Utiliser Helm pour créer une application.

2. Déployez le modèle à l'aide d'un LeaderWorkerSet.

   Remarque

   • Remplacez alibabacloud.com/gpu-model-series: <example-model> dans le fichier YAML par un modèle GPU spécifique pris en charge par ACS. Pour obtenir la liste des modèles GPU actuellement pris en charge, contactez votre gestionnaire de compte ou soumettez un ticket.

   • Contrairement au TCP/IP, le réseau RDMA haute performance utilise la copie zéro et le contournement du noyau pour éviter la copie de données et les changements de contexte fréquents. Ces fonctionnalités entraînent une latence réduite, un débit accru et une utilisation moindre du CPU. ACS prend en charge l'utilisation du RDMA via la configuration du libellé alibabacloud.com/hpn-type: "rdma" dans le fichier YAML. Pour obtenir la liste des modèles GPU prenant en charge le RDMA, contactez votre gestionnaire de compte ou soumettez un ticket.

   • Si vous utilisez Fluid pour charger le modèle, modifiez le claimName des deux PVC pour qu'il corresponde au nom du Dataset Fluid.

   • Les différentes architectures de déploiement distribué affectent les valeurs de variables telles que tensor-parallel-size et LWS_GROUP_SIZE dans le fichier YAML.

   Déploiement standard

   apiVersion: leaderworkerset.x-k8s.io/v1
   kind: LeaderWorkerSet
   metadata:
     name: deepseek-r1-671b-fp8-distrubution
   spec:
     replicas: 1
     leaderWorkerTemplate:
       size: 2 # The total number of leaders and workers.
       restartPolicy: RecreateGroupOnPodRestart
       leaderTemplate:
         metadata:
           labels: 
             role: leader
             alibabacloud.com/compute-class: gpu  # Specify the GPU type.
             alibabacloud.com/compute-qos: default # Specify the ACS QoS level.
             alibabacloud.com/gpu-model-series: <example-model> ## Specify the GPU model.
         spec:
           volumes:
             - name: llm-model
               persistentVolumeClaim:
                 ## If you use Fluid, enter the Fluid dataset name here, for example: deepseek
                 claimName: llm-model
             - name: shm
               emptyDir:
                 medium: Memory
                 sizeLimit: 32Gi
           containers:
             - name: deepseek-r1-671b-leader
               image: registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/vllm:v0.7.2
               env:
                 - name: NCCL_SOCKET_IFNAME # Specify the network interface card.
                   value: eth0
               command:
                 - sh
                 - -c
                 - "/vllm-workspace/ray_init.sh leader --ray_cluster_size=$(LWS_GROUP_SIZE);vllm serve /models/DeepSeek-R1/ --port 8000 --trust-remote-code --served-model-name ds --max-model-len 2048 --gpu-memory-utilization 0.95 --tensor-parallel-size 8 --pipeline-parallel-size 2 --enforce-eager"
   # Set tensor-parallel-size to the total number of cards in each leader and worker pod.
               resources:
                 limits:
                   nvidia.com/gpu: "8"
                   cpu: "64"
                   memory: 512G
                 requests:
                   nvidia.com/gpu: "8"
                   cpu: "64"
                   memory: 512G           
               ports:
                 - containerPort: 8000
               volumeMounts:
                 - mountPath: /models/DeepSeek-R1
                   name: llm-model
                 - mountPath: /dev/shm
                   name: shm
       workerTemplate:
         metadata:
           labels: 
             alibabacloud.com/compute-class: gpu  # Specify the GPU type.
             alibabacloud.com/compute-qos: default # Specify the ACS QoS level.
             alibabacloud.com/gpu-model-series: <example-model> ## Specify the GPU model.
         spec:
           volumes:
             - name: llm-model
               persistentVolumeClaim:
                 ## If you use Fluid, enter the Fluid dataset name here, for example: deepseek
                 claimName: llm-model
             - name: shm
               emptyDir:
                 medium: Memory
                 sizeLimit: 32Gi
           containers:
             - name: deepseek-r1-671b-worker
               image: registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/vllm:v0.7.2
               env:
                 - name: NCCL_SOCKET_IFNAME # Specify the network interface card.
                   value: eth0
               command:
                 - sh
                 - -c
                 - "/vllm-workspace/ray_init.sh worker --ray_address=$(LWS_LEADER_ADDRESS)"
               resources:
                 limits:
                   nvidia.com/gpu: "8"
                   cpu: "64"
                   memory: 512G
                 requests:
                   nvidia.com/gpu: "8"
                   cpu: "64"
                   memory: 512G
               ports:
                 - containerPort: 8000
               volumeMounts:
                 - mountPath: /models/DeepSeek-R1
                   name: llm-model
                 - mountPath: /dev/shm
                   name: shm

   Accélération RDMA

   Lors de l'utilisation d'une image de base open source (telle que vLLM), ajoutez les variables d'environnement suivantes au fichier YAML :

   Nom	Valeur
   NCCL_SOCKET_IFNAME	eth0
   NCCL_IB_TC	136
   NCCL_IB_SL	5
   NCCL_IB_GID_INDEX	3
   NCCL_DEBUG	INFO
   NCCL_IB_HCA	mlx5
   NCCL_NET_PLUGIN	none

   apiVersion: leaderworkerset.x-k8s.io/v1
   kind: LeaderWorkerSet
   metadata:
     name: deepseek-r1-671b-fp8-distrubution
   spec:
     replicas: 1
     leaderWorkerTemplate:
       size: 2 # The total number of leaders and workers.
       restartPolicy: RecreateGroupOnPodRestart
       leaderTemplate:
         metadata:
           labels: 
             role: leader
             alibabacloud.com/compute-class: gpu  # Specify the GPU type.
             alibabacloud.com/compute-qos: default # Specify the ACS QoS level.
             alibabacloud.com/gpu-model-series: <example-model> ## Specify the GPU model.
             # Specify that the application runs in a high-performance RDMA network. Submit a ticket for a list of supported GPU models.
             alibabacloud.com/hpn-type: "rdma"
         spec:
           volumes:
             - name: llm-model
               persistentVolumeClaim:
                 ## If you use Fluid, enter the Fluid dataset name here, for example: deepseek
                 claimName: llm-model
             - name: shm
               emptyDir:
                 medium: Memory
                 sizeLimit: 32Gi
           containers:
             - name: deepseek-r1-671b-leader
               image: registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/vllm:v0.7.2
               env:
                 - name: NCCL_SOCKET_IFNAME # Specify the network interface card.
                   value: eth0
                 - name: NCCL_IB_TC
                   value: "136"
                 - name: NCCL_IB_SL
                   value: "5"
                 - name: NCCL_IB_GID_INDEX
                   value: "3"
                 - name: NCCL_DEBUG
                   value: "INFO"
                 - name: NCCL_IB_HCA
                   value: "mlx5"
                 - name: NCCL_NET_PLUGIN
                   value: "none"                
               command:
                 - sh
                 - -c
                 - "/vllm-workspace/ray_init.sh leader --ray_cluster_size=$(LWS_GROUP_SIZE);vllm serve /models/DeepSeek-R1/ --port 8000 --trust-remote-code --served-model-name ds --max-model-len 2048 --gpu-memory-utilization 0.95 --tensor-parallel-size 8 --pipeline-parallel-size 2 --enforce-eager"
   # Set tensor-parallel-size to the total number of cards in each leader and worker pod.
               resources:
                 limits:
                   nvidia.com/gpu: "8"
                   cpu: "64"
                   memory: 512G
                 requests:
                   nvidia.com/gpu: "8"
                   cpu: "64"
                   memory: 512G           
               ports:
                 - containerPort: 8000
               volumeMounts:
                 - mountPath: /models/DeepSeek-R1
                   name: llm-model
                 - mountPath: /dev/shm
                   name: shm
       workerTemplate:
         metadata:
           labels: 
             alibabacloud.com/compute-class: gpu  # Specify the GPU type.
             alibabacloud.com/compute-qos: default # Specify the ACS QoS level.
             alibabacloud.com/gpu-model-series: <example-model> ## Specify the GPU model.
             # Specify that the application runs in a high-performance RDMA network. Submit a ticket for a list of supported GPU models.
             alibabacloud.com/hpn-type: "rdma"
         spec:
           volumes:
             - name: llm-model
               persistentVolumeClaim:
                 ## If you use Fluid, enter the Fluid dataset name here, for example: deepseek
                 claimName: llm-model
             - name: shm
               emptyDir:
                 medium: Memory
                 sizeLimit: 32Gi
           containers:
             - name: deepseek-r1-671b-worker
               image: registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/vllm:v0.7.2
               env:
                 - name: NCCL_SOCKET_IFNAME # Specify the network interface card.
                   value: eth0
                 - name: NCCL_IB_TC
                   value: "136"
                 - name: NCCL_IB_SL
                   value: "5"
                 - name: NCCL_IB_GID_INDEX
                   value: "3"
                 - name: NCCL_DEBUG
                   value: "INFO"
                 - name: NCCL_IB_HCA
                   value: "mlx5"
                 - name: NCCL_NET_PLUGIN
                   value: "none"      
               command:
                 - sh
                 - -c
                 - "/vllm-workspace/ray_init.sh worker --ray_address=$(LWS_LEADER_ADDRESS)"
               resources:
                 limits:
                   nvidia.com/gpu: "8"
                   cpu: "64"
                   memory: 512G
                 requests:
                   nvidia.com/gpu: "8"
                   cpu: "64"
                   memory: 512G
               ports:
                 - containerPort: 8000
               volumeMounts:
                 - mountPath: /models/DeepSeek-R1
                   name: llm-model
                 - mountPath: /dev/shm
                   name: shm

3. Exposez le service d'inférence à l'aide d'un Service.

   apiVersion: v1
   kind: Service
   metadata:
     name: ds-leader
   spec:
     ports:
       - name: http
         port: 8000
         protocol: TCP
         targetPort: 8000
     selector:
       leaderworkerset.sigs.k8s.io/name: deepseek-r1-671b-fp8-distrubution
       role: leader
     type: ClusterIP

Étape 3 : Vérifier le service d'inférence

1. Utilisez kubectl port-forward pour établir une redirection de port entre le service d'inférence et votre environnement local.

   Remarque

   La redirection de port établie par kubectl port-forward ne convient pas à la production en raison de son manque de fiabilité, de sécurité et d'évolutivité. Réservez-la donc uniquement au développement et au débogage. Pour plus d'informations sur les solutions réseau prêtes pour la production dans les clusters Kubernetes, consultez Gestion des Ingress.

   kubectl port-forward svc/ds-leader 8000:8000

   Résultat attendu :

   Forwarding from 127.0.0.1:8000 -> 8000
   Forwarding from [::1]:8000 -> 8000

2. Envoyez une requête d'inférence au modèle.

   curl http://localhost:8000/v1/chat/completions \
     -H "Content-Type: application/json" \
     -d '{
       "model": "ds",
       "messages": [
         {
           "role": "system", 
           "content": "You are a friendly AI assistant."
         },
         {
           "role": "user",
           "content": "Tell me about deep learning."
         }
       ],
       "max_tokens": 1024,
       "temperature": 0.7,
       "top_p": 0.9,
       "seed": 10
     }'

   Résultat attendu :

   {"id":"chatcmpl-4bc78b66e2a4439f8362bd434a60be57","object":"chat.completion","created":1739501401,"model":"ds","choices":[{"index":0,"message":{"role":"assistant","reasoning_content":null,"content":"Okay, the user wants me to explain deep learning. I need to think about how to answer this well. First, I need to clarify the basic definition of deep learning. It's a branch of machine learning, right? Then I should compare it with traditional machine learning methods to explain its advantages, such as automatic feature extraction. I might need to mention neural networks, especially the structure of deep neural networks with multiple hidden layers.\n\nNext, I should talk about the core components of deep learning, such as activation functions, loss functions, and optimizers. The user might not be familiar with these terms, so I should briefly explain the role of each part. For example, ReLU as an activation function, Adam as an optimizer, and examples like the cross-entropy loss function.\n\nThen, for application areas, computer vision and natural language processing are common. I should provide some practical examples like image recognition and machine translation to make it easier for the user to understand. For industry applications, like healthcare and finance, the user might be interested in these real-world use cases.\n\nI also need to mention popular frameworks like TensorFlow and PyTorch, which make deep learning easier to implement. The importance of hardware acceleration, such as GPUs, is also key to explaining why deep learning is advancing so quickly.\n\nI should also discuss the challenges and limitations of deep learning, such as data dependency, high computational resource requirements, and poor interpretability. This will give the user a balanced view of its pros and cons. I might also mention future development directions, like efficient training algorithms and research into interpretability.\n\nThe user probably wants to understand the basic concepts of deep learning. They might have some technical background but not in-depth knowledge. They likely want to quickly grasp the key points and applications, so the answer needs to be well-structured and focused, without getting too deep into technical details but also not being too brief. I need to balance professionalism with ease of understanding.\n\nI should avoid using too much jargon, or explain terms when I use them, such as 'neural network' or 'convolutional neural network'. The user could be a student or a newcomer to the field, so I should use plain language. I should also use examples to connect the concepts to real-world applications to make them more memorable.\n\nI also need to be clear about the relationship between deep learning and machine learning, explaining that deep learning is a subset of machine learning but operates at a deeper level to handle more complex problems. I might also mention the backpropagation algorithm as one of the key training techniques.\n\nFinally, I'll provide a summary that emphasizes the impact and potential of deep learning and its future directions. This will give the user a comprehensive understanding. I'll double-check if I've missed any important points, like common model architectures such as CNNs and RNNs, which I should briefly mention to show the diversity.\n\nSometimes users are interested in the principles, but it's better to keep it concise here, focusing on an overview rather than in-depth technical details. I need to ensure the answer flows logically, starting from the definition, then moving to core components, applications, frameworks, challenges, and future directions. That structure seems reasonable.\n</think>\n\nDeep learning is a branch of machine learning that aims to simulate the human brain's learning process by building multi-layer neural networks (known as 'deep' networks). By automatically learning complex features and patterns from large amounts of data, it is widely used in fields such as image recognition, speech processing, and natural language processing.\n\n### Core concepts\n1. **Artificial Neural Network (ANN)**:\n   - Consists of an input layer, multiple hidden layers, and an output layer, with each layer containing multiple neurons.\n   - Processes information by simulating the activation and transmission of signals between neurons.\n\n2. **Automatic feature extraction**:\n   - Traditional machine learning relies on manually designed features. Deep learning, through its multi-layer networks, automatically extracts abstract features from data, such as edges and shapes from pixels in an image.\n\n3. **Key components**:\n   - **Activation function** (such as ReLU, Sigmoid): Introduces non-linearity, enhancing the model's expressive power.\n   - **Loss function** (such as cross-entropy, mean squared error): Measures the difference between the predicted output and the actual value.\n   - **Optimizer** (such as SGD, Adam): Optimizes the network's parameters through backward propagation to minimize the loss.\n\n---\n\n### Typical models\n- **Convolutional Neural Network (CNN)**:  \n  Designed specifically for images, it uses convolutional kernels to extract spatial features. Classic models include ResNet and VGG.\n- **Recurrent Neural Network (RNN)**:  \n  Processes sequential data like text and speech by introducing a memory mechanism. Improved versions include LSTM and GRU.\n- **Transformer**:  \n  Based on a self-attention mechanism, it has significantly improved performance in natural language processing tasks. Examples include the BERT and GPT series.\n\n---\n\n### Application scenarios\n- **Computer vision**: Facial recognition, medical imaging analysis (such as detecting lesions in lung CT scans).\n- **Natural language processing**: Intelligent chatbots, document summary generation, and translation (such as DeepL).\n- **Speech technology**: Voice assistants (such as Siri) and real-time caption generation.\n- **Reinforcement learning**: Game AI (AlphaGo) and robot control.\n\n---\n\n### Advantages and challenges\n- **Advantages**:\n  - Automatically learns complex features, reducing the need for manual intervention.\n  - Far outperforms traditional methods when given large amounts of data and high computing power.\n- **Challenges**:\n  - Relies on massive amounts of labeled data (for example, tens of thousands of labeled medical images).\n  - High model training costs (for example, training GPT-3 cost over ten million USD).\n  - Its 'black box' nature leads to poor interpretability, limiting its application in high-risk fields like medicine.\n\n---\n\n### Tools and trends\n- **Mainstream frameworks**: TensorFlow (friendly for industrial deployment) and PyTorch (preferred for research).\n- **Research directions**:\n  - Lightweight models (such as MobileNet for mobile devices).\n  - Self-supervised learning (to reduce dependency on labeled data).\n  - Enhanced interpretability (such as visualizing the model's decision-making basis).\n\nDeep learning is pushing the boundaries of artificial intelligence. From generative AI (such as Stable Diffusion generating images) to autonomous driving, it continues to transform the technology ecosystem. Future developments may bring breakthroughs in reducing computational costs, improving efficiency, and enhancing interpretability.","tool_calls":[]},"logprobs":null,"finish_reason":"stop","stop_reason":null}],"usage":{"prompt_tokens":17,"total_tokens":1131,"completion_tokens":1114,"prompt_tokens_details":null},"prompt_logprobs":null}

   Paramètres du modèle

   Cette rubrique décrit uniquement les paramètres utilisés pour la vérification. Pour plus de paramètres, consultez la documentation de l'API DeepSeek.

   Paramètre	Description	Valeur d'exemple
   model	Modèle à utiliser.	ds
   messages	Liste de messages formant la conversation. role : Rôle de l'initiateur du message. content : Contenu du message.	-
   max_tokens	Nombre maximal de tokens que le modèle peut générer en une seule requête. Plage : 1 à 8192. Valeur par défaut : 4096 (si non spécifié).	1024
   temperature	Température d'échantillonnage. Une valeur élevée (comme 1) rend la sortie plus aléatoire, tandis qu'une valeur faible (comme 0,2) la rend plus focalisée et déterministe. Valeur : comprise entre 0 et 2.	0,7