使用分布式工作负载

流程

1. 在终端窗口中，为您的工作创建一个目录，并更改到该目录。

2. 将 IMG 环境变量设置为自定义镜像的名称。在本节中的示例命令中，my_training_image 是自定义镜像的名称。

   export IMG=my_training_image

   Copy to Clipboard Toggle word wrap

3. 使用以下内容创建名为 Dockerfile 的文件：

   1. 使用 FROM 指令指定合适的基本培训镜像的位置。

      在以下命令中，将 _<base- training-image>_ 替换为您选择的基本培训镜像的名称：

      FROM quay.io/modh/<base-training-image>

      Copy to Clipboard Toggle word wrap

      示例：

      FROM quay.io/modh/ray:2.47.1-py311-cu121

      Copy to Clipboard Toggle word wrap

      FROM quay.io/modh/training:py311-rocm62-torch251

      Copy to Clipboard Toggle word wrap

   2. 使用 RUN 指令安装其他软件包。您还可以通过使用数字符号(#)为每个注释行添加注释到 Dockerfile。

      以下示例演示了如何安装 Python PyTorch 软件包的特定版本：

      # Install PyTorch
      RUN python3 -m pip install torch==2.5.1

      Copy to Clipboard Toggle word wrap

4. 构建 镜像文件。将 -t 选项与 podman build 命令一起使用，以创建指定自定义镜像名称和版本的镜像标签，以便更轻松地引用和管理镜像：

   podman build -t <custom-image-name>:_<version>_ -f Dockerfile

   Copy to Clipboard Toggle word wrap

   Example:

   podman build -t ${IMG}:0.0.1 -f Dockerfile

   Copy to Clipboard Toggle word wrap

   构建输出表示构建过程完成。

5. 显示镜像列表：

   podman images

   Copy to Clipboard Toggle word wrap

   如果成功创建了新镜像，则会将其包含在镜像列表中。

6. 将镜像推送到容器 registry 中：

   podman push ${IMG}:0.0.1

   Copy to Clipboard Toggle word wrap
7. 可选：使新镜像可供其他用户使用，如 将镜像推送到集成的 OpenShift 镜像 registry 中所述。

流程

1. 在一个终端窗口中，登录到 OpenShift CLI，如下例所示：

   $ oc login <openshift_cluster_url> -u <admin_username> -p <password>

   Copy to Clipboard Toggle word wrap

2. 将 IMG 环境变量设置为镜像的名称。在本节中的示例命令中，my_training_image 是镜像的名称。

   export IMG=my_training_image

   Copy to Clipboard Toggle word wrap

3. 登录到集成的镜像 registry：

   podman login -u $(oc whoami) -p $(oc whoami -t) $(oc registry info)

   Copy to Clipboard Toggle word wrap

4. 为集成镜像 registry 标记镜像：

   podman tag ${IMG} $(oc registry info)/$(oc project -q)/${IMG}

   Copy to Clipboard Toggle word wrap

5. 将镜像推送到集成的镜像 registry：

   podman push $(oc registry info)/$(oc project -q)/${IMG}

   Copy to Clipboard Toggle word wrap

6. 检索您想要的标签的镜像存储库位置：

   oc get is ${IMG} -o jsonpath='{.status.tags[?(@.tag=="<TAG>")].items[0].dockerImageReference}'

   Copy to Clipboard Toggle word wrap

   现在，任何用户都可以在 Ray 集群或培训工作的 image 参数中指定这个检索到的镜像位置值来使用您的镜像。

流程

1. 在 JupyterLab 界面中，点 File > New > Notebook。指定您首选的 Python 版本，然后点 Select。

   使用 .ipynb 文件扩展名创建一个新的 Jupyter 笔记本文件。

2. 在新笔记本的单元格中添加以下代码：

   下载演示 Jupyter 笔记本的代码

   from codeflare_sdk import copy_demo_nbs
   copy_demo_nbs()

   Copy to Clipboard Toggle word wrap

3. 选择单元，然后点 Run > Run selected cell。

   几秒钟后，copy_demo_nbs （） 函数复制与 CodeFlare SDK 当前安装版本的 demo Jupyter 笔记本，并将其克隆到 demo-notebooks 文件夹中。

4. 在左侧导航窗格中，右键单击新笔记本，再单击删除。
5. 单击 Delete 确认。

1. 在左侧导航窗格中，双击 demo-notebooks。
2. 双击 additional-demos，并验证 文件夹是否包含几个演示 Jupyter 笔记本。
3. 单击 demo-notebooks。
4. 双击 guided-demos，并验证 文件夹是否包含几个演示 Jupyter 笔记本。

流程

1. 检查您的集群管理员是否为 Ray 集群定义了 默认 本地队列。

   您可以使用 codeflare_sdk.list_local_queues （） 函数查看当前命名空间中的所有本地队列，以及与每个本地队列关联的资源类型。

   或者，您可以使用 OpenShift Web 控制台，如下所示：

   1. 在 OpenShift Web 控制台中，从 Project 列表中选择您的项目。

   2. 单击 Search，然后从 Resources 列表中选择 LocalQueue 以显示项目的本地队列列表。

      如果没有列出本地队列，请联络您的集群管理员。

   3. 查看每个本地队列的详情：

      1. 单击本地队列名称。

      2. 点 YAML 选项卡，并查看 metadata.annotations 部分。

         如果 kueue.x-k8s.io/default-queue 注解被设置为 'true'，则队列将配置为默认的本地队列。

         注意

         如果集群管理员没有定义默认的本地队列，则必须在每个 Jupyter 笔记本中指定本地队列。

2. 在 JupyterLab 界面中，打开 demo-notebooks > guided-demos 文件夹。

3. 通过双击每个 Jupyter 笔记本文件来打开所有 Jupyter 笔记本。

   Jupyter 笔记本文件具有 .ipynb 文件名扩展名。

4. 在每个 Jupyter 笔记本中，确保 导入 部分从 CodeFlare SDK 中导入所需的组件，如下所示：

   import 部分示例

   from codeflare_sdk import Cluster, ClusterConfiguration, TokenAuthentication

   Copy to Clipboard Toggle word wrap

5. 在每个 Jupyter 笔记本中，更新 TokenAuthentication 部分，以提供 令牌和 服务器 详情，以使用 CodeFlare SDK 向 OpenShift 集群进行身份验证。

   有关如何查找服务器和令牌详情的详情，请参考使用集群服务器和令牌进行身份验证。

6. 可选：如果要使用自定义证书，请更新 TokenAuthentication 部分，以添加 ca_cert_path 参数以指定自定义证书的位置，如下例所示：

   身份验证部分示例

   auth = TokenAuthentication(
       token = "XXXXX",
       server = "XXXXX",
       skip_tls=False,
       ca_cert_path="/path/to/cert"
   )
   auth.login()

   Copy to Clipboard Toggle word wrap

   或者，您可以设置 CF_SDK_CA_CERT_PATH 环境变量来指定自定义证书的位置。

7. 在每个 Jupyter 笔记本中，按如下所示更新集群配置部分：

   1. 如果指定了 namespace 值，将 example 值替换为项目的名称。

      如果省略这一行，则会在当前项目中创建 Ray 集群。

   2. 如果指定了 image 值，将 example 值替换为到合适的 Ray 集群镜像的链接。Ray 集群镜像中的 Python 版本必须与工作台中的 Python 版本相同。

      如果省略这一行，则默认使用以下 Ray 集群镜像之一，具体取决于工作台中检测到的 Python 版本：

      • Python 3.9: quay.io/modh/ray:2.35.0-py39-cu121
      • python 3.11: quay.io/modh/ray:2.47.1-py311-cu121

      默认 Ray 镜像与指定 CUDA 版本支持的 NVIDIA GPU 兼容。默认镜像是 AMD64 镜像，可能不适用于其他架构。

      提供了其他兼容 ROCm 的集群镜像，它们与指定的 ROCm 版本支持的 AMD 加速器兼容。这些镜像是 AMD64 镜像，可能不适用于其他架构。

      有关最新可用培训镜像及其预装软件包的详情，包括 CUDA 和 ROCm 版本，请参阅 Red Hat OpenShift AI: 支持的配置。

   3. 如果集群管理员没有配置默认本地队列，请为 Ray 集群指定本地队列，如下例所示：

      本地队列分配示例

      local_queue="your_local_queue_name"

      Copy to Clipboard Toggle word wrap

   4. 可选： 将标签 参数的字典分配给 Ray 集群以进行识别和管理目的，如下例所示：

      标签分配示例

      labels = {"exampleLabel1": "exampleLabel1Value", "exampleLabel2": "exampleLabel2Value"}

      Copy to Clipboard Toggle word wrap

8. 在 2_basic_interactive.ipynb Jupyter 笔记本中，确保 Ray 集群创建部分中包含以下 Ray 集群身份验证代码：

   Ray 集群身份验证代码

   from codeflare_sdk import generate_cert
   generate_cert.generate_tls_cert(cluster.config.name, cluster.config.namespace)
   generate_cert.export_env(cluster.config.name, cluster.config.namespace)

   Copy to Clipboard Toggle word wrap

   注意

   在 OpenShift AI 的 CodeFlare 组件中默认启用 mutual Transport Layer Security (mTLS)。您必须包含 Ray 集群身份验证代码，以便启用在 Jupyter 笔记本中运行的 Ray 客户端，以连接到启用了 mTLS 的安全 Ray 集群。

9. 按照 file-name 前缀(0_、1_ 等)运行 Jupyter 笔记本。

   1. 在每个 Jupyter 笔记本中，依次运行每个单元，并查看单元输出。
   2. 如果显示错误，请查看输出以查找有关问题的信息和所需的纠正操作。例如，按照指示替换任何已弃用的参数。另请参阅 用户对分布式工作负载的常见问题进行故障排除。
   3. 有关在 Jupyter 笔记本中工作时，您可以使用交互式浏览器控制简化 Ray 集群任务的更多信息，请参阅 在 Jupyter 笔记本中 管理 Ray 集群。

验证

1. Jupyter 笔记本运行以在没有错误的情况下完成。
2. 在 Jupyter 笔记本中，cluster.status （） 函数或 cluster.details （） 函数的输出表示 Ray 集群是 Active。

流程

1. 按照从 CodeFlare SDK 中运行演示 Jupyter 笔记本中所述，按照文件名前缀(0_、1_ 等)运行所有演示 Jupyter 笔记本。

2. 在每个演示 Jupyter 笔记本中，在运行集群配置步骤时，Jupyter 笔记本中会自动显示以下互动控制：

   • Cluster Up: 您可以点此按钮启动 Ray 集群。此按钮等同于 cluster.up （） 命令。当您点此按钮时，信息会显示集群是否已成功创建。
   • Cluster Down ：您可以点此按钮删除 Ray 集群。此按钮等同于 cluster.down （） 命令。集群将立即删除，系统不会提示您确认删除。当您点此按钮时，信息会显示集群是否已成功删除。
   • 等待 集群 ：您可以选择这个选项来指定笔记本单元应等待 Ray 集群仪表板就绪，然后继续下一步。这个选项等同于 cluster.wait_ready （） 命令。

3. 在 JupyterLab 界面中，创建一个新的 Jupyter 笔记本来管理 Ray 集群，如下所示：

   1. 点 File > New > Notebook。指定您首选的 Python 版本，然后点 Select。

      使用 .ipynb 文件扩展名创建一个新的 Jupyter 笔记本文件。

   2. 在新的 Jupyter 笔记本中添加以下代码：

      导入所需软件包的代码

      from codeflare_sdk import TokenAuthentication, view_clusters

      Copy to Clipboard Toggle word wrap

      view_clusters 软件包提供了用于列出集群的交互式浏览器控制，显示集群详情、打开 Ray 仪表板并刷新集群数据。

   3. 添加新的笔记本单元，并在新单元中添加以下代码：

      要进行身份验证的代码

      auth = TokenAuthentication(
          token = "XXXXX",
          server = "XXXXX",
          skip_tls=False
      )
      auth.login()

      Copy to Clipboard Toggle word wrap

      有关如何查找令牌和服务器值的详情，请参考从 CodeFlare SDK 中运行演示 Jupyter 笔记本。

   4. 添加新的笔记本单元，并在新单元中添加以下代码：

      查看当前项目中的集群的代码

      view_clusters()

      Copy to Clipboard Toggle word wrap

      当您运行没有指定参数的 view_clusters （） 命令时，您可以生成 当前 项目中的所有 Ray 集群的列表，并显示与 cluster.details （） 函数类似的信息。

      如果可以访问另一个项目，您可以通过指定项目名称来列出该项目中的 Ray 集群，如下例所示：

      查看另一个项目中的集群的代码

      view_clusters("my_second_project")

      Copy to Clipboard Toggle word wrap

   5. 点 File > Save Notebook As，输入 demo-notebooks/guided-demos/manage_ray_clusters.ipynb，然后点击 Save。
4. 在 demo-notebooks/guided-demos/manage_ray_clusters.ipynb Jupyter notebook 中，选择每个单元格，然后点击 Run > Run selected cell。

5. 当您使用 view_clusters （） 函数运行单元时，输出取决于是否存在 Ray 集群。

   如果没有 Ray 集群，则会显示以下文本，其中 _[project-name]_ 是目标项目的名称：

   No clusters found in the [project-name] namespace.

   Copy to Clipboard Toggle word wrap

   否则，Jupyter 笔记本显示有关现有 Ray 集群的以下信息：

   • 选择现有集群

     在此标题下，每个现有集群会显示一个切换按钮。点集群名称来选择集群。集群详情部分已更新，显示有关所选集群的详情，如集群名称、OpenShift AI 项目名称、集群资源信息和集群状态。

   • 删除集群

     点击此按钮删除所选集群。这个按钮等同于 Cluster Down 按钮。集群将立即删除，系统不会提示您确认删除。消息显示集群是否已成功删除，对应的按钮将不再显示在 Select an existing cluster 标题下。

   • 查看作业

     点击此按钮，打开所选集群的 Ray 仪表板中的 Jobs 选项卡，并查看提交的作业详情。对应的 URL 显示在 Jupyter 笔记本中。

   • 打开 Ray Dashboard

     点击此按钮打开所选集群的 Ray 仪表板中的 Overview 选项卡。对应的 URL 显示在 Jupyter 笔记本中。

   • 刷新数据

     点这个按钮刷新 Ray 集群列表以及所选集群的集群详情。当您选择集群以及删除所选集群时，集群详情会自动刷新。

验证

1. 演示 Jupyter 笔记本运行以在没有错误的情况下完成。
2. 在 manage_ray_clusters.ipynb Jupyter 笔记本中，view_clusters （） 函数的输出是正确的。

流程

1. 登录 OpenShift 控制台。

2. 创建 ConfigMap 资源，如下所示：

   1. 在 Administrator 视角中，点 Workloads → ConfigMaps。
   2. 从 Project 列表中，选择您的项目。
   3. 点 Create ConfigMap。

   4. 在 Configure via 部分中，选择 YAML view 选项。

      Create ConfigMap 页面将打开，默认的 YAML 代码会自动添加。

3. 将默认 YAML 代码替换为您的 training-script 代码。

   有关培训脚本示例，请参阅 培训 Operator PyTorch 培训脚本示例。

4. 点 Create。

验证

1. 在 OpenShift 控制台中，在 Administrator 视角中点 Workloads → ConfigMaps。
2. 从 Project 列表中，选择您的项目。
3. 点 ConfigMap 资源显示培训脚本详情。

流程

1. 登录 OpenShift 控制台。

2. 创建 PyTorchJob 资源，如下所示：

   1. 在 Administrator 视角中，点击 Home → Search。
   2. 从 Project 列表中，选择您的项目。
   3. 单击 Resources 列表，然后在搜索字段中开始输入 PyTorchJob。

   4. 选择 PyTorchJob，然后单击 Create PyTorchJob。

      Create PyTorchJob 页面将打开，自动添加默认 YAML 代码。

3. 更新元数据，将 name 和 namespace 值替换为您的环境的值，如下例所示：

   metadata:
     name: pytorch-multi-node-job
     namespace: test-namespace

   Copy to Clipboard Toggle word wrap

4. 配置 master 节点，如下例所示：

   spec:
     pytorchReplicaSpecs:
       Master:
         replicas: 1
         restartPolicy: OnFailure
         template:
           metadata:
             labels:
               app: pytorch-multi-node-job

   Copy to Clipboard Toggle word wrap
   1. 在 replicas 条目中，指定 1。只需要一个 master 节点。

   2. 要使用 ConfigMap 资源为 PyTorchJob pod 提供培训脚本，请添加 ConfigMap 卷挂载信息，如下例所示：

      从 ConfigMap 资源添加培训脚本

      Spec:
        pytorchReplicaSpecs:
          Master:
            ...
            template:
              spec:
                containers:
                - name: pytorch
                  image: quay.io/modh/training:py311-cuda124-torch251
                  command: ["python", "/workspace/scripts/train.py"]
                  volumeMounts:
                  - name: training-script-volume
                    mountPath: /workspace
                volumes:
                - name: training-script-volume
                  configMap:
                    name: training-script-configmap

      Copy to Clipboard Toggle word wrap

   3. 为您的环境添加适当的资源限制，如下例所示：

      添加资源 contraints

      SSpec:
        pytorchReplicaSpecs:
          Master:
            ...
            template:
              spec:
                containers: ...
                resources:
                  requests:
                        cpu: "4"
                        memory: "8Gi"
                        nvidia.com/gpu: 2    # To use GPUs (Optional)
                  limits:
                        cpu: "4"
                        memory: "8Gi"
                        nvidia.com/gpu: 2

      Copy to Clipboard Toggle word wrap

5. 在 PyTorchJob 资源的 Worker 部分中进行类似的编辑。

   1. 更新 replicas 条目，以指定 worker 节点的数量。

   有关 PyTorchJob 资源的完整示例，请参阅 multi-node 培训的 Training Operator PyTorchJob 资源示例。

6. 点 Create。

验证

1. 在 OpenShift 控制台中，打开 Administrator 视角。
2. 从 Project 列表中，选择您的项目。
3. 点 Home → Search → PyTorchJob，并验证作业是否已创建。
4. 点 Workloads → Pods，验证请求的 head pod 和 worker pod 是否正在运行。

流程

1. 登录到 OpenShift CLI，如下所示：

   登录到 OpenShift CLI

   oc login --token=<token> --server=<server>

   Copy to Clipboard Toggle word wrap

   有关如何查找服务器和令牌详情的详情，请参考使用集群服务器和令牌进行身份验证。

2. 创建名为 training .py 的文件，并使用您的培训脚本填充该文件，如下所示：

   创建培训脚本

   cat <<EOF > train.py
   <paste your content here>
   EOF

   Copy to Clipboard Toggle word wrap

   将 <paste your content here& gt; 替换为您的培训脚本内容。

   有关培训脚本示例，请参阅 培训 Operator PyTorch 培训脚本示例。

3. 创建 ConfigMap 资源来存储培训脚本，如下所示：

   创建 ConfigMap 资源

   oc create configmap training-script-configmap --from-file=train.py -n <your-namespace>

   Copy to Clipboard Toggle word wrap

   将 <your-namespace > 替换为项目的名称。

4. 创建名为 pytorchjob.yaml 的文件来定义分布式培训作业设置，如下所示：

   定义分布式培训工作

   cat <<EOF > pytorchjob.py
   <paste your content here>
   EOF

   Copy to Clipboard Toggle word wrap

   将 <paste your content here > 替换为您的培训工作内容。

   有关示例培训作业，请参阅多节点培训培训 Operator PyTorchJob 资源示例。

5. 创建分布式培训工作，如下所示：

   创建分布式培训工作

   oc apply -f pytorchjob.yaml

   Copy to Clipboard Toggle word wrap

验证

1. 监控正在运行的分布式培训作业，如下所示：

   监控分布式培训工作

   oc get pytorchjobs -n <your-namespace>

   Copy to Clipboard Toggle word wrap

   将 <your-namespace > 替换为项目的名称。

2. 检查 pod 日志，如下所示：

   检查 pod 日志

   oc logs <pod-name> -n <your-namespace>

   Copy to Clipboard Toggle word wrap

   将 <your-namespace > 替换为项目的名称。

3. 当您要删除作业时，运行以下命令：

   删除作业

   oc delete pytorchjobs/pytorch-multi-node-job -n <your-namespace>

   Copy to Clipboard Toggle word wrap

   将 <your-namespace > 替换为项目的名称。

流程

1. 打开工作台，如下所示：

   1. 登录到 Red Hat OpenShift AI web 控制台。
   2. 点 Data Science projects 并点您的项目。
   3. 单击 Workbenches 选项卡。
   4. 如果您的工作台还没有运行，请启动工作台。
   5. 点 Open 链接在新窗口中打开 IDE。
2. 点 File → New → Notebook。

3. 创建培训功能，如下例所示：

   1. 使用以下内容创建单元：

      培训功能示例

      def train_func():
          import os
          import torch
          import torch.distributed as dist
      
          # Select backend dynamically: nccl for GPU, gloo for CPU
          backend = "nccl" if torch.cuda.is_available() else "gloo"
      
          # Initialize the process group
          dist.init_process_group(backend)
      
          # Get rank and world size
          rank = dist.get_rank()
          world_size = dist.get_world_size()
      
          # Select device dynamically
          device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
      
          # Log rank initialization
          print(f"Rank {rank}/{world_size} initialized with backend {backend} on device {device}.")
      
          # Initialize tensor on the selected device
          tensor = torch.zeros(1, device=device)
      
          if rank == 0:
              tensor += 1
              for i in range(1, world_size):
                  dist.send(tensor, dst=i)
          else:
              dist.recv(tensor, src=0)
      
          print(f"Rank {rank}: Tensor value {tensor.item()} on {device}")
      
          # Cleanup
          dist.destroy_process_group()

      Copy to Clipboard Toggle word wrap

      注意

      在本示例培训工作中，您不需要安装任何其他软件包或设置任何培训参数。

      有关如何添加其他软件包并设置培训参数的更多信息，请参阅配置调优作业。

   2. 可选：编辑内容来为您的环境指定适当的值。
   3. 运行单元以创建培训功能。

4. 配置 Training Operator SDK 客户端身份验证，如下所示：

   1. 使用以下内容创建单元：

      培训 Operator SDK 客户端身份验证示例

      from kubernetes import client
      from kubeflow.training import TrainingClient
      from kubeflow.training.models import V1Volume, V1VolumeMount, V1PersistentVolumeClaimVolumeSource
      
      api_server = "<API_SERVER>"
      token = "<TOKEN>"
      
      configuration = client.Configuration()
      configuration.host = api_server
      configuration.api_key = {"authorization": f"Bearer {token}"}
      # Un-comment if your cluster API server uses a self-signed certificate or an un-trusted CA
      #configuration.verify_ssl = False
      api_client = client.ApiClient(configuration)
      client = TrainingClient(client_configuration=api_client.configuration)

      Copy to Clipboard Toggle word wrap

   2. 编辑 api_server 和 token 参数，以输入要向 OpenShift 集群进行身份验证的值。

      有关如何查找服务器和令牌详情的详情，请参考使用集群服务器和令牌进行身份验证。

   3. 运行单元来配置 Training Operator SDK 客户端身份验证。
5. 点 File > Save Notebook As，输入适当的文件名，然后点 Save。

验证

1. 所有单元都成功运行。

流程

1. 打开工作台，如下所示：

   1. 登录到 Red Hat OpenShift AI web 控制台。
   2. 点 Data Science projects 并点您的项目。
   3. 单击 Workbenches 选项卡。如果您的工作台还没有运行，请启动工作台。
   4. 点 Open 链接在新窗口中打开 IDE。
2. 点 File → Open，打开您用来配置培训作业的 Jupyter 笔记本。

3. 创建单元来运行作业，并添加以下内容：

   from kubernetes import client
   
   # Start PyTorchJob with 2 Workers and 2 GPU per Worker (multi-node, multi-worker job).
   client.create_job(
      name="pytorch-ddp",
      train_func=train_func,
      base_image="quay.io/modh/training:py311-cuda124-torch251",
      num_workers=2,
      resources_per_worker={"nvidia.com/gpu": "2"},
      packages_to_install=["torchvision==0.19.0"],
      env_vars={"NCCL_DEBUG": "INFO", "TORCH_DISTRIBUTED_DEBUG": "DETAIL"},
      labels={
           "kueue.x-k8s.io/queue-name": "<local-queue-name>",
           "key": "value"
       },
      annotations={"key": "value"}
   )

   Copy to Clipboard Toggle word wrap

4. 编辑内容以指定环境的适当值，如下所示：

   1. 编辑 num_workers 值，以指定 worker 节点的数量。
   2. 根据作业要求和可用资源更新 resources_per_worker 值。
   3. 编辑 kueue.x-k8s.io/queue-name 标签的值，以匹配目标 LocalQueue 的名称。

   4. 提供的示例是 NVIDIA GPU。如果使用 AMD 加速器，请进行以下额外更改：

      • 在 resources_per_worker 条目中，将 nvidia.com/gpu 改为 amd.com/gpu
      • 将 base_image 值更改为 quay.io/modh/ training:py311-rocm62-torch251
      • 删除 NCCL_DEBUG 条目

1. 运行单元以运行该作业。

1. 使用以下内容创建单元：

   client.get_job_logs(
       name="pytorch-ddp",
       job_kind="PyTorchJob",
       follow=True,
   )

   Copy to Clipboard Toggle word wrap
2. 运行单元以查看作业进度。

流程

1. 打开工作台，如下所示：

   1. 登录到 Red Hat OpenShift AI web 控制台。
   2. 点 Data Science projects 并点您的项目。
   3. 单击 Workbenches 选项卡。
   4. 确保工作台使用具有 RWX 功能的存储类。
   5. 如果您的工作台还没有运行，请启动工作台。
   6. 点 Open 链接在新窗口中打开 IDE。
2. 点 File → New → Notebook。

3. 安装运行培训或调优作业所需的任何其他软件包。

   1. 在笔记本单元中，添加代码来安装其他软件包，如下所示：

      安装依赖项的代码

      # Install the yamlmagic package
      !pip install yamlmagic
      %load_ext yamlmagic
      
      !pip install git+https://github.com/kubeflow/trainer.git@release-1.9#subdirectory=sdk/python

      Copy to Clipboard Toggle word wrap

   2. 选择单元，然后点 Run > Run selected cell。

      已安装其他软件包。

4. 设置培训参数，如下所示：

   1. 使用以下内容创建单元：

      %%yaml parameters
      
      # Model
      model_name_or_path: Meta-Llama/Meta-Llama-3.1-8B-Instruct
      model_revision: main
      torch_dtype: bfloat16
      attn_implementation: flash_attention_2
      
      # PEFT / LoRA
      use_peft: true
      lora_r: 16
      lora_alpha: 8
      lora_dropout: 0.05
      lora_target_modules: ["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
      lora_modules_to_save: []
      init_lora_weights: true
      
      # Quantization / BitsAndBytes
      load_in_4bit: false                       # use 4 bit precision for the base model (only with LoRA)
      load_in_8bit: false                       # use 8 bit precision for the base model (only with LoRA)
      
      # Datasets
      dataset_name: gsm8k                       # id or path to the dataset
      dataset_config: main                      # name of the dataset configuration
      dataset_train_split: train                # dataset split to use for training
      dataset_test_split: test                  # dataset split to use for evaluation
      dataset_text_field: text                  # name of the text field of the dataset
      dataset_kwargs:
        add_special_tokens: false               # template with special tokens
        append_concat_token: false              # add additional separator token
      
      # SFT
      max_seq_length: 1024                      # max sequence length for model and packing of the dataset
      dataset_batch_size: 1000                  # samples to tokenize per batch
      packing: false
      use_liger: false
      
      # Training
      num_train_epochs: 10                      # number of training epochs
      
      per_device_train_batch_size: 32           # batch size per device during training
      per_device_eval_batch_size: 32            # batch size for evaluation
      auto_find_batch_size: false               # find a batch size that fits into memory automatically
      eval_strategy: epoch                      # evaluate every epoch
      
      bf16: true                                # use bf16 16-bit (mixed) precision
      tf32: false                               # use tf32 precision
      
      learning_rate: 1.0e-4                     # initial learning rate
      warmup_steps: 10                          # steps for a linear warmup from 0 to `learning_rate`
      lr_scheduler_type: inverse_sqrt           # learning rate scheduler (see transformers.SchedulerType)
      
      optim: adamw_torch_fused                  # optimizer (see transformers.OptimizerNames)
      max_grad_norm: 1.0                        # max gradient norm
      seed: 42
      
      gradient_accumulation_steps: 1            # number of steps before performing a backward/update pass
      gradient_checkpointing: false             # use gradient checkpointing to save memory
      gradient_checkpointing_kwargs:
        use_reentrant: false
      
      # FSDP
      fsdp: "full_shard auto_wrap offload"      # remove offload if enough GPU memory
      fsdp_config:
        activation_checkpointing: true
        cpu_ram_efficient_loading: false
        sync_module_states: true
        use_orig_params: true
        limit_all_gathers: false
      
      # Checkpointing
      save_strategy: epoch                      # save checkpoint every epoch
      save_total_limit: 1                       # limit the total amount of checkpoints
      resume_from_checkpoint: false             # load the last checkpoint in output_dir and resume from it
      
      # Logging
      log_level: warning                        # logging level (see transformers.logging)
      logging_strategy: steps
      logging_steps: 1                          # log every N steps
      report_to:
      - tensorboard                             # report metrics to tensorboard
      
      output_dir: /mnt/shared/Meta-Llama-3.1-8B-Instruct

      Copy to Clipboard Toggle word wrap
   2. 可选：如果您指定不同的模型或数据集，请编辑参数以适应模型、数据集和资源。如有必要，更新前面的单元以指定培训或调优作业的依赖项。
   3. 运行单元来设置培训参数。

5. 创建培训功能，如下所示：

   1. 使用以下内容创建单元：

      def main(parameters):
          import random
      
          from datasets import load_dataset
          from transformers import (
              AutoTokenizer,
              set_seed,
          )
      
          from trl import (
              ModelConfig,
              ScriptArguments,
              SFTConfig,
              SFTTrainer,
              TrlParser,
              get_peft_config,
              get_quantization_config,
              get_kbit_device_map,
          )
      
          parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
          script_args, training_args, model_args = parser.parse_dict(parameters)
      
          # Set seed for reproducibility
          set_seed(training_args.seed)
      
          # Model and tokenizer
          quantization_config = get_quantization_config(model_args)
          model_kwargs = dict(
              revision=model_args.model_revision,
              trust_remote_code=model_args.trust_remote_code,
              attn_implementation=model_args.attn_implementation,
              torch_dtype=model_args.torch_dtype,
              use_cache=False if training_args.gradient_checkpointing or
                                 training_args.fsdp_config.get("activation_checkpointing",
                                                               False) else True,
              device_map=get_kbit_device_map() if quantization_config is not None else None,
              quantization_config=quantization_config,
          )
          training_args.model_init_kwargs = model_kwargs
          tokenizer = AutoTokenizer.from_pretrained(
              model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code, use_fast=True
          )
          if tokenizer.pad_token is None:
              tokenizer.pad_token = tokenizer.eos_token
      
          # You can override the template here according to your use case
          # tokenizer.chat_template = ...
      
          # Datasets
          train_dataset = load_dataset(
              path=script_args.dataset_name,
              name=script_args.dataset_config,
              split=script_args.dataset_train_split,
          )
          test_dataset = None
          if training_args.eval_strategy != "no":
              test_dataset = load_dataset(
                  path=script_args.dataset_name,
                  name=script_args.dataset_config,
                  split=script_args.dataset_test_split,
              )
      
          # Templatize datasets
          def template_dataset(sample):
              # return{"text": tokenizer.apply_chat_template(examples["messages"], tokenize=False)}
              messages = [
                  {"role": "user", "content": sample[question]},
                  {"role": "assistant", "content": sample[answer]},
              ]
              return {"text": tokenizer.apply_chat_template(messages, tokenize=False)}
      
          train_dataset = train_dataset.map(template_dataset, remove_columns=["question", "answer"])
          if training_args.eval_strategy != "no":
              # test_dataset = test_dataset.map(template_dataset, remove_columns=["messages"])
              test_dataset = test_dataset.map(template_dataset, remove_columns=["question", "answer"])
      
          # Check random samples
          with training_args.main_process_first(
              desc="Log few samples from the training set"
          ):
              for index in random.sample(range(len(train_dataset)), 2):
                  print(train_dataset[index]["text"])
      
          # Training
          trainer = SFTTrainer(
              model=model_args.model_name_or_path,
              args=training_args,
              train_dataset=train_dataset,
              eval_dataset=test_dataset,
              peft_config=get_peft_config(model_args),
              tokenizer=tokenizer,
          )
      
          if trainer.accelerator.is_main_process and hasattr(trainer.model, "print_trainable_parameters"):
              trainer.model.print_trainable_parameters()
      
          checkpoint = None
          if training_args.resume_from_checkpoint is not None:
              checkpoint = training_args.resume_from_checkpoint
      
          trainer.train(resume_from_checkpoint=checkpoint)
      
          trainer.save_model(training_args.output_dir)
      
          with training_args.main_process_first(desc="Training completed"):
              print(f"Training completed, model checkpoint written to {training_args.output_dir}")

      Copy to Clipboard Toggle word wrap
   2. 可选：如果您指定不同的模型或数据集，请编辑 tokenizer.chat_template 参数，为您的 model 和 dataset 指定适当的值。
   3. 运行单元以创建培训功能。

6. 配置 Training Operator SDK 客户端身份验证，如下所示：

   1. 使用以下内容创建单元：

      from kubernetes import client
      from kubeflow.training import TrainingClient
      from kubeflow.training.models import V1Volume, V1VolumeMount, V1PersistentVolumeClaimVolumeSource
      
      api_server = "<API_SERVER>"
      token = "<TOKEN>"
      
      configuration = client.Configuration()
      configuration.host = api_server
      configuration.api_key = {"authorization": f"Bearer {token}"}
      # Un-comment if your cluster API server uses a self-signed certificate or an un-trusted CA
      #configuration.verify_ssl = False
      api_client = client.ApiClient(configuration)
      client = TrainingClient(client_configuration=api_client.configuration)

      Copy to Clipboard Toggle word wrap

   2. 编辑 api_server 和 token 参数，以输入要向 OpenShift 集群进行身份验证的值。

      有关如何查找服务器和令牌详情的详情，请参考使用集群服务器和令牌进行身份验证。

   3. 运行单元来配置 Training Operator SDK 客户端身份验证。
7. 点 File > Save Notebook As，输入适当的文件名，然后点 Save。

验证

1. 所有单元都成功运行。

流程

1. 打开工作台，如下所示：

   1. 登录到 Red Hat OpenShift AI web 控制台。
   2. 点 Data Science projects 并点您的项目。
   3. 单击 Workbenches 选项卡。如果您的工作台还没有运行，请启动工作台。
   4. 点 Open 链接在新窗口中打开 IDE。
2. 点 File → Open，打开您用来配置微调作业的 Jupyter 笔记本。

3. 创建单元来运行作业，并添加以下内容：

   client.create_job(
       job_kind="PyTorchJob",
       name="sft",
       train_func=main,
       num_workers=8,
       num_procs_per_worker="1",
       resources_per_worker={
           "nvidia.com/gpu": 1,
           "memory": "64Gi",
           "cpu": 4,
       },
       base_image="quay.io/modh/training:py311-cuda124-torch251",
       env_vars={
           # Hugging Face
           "HF_HOME": "/mnt/shared/.cache",
           "HF_TOKEN": "",
           # CUDA
           "PYTORCH_CUDA_ALLOC_CONF": "expandable_segments:True",
           # NCCL
           "NCCL_DEBUG": "INFO",
           "NCCL_ENABLE_DMABUF_SUPPORT": "1",
       },
       packages_to_install=[
           "tensorboard",
       ],
       parameters=parameters,
       volumes=[
           V1Volume(name="shared",
               persistent_volume_claim=V1PersistentVolumeClaimVolumeSource(claim_name="shared")),
       ],
       volume_mounts=[
           V1VolumeMount(name="shared", mount_path="/mnt/shared"),
       ],
   )

   Copy to Clipboard Toggle word wrap

4. 编辑 HF_TOKEN 值，以指定您的 Hugging Face 访问令牌。

   可选： 如果您指定了不同的模型，且您的模型不是 Hugging Face Hub 的控制模型，请删除 HF_HOME 和 HF_TOKEN 条目。

5. 可选：编辑其他内容来为您的环境指定适当的值，如下所示：

   1. 编辑 num_workers 值，以指定 worker 节点的数量。
   2. 根据作业要求和可用资源更新 resources_per_worker 值。

   3. 提供的示例是 NVIDIA GPU。如果使用 AMD 加速器，请进行以下额外更改：

      • 在 resources_per_worker 条目中，将 nvidia.com/gpu 改为 amd.com/gpu
      • 将 base_image 值更改为 quay.io/modh/ training:py311-rocm62-torch251
      • 删除 CUDA 和 NCCL 条目

   4. 如果附加到工作台的 RWX PersistentVolumeClaim 资源具有不同的名称而不是 共享，请更新以下值以用 PVC 名称替换 共享 ：

      • 在此单元中，更新 HF_HOME 值。

      • 在这个单元中，在 volumes 条目中更新 PVC 详情：

        • 在 V1Volume 条目中，更新 name 和 claim_name 值。
        • 在 volume_mounts 条目中，更新 name 和 mount_path 值。

      • 在设置 training 参数的单元中，更新 output_dir 值。

        有关设置培训参数的更多信息，请参阅配置调优作业。

6. 运行单元以运行该作业。

1. 使用以下内容创建单元：

   client.get_job_logs(
       name="sft",
       job_kind="PyTorchJob",
       follow=True,
   )

   Copy to Clipboard Toggle word wrap
2. 运行单元以查看作业进度。

流程

1. 打开工作台，如下所示：

   1. 登录到 Red Hat OpenShift AI web 控制台。
   2. 点 Data Science projects 并点您的项目。
   3. 单击 Workbenches 选项卡。如果您的工作台还没有运行，请启动工作台。
   4. 点 Open 链接在新窗口中打开 IDE。
2. 点 File → Open，打开您用来配置和运行示例微调作业的 Jupyter 笔记本。

3. 使用以下内容创建单元：

   client.delete_job(name="sft")

   Copy to Clipboard Toggle word wrap
4. 可选：如果要删除其他作业，请编辑内容，将 sft 替换为作业的名称。
5. 运行单元以删除作业。

验证

1. 在 OpenShift 控制台中，在 Administrator 视角中点 Workloads → Jobs。
2. 从 Project 列表中，选择您的项目。
3. 验证指定的作业没有被列出。