GPU推断 - AWS 深度学习 Containers
ApacheMXNet（孵化中）推断 GPUTensorFlow GPU推断PyTorch GPU推断

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

GPU推断

本节介绍如何使用 ApacheMXNet（孵化）、、和 2 对集EKSGPU群的 Deep Learning Containers 运行推理。 PyTorch TensorFlow TensorFlow

有关深度学习容器的完整列表，请参阅可用的深度学习容器映像。

注意

MKL用户：阅读AWS Deep Learning Containers 英特尔数学内核库 (MKL) 建议以获得最佳的训练或推理性能。

ApacheMXNet（孵化中）推断 GPU

在此方法中，创建一个 Kubernetes 服务和部署。Kubernetes 服务公开了一个进程及其端口。在创建 Kubernetes 服务时，您可以指定要使用的服务类型。ServiceTypes默认 ServiceType 为 ClusterIP。部署负责确保一定数量的 pod 始终处于启动和运行状态。

  1. 要进行 GPU-base 推断，请安装适用于 Kubernet NVIDIA es 的设备插件：

    $ kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v1.12/nvidia-device-plugin.yml

  2. 确认运行 nvidia-device-plugin-daemonset 正常。

    $ kubectl get daemonset -n kube-system

    该输出值将类似于以下内容：

    NAME                             DESIRED   CURRENT   READY     UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
aws-node                         3         3         3         3            3           <none>          6d
kube-proxy                       3         3         3         3            3           <none>          6d
nvidia-device-plugin-daemonset   3         3         3         3            3           <none>          57s

  3. 创建命名空间。您可能需要更改 kubeconfig 以指向正确的集群。确认您已设置了 “training-gpu-1” 或将其更改为集群的配置。GPU有关设置集群的更多信息，请参阅亚马逊EKS设置。

    $ NAMESPACE=mx-inference; kubectl —kubeconfig=/home/ubuntu/.kube/eksctl/clusters/training-gpu-1 create namespace ${NAMESPACE}

  4. （使用公共模型时的可选步骤。） 在可装载的网络位置（如 S3）处设置您的模型。请参阅使用推理一节中提及的将经过训练的模型上传到 S3 的步骤。 TensorFlow将密钥应用于您的命名空间。有关密钥的更多信息，请参阅 Kubernetes 密钥文档。

    $ kubectl -n ${NAMESPACE} apply -f secret.yaml

  5. 创建 mx_inference.yaml 文件。使用下一个代码块的内容作为其内容。

    ---
kind: Service
apiVersion: v1
metadata:
  name: squeezenet-service
  labels:
    app: squeezenet-service
spec:
  ports:
  - port: 8080
    targetPort: mms
  selector:
    app: squeezenet-service
---
kind: Deployment
apiVersion: apps/v1
metadata:
  name: squeezenet-service
  labels:
    app: squeezenet-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: squeezenet-service
  template:
    metadata:
      labels:
        app: squeezenet-service
    spec:
      containers:
      - name: squeezenet-service
        image: 763104351884.dkr.ecr.us-east-1.amazonaws.com/mxnet-inference:1.6.0-gpu-py36-cu101-ubuntu16.04
        args:
        - mxnet-model-server
        - --start
        - --mms-config /home/model-server/config.properties
        - --models squeezenet=https://s3.amazonaws.com/model-server/model_archive_1.0/squeezenet_v1.1.mar
        ports:
        - name: mms
          containerPort: 8080
        - name: mms-management
          containerPort: 8081
        imagePullPolicy: IfNotPresent
        resources:
          limits:
            cpu: 4
            memory: 4Gi
            nvidia.com/gpu: 1
          requests:
            cpu: "1"
            memory: 1Gi

  6. 将配置应用于之前定义的命名空间中的新 pod：

    $ kubectl -n ${NAMESPACE} apply -f mx_inference.yaml

    您的输出应类似于以下内容：

    service/squeezenet-service created
deployment.apps/squeezenet-service created

  7. 检查 Pod 的状态并等待 pod 处于 “RUNNING” 状态：

    $ kubectl get pods -n ${NAMESPACE}

  8. 重复检查状态步骤，直到看到以下 “RUNNING” 状态：

    NAME                     READY     STATUS    RESTARTS   AGE
squeezenet-service-xvw1  1/1       Running   0          3m

  9. 要进一步描述 pod，您可以运行：

    $ kubectl describe pod <pod_name> -n ${NAMESPACE}

  10. 由于 serviceType 这里是 ClusterIP，因此您可以将端口从容器转发到主机（& 符号在后台运行）：

    $ kubectl port-forward -n ${NAMESPACE} `kubectl get pods -n ${NAMESPACE} --selector=app=squeezenet-service -o jsonpath='{.items[0].metadata.name}'` 8080:8080 &

  11. 下载小猫的图像：

    $ curl -O https://s3.amazonaws.com/model-server/inputs/kitten.jpg

  12. 在该模型上运行推理：

    $ curl -X POST http://127.0.0.1:8080/predictions/squeezenet -T kitten.jpg

TensorFlow GPU推断

在此方法中，创建一个 Kubernetes 服务和部署。Kubernetes 服务公开了一个进程及其端口。在创建 Kubernetes 服务时，您可以指定要使用的服务类型。ServiceTypes默认 ServiceType 为 ClusterIP。部署负责确保一定数量的 pod 始终处于启动和运行状态。

  1. 要进行 GPU-base 推断，请安装适用于 Kubernet NVIDIA es 的设备插件：

    $ kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v1.12/nvidia-device-plugin.yml

  2. 确认运行 nvidia-device-plugin-daemonset 正常。

    $ kubectl get daemonset -n kube-system

    该输出值将类似于以下内容：

    NAME                             DESIRED   CURRENT   READY     UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
aws-node                         3         3         3         3            3           <none>          6d
kube-proxy                       3         3         3         3            3           <none>          6d
nvidia-device-plugin-daemonset   3         3         3         3            3           <none>          57s

  3. 创建命名空间。您可能需要更改 kubeconfig 以指向正确的集群。确认您已设置了 “training-gpu-1” 或将其更改为集群的配置。GPU有关设置集群的更多信息，请参阅亚马逊EKS设置。

    $ NAMESPACE=tf-inference; kubectl —kubeconfig=/home/ubuntu/.kube/eksctl/clusters/training-gpu-1 create namespace ${NAMESPACE}

  4. 用于推理的模型可通过不同的方式进行检索，例如，使用共享卷、S3 等。由于该服务需要访问 S3 和ECR，因此您必须将 AWS 凭证存储为 Kubernetes 密钥。在本示例中，您将使用 S3 来存储和提取训练后的模型。

    检查您的 AWS 凭证。这些凭证必须具有 S3 写入访问权限。

    $ cat ~/.aws/credentials

  5. 输出将类似于以下内容：

    $ [default]
aws_access_key_id = FAKEAWSACCESSKEYID
aws_secret_access_key = FAKEAWSSECRETACCESSKEY

  6. 使用 base64 对这些凭证进行编码。首先编码访问密钥。

    $ echo -n 'FAKEAWSACCESSKEYID' | base64

    接下来编码秘密访问密钥。

    $ echo -n 'FAKEAWSSECRETACCESSKEYID' | base64

    您的输出应类似于以下内容：

    $ echo -n 'FAKEAWSACCESSKEYID' | base64
RkFLRUFXU0FDQ0VTU0tFWUlE
$ echo -n 'FAKEAWSSECRETACCESSKEY' | base64
RkFLRUFXU1NFQ1JFVEFDQ0VTU0tFWQ==

  7. 创建 yaml 文件来存储密钥。在您的主目录中将该密钥另存为 secret.yaml。

    apiVersion: v1
kind: Secret
metadata:
  name: aws-s3-secret
type: Opaque
data:
  AWS_ACCESS_KEY_ID: RkFLRUFXU0FDQ0VTU0tFWUlE
  AWS_SECRET_ACCESS_KEY: RkFLRUFXU1NFQ1JFVEFDQ0VTU0tFWQ==

  8. 将密钥应用于您的命名空间：

    $ kubectl -n ${NAMESPACE} apply -f secret.yaml

  9. 在本示例中，您将克隆 tensorflow-serving 存储库并将预训练模型同步到 S3 存储桶。以下示例命名存储桶 tensorflow-serving-models。它还将已保存的模型同步到名 saved_model_half_plus_two_gpu 的 S3 存储桶。

    $ git clone https://github.com/tensorflow/serving/
$ cd serving/tensorflow_serving/servables/tensorflow/testdata/

  10. 同步CPU模型。

    $ aws s3 sync saved_model_half_plus_two_gpu s3://<your_s3_bucket>/saved_model_half_plus_two_gpu

  11. 创建 tf_inference.yaml 文件。使用下一个代码块的内容作为其内容，并将 --model_base_path 更新为使用您的 S3 存储桶。你可以将其与 TensorFlow 或 TensorFlow 2 一起使用。要将其与 TensorFlow 2 一起使用，请将 Docker 镜像更改为 TensorFlow 2 镜像。

    ---
  kind: Service
  apiVersion: v1
  metadata:
    name: half-plus-two
    labels:
      app: half-plus-two
  spec:
    ports:
    - name: http-tf-serving
      port: 8500
      targetPort: 8500
    - name: grpc-tf-serving
      port: 9000
      targetPort: 9000
    selector:
      app: half-plus-two
      role: master
    type: ClusterIP
---
  kind: Deployment
  apiVersion: apps/v1
  metadata:
    name: half-plus-two
    labels:
      app: half-plus-two
      role: master
  spec:
    replicas: 1
    selector:
      matchLabels:
        app: half-plus-two
        role: master
    template:
      metadata:
        labels:
          app: half-plus-two
          role: master
      spec:
        containers:
        - name: half-plus-two
          image: 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference:1.15.0-gpu-py36-cu100-ubuntu18.04
          command:
          - /usr/bin/tensorflow_model_server
          args:
          - --port=9000
          - --rest_api_port=8500
          - --model_name=saved_model_half_plus_two_gpu
          - --model_base_path=s3://tensorflow-trained-models/saved_model_half_plus_two_gpu
          ports:
          - containerPort: 8500
          - containerPort: 9000
          imagePullPolicy: IfNotPresent
          env:
          - name: AWS_ACCESS_KEY_ID
            valueFrom:
              secretKeyRef:
                key: AWS_ACCESS_KEY_ID
                name: aws-s3-secret
          - name: AWS_SECRET_ACCESS_KEY
            valueFrom:
              secretKeyRef:
                key: AWS_SECRET_ACCESS_KEY
                name: aws-s3-secret
          - name: AWS_REGION
            value: us-east-1
          - name: S3_USE_HTTPS
            value: "true"
          - name: S3_VERIFY_SSL
            value: "true"
          - name: S3_ENDPOINT
            value: s3.us-east-1.amazonaws.com
            resources:
              limits:
                cpu: 4
                memory: 4Gi
                nvidia.com/gpu: 1
              requests:
                cpu: "1"
                memory: 1Gi

  12. 将配置应用于之前定义的命名空间中的新 pod：

    $ kubectl -n ${NAMESPACE} apply -f tf_inference.yaml

    您的输出应类似于以下内容：

    service/half-plus-two created
deployment.apps/half-plus-two created

  13. 检查 Pod 的状态并等待 pod 处于 “RUNNING” 状态：

    $ kubectl get pods -n ${NAMESPACE}

  14. 重复检查状态步骤，直到看到以下 “RUNNING” 状态：

    NAME                     READY     STATUS    RESTARTS   AGE
half-plus-two-vmwp9  1/1       Running   0          3m

  15. 要进一步描述 pod，您可以运行：

    $ kubectl describe pod <pod_name> -n ${NAMESPACE}

  16. 由于 serviceType 这里是 ClusterIP，因此您可以将端口从容器转发到主机（& 符号在后台运行）：

    $ kubectl port-forward -n ${NAMESPACE} `kubectl get pods -n ${NAMESPACE} --selector=app=half-plus-two -o jsonpath='{.items[0].metadata.name}'` 8500:8500 &

  17. 将以下 json 字符串置于名为 half_plus_two_input.json 的文件中

    {"instances": [1.0, 2.0, 5.0]}

  18. 在该模型上运行推理：

    $ curl -d @half_plus_two_input.json -X POST http://localhost:8500/v1/models/saved_model_half_plus_two_cpu:predict

    预期的输出如下所示：

    {
    "predictions": [2.5, 3.0, 4.5
    ]
}

PyTorch GPU推断

在此方法中，创建一个 Kubernetes 服务和部署。Kubernetes 服务公开了一个进程及其端口。在创建 Kubernetes 服务时，您可以指定要使用的服务类型。ServiceTypes默认 ServiceType 为 ClusterIP。部署负责确保一定数量的 pod 始终处于启动和运行状态。

  1. 要进行 GPU-base 推断，请安装适用于 Kubernet NVIDIA es 的设备插件。

    $ kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v1.12/nvidia-device-plugin.yml

  2. 确认运行 nvidia-device-plugin-daemonset 正常。

    $ kubectl get daemonset -n kube-system

    该输出值将类似于以下内容。

    NAME                             DESIRED   CURRENT   READY     UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
aws-node                         3         3         3         3            3           <none>          6d
kube-proxy                       3         3         3         3            3           <none>          6d
nvidia-device-plugin-daemonset   3         3         3         3            3           <none>          57s

  3. 创建命名空间。

    $ NAMESPACE=pt-inference; kubectl create namespace ${NAMESPACE}

  4. （使用公共模型时的可选步骤。） 在可装载的网络位置（如 S3）处设置您的模型。请参阅使用推理一节中提及的将经过训练的模型上传到 S3 的步骤。 TensorFlow将密钥应用于您的命名空间。有关密钥的更多信息，请参阅 Kubernetes 密钥文档。

    $ kubectl -n ${NAMESPACE} apply -f secret.yaml

  5. 创建 pt_inference.yaml 文件。使用下一个代码块的内容作为其内容。

    ---
kind: Service
apiVersion: v1
metadata:
  name: densenet-service
  labels:
    app: densenet-service
spec:
  ports:
  - port: 8080
    targetPort: mms
  selector:
    app: densenet-service
---
kind: Deployment
apiVersion: apps/v1
metadata:
  name: densenet-service
  labels:
    app: densenet-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: densenet-service
  template:
    metadata:
      labels:
        app: densenet-service
    spec:
      containers:
      - name: densenet-service
        image: "763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-inference:1.3.1-gpu-py36-cu101-ubuntu16.04"
        args:
        - mxnet-model-server
        - --start
        - --mms-config /home/model-server/config.properties
        - --models densenet=https://dlc-samples.s3.amazonaws.com/pytorch/multi-model-server/densenet/densenet.mar
        ports:
        - name: mms
          containerPort: 8080
        - name: mms-management
          containerPort: 8081
        imagePullPolicy: IfNotPresent
        resources:
          limits:
            cpu: 4
            memory: 4Gi
            nvidia.com/gpu: 1
          requests:
            cpu: "1"
            memory: 1Gi

  6. 将配置应用于之前定义的命名空间中的新 pod。

    $ kubectl -n ${NAMESPACE} apply -f pt_inference.yaml

    您的输出应类似于以下内容：

    service/densenet-service created
deployment.apps/densenet-service created

  7. 检查 Pod 的状态并等待 pod 处于 “RUNNING” 状态。

    $ kubectl get pods -n ${NAMESPACE}

    您的输出应类似于以下内容：

    NAME                     READY     STATUS    RESTARTS   AGE
densenet-service-xvw1    1/1       Running   0          3m

  8. 要进一步描述 pod，您可以运行：

    $ kubectl describe pod <pod_name> -n ${NAMESPACE}

  9. 由于 serviceType 这里是 ClusterIP，因此您可以将端口从容器转发到主机（& 符号在后台运行）。

    $ kubectl port-forward -n ${NAMESPACE} `kubectl get pods -n ${NAMESPACE} --selector=app=densenet-service -o jsonpath='{.items[0].metadata.name}'` 8080:8080 &

  10. 在启动您的服务器后，现在您可以从不同的窗口来运行推理。

    $ curl -O https://s3.amazonaws.com/model-server/inputs/flower.jpg
curl -X POST http://127.0.0.1:8080/predictions/densenet -T flower.jpg

有关在使用完集群后对其进行清理的信息，请参阅清EKS理。

后续步骤

要了解如何在亚马逊上将自定义入口点与 Deep Learning Containers 配合使用EKS，请参阅。自定义入口点脚本