翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# ローカルコードを SageMaker トレーニングジョブとして実行する
<a name="train-remote-decorator"></a>

ローカル機械学習 (ML) Python コードは、単一ノードの大規模な Amazon SageMaker トレーニングジョブとして実行することも、複数の並列ジョブとして実行することもできます。これは、次のコードサンプルに示すように、コードに @remote デコレータで注釈を付けることで実現できます。リモート関数では複数のインスタンスにわたる[分散トレーニング](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-training.html)がサポートされていません。

```
@remote(**settings)
def divide(x, y):
    return x / y
```

SageMaker Python SDK は、既存のワークスペース環境と関連するデータ処理コードおよびデータセットを、SageMaker トレーニングプラットフォーム上で実行される SageMaker トレーニングジョブに自動的に変換します。また、永続キャッシュ機能を有効化して、以前にダウンロードした依存関係パッケージをキャッシュすることで、ジョブのスタートアップレイテンシーをさらに短縮することもできます。このジョブのレイテンシーの短縮は、SageMaker AI が管理するウォームプールだけを使用した場合のレイテンシーの短縮よりも大きくなります。詳細については、「[永続キャッシュを使用する](train-warm-pools.md#train-warm-pools-persistent-cache)」を参照してください。

**注記**  
分散トレーニングジョブは、リモート関数ではサポートされていません。

以下のセクションでは、ローカル機械学習コードに @remote デコレータで注釈を付け、ユースケースに合わせてエクスペリエンスを調整する方法を示します。これには、環境のカスタマイズと SageMaker Experiments との統合が含まれます。

**Topics**
+ [環境をセットアップする](#train-remote-decorator-env)
+ [リモート関数を呼び出す](train-remote-decorator-invocation.md)
+ [設定ファイル](train-remote-decorator-config.md)
+ [ランタイム環境をカスタマイズする](train-remote-decorator-customize.md)
+ [コンテナイメージの互換性](train-remote-decorator-container.md)
+ [Amazon SageMaker Experiments によるパラメータとメトリクスの記録](train-remote-decorator-experiments.md)
+ [モジュラーコードと @remote デコレータの使用](train-remote-decorator-modular.md)
+ [ランタイム依存関係用のプライベートリポジトリ](train-remote-decorator-private.md)
+ [サンプルノートブックの例](train-remote-decorator-examples.md)

## 環境をセットアップする
<a name="train-remote-decorator-env"></a>

次の 3 つのオプションから 1 つ選択して、環境をセットアップします。

### Amazon SageMaker Studio Classic からコードを実行する
<a name="train-remote-decorator-env-studio"></a>

SageMaker ノートブックを作成し、SageMaker Studio Classic イメージで利用可能なイメージを添付することで、SageMaker Studio Classic からローカル機械学習コードに注釈を付けて実行できます。以下の手順は、SageMaker ノートブックの作成、SageMaker Python SDK のインストール、およびコードへのデコレータでの注釈付けに役立ちます。

1. 次のように、SageMaker ノートブックを作成し、SageMaker Studio Classic にイメージをアタッチします。

   1. *Amazon SageMaker AI 開発者ガイド*の「[Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html)」の指示に従います。

   1. 左のナビゲーションペインで **[Studio]** を選択します。新しいウィンドウが開きます。

   1. **[使用を開始]** ダイアログボックスで、下向き矢印からユーザープロファイルを選択します。新しいウィンドウが開きます。

   1. **[Studio Classic を開く]** を選択します。

   1. メインワークエリアから **[ランチャーを開きます]** を選択します。新しいページが開きます。

   1. メインワークエリアから **[ノートブックの作成]** を選択します。

   1. **[環境の変更]** ダイアログボックスの **[イメージ]** の横にある下向き矢印から **[Base Python 3.0]** を選択します。

      @remote デコレータは、SageMaker Studio Classic ノートブックにアタッチされたイメージを自動的に検出し、それを使用して SageMaker トレーニングジョブを実行します。`image_uri` がデコレータまたは設定ファイルの引数として指定されている場合、検出されたイメージの代わりに `image_uri` で指定された値が使用されます。

      SageMaker Studio Classic でノートブックを作成する方法の詳細については、「[Create or Open an Amazon SageMaker Studio Classic Notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-create-open.html#notebooks-create-file-menu)」の「**Create a Notebook from the File Menu**」セクションを参照してください。

      使用可能なイメージのリストについては、「[Supported Docker images](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-container.html)」を参照してください。

1. SageMaker Python SDK をインストールします。

   SageMaker Studio Classic ノートブック内のコードに @remote 関数で注釈を付けるには、SageMaker Python SDK がインストールされている必要があります。次のコードサンプルに示すように、SageMaker Python SDK をインストールします。

   ```
   !pip install sagemaker
   ```

1. @remote デコレータを使用して、SageMaker トレーニングジョブで関数を実行します。

   ローカル機械学習コードを実行するには、まず依存関係ファイルを作成し、ローカルコードを配置する場所を SageMaker AI に指示します。そのためには、以下の手順を実行します。

   1. SageMaker Studio Classic Launcher のメインワークエリアの **[ユーティリティとファイル]** で、**[テキストファイル]** を選択します。これにより、`untitled.txt.` と呼ばれるテキストファイルを含む新しいタブが開きます。

      SageMaker Studio ユーザーインターフェイス (UI) の詳細については、「[Amazon SageMaker Studio Classic UI Overview](https://docs.aws.amazon.com//sagemaker/latest/dg/studio-ui.html)」を参照してください。

   1. `untitled.txt ` を `requirements.txt` に名前変更します。

   1. SageMaker AI ライブラリとともに、コードに必要なすべての依存関係を `requirements.txt` に追加します。

      `divide` 関数例の `requirements.txt` の最小限のコードサンプルを以下のセクションに示します。

      ```
      sagemaker
      ```

   1. 以下のように依存関係ファイルを渡して、リモートデコレータを使用してコードを実行します。

      ```
      from sagemaker.remote_function import remote
      
      @remote(instance_type="ml.m5.xlarge", dependencies='./requirements.txt')
      def divide(x, y):
          return x / y
      
      divide(2, 3.0)
      ```

      その他のコードサンプルについては、サンプルノートブック [quick\$1start.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb) を参照してください。

      すでに SageMaker Studio Classic ノートブックを実行していて、「**2. Install the SageMaker Python SDK**」の指示に従って Python SDK をインストールする場合は、カーネルを再起動する必要があります。詳細については、Amazon SageMaker AI 開発者ガイドの「[Use the SageMaker Studio Classic Notebook Toolbar](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-menu.html)」を参照してください。

### Amazon SageMaker ノートブックからコードを実行する
<a name="train-remote-decorator-env-notebook"></a>

SageMaker ノートブックインスタンスからローカル機械学習コードに注釈を付けることができます。以下の手順は、カスタムカーネルを使用したノートブックインスタンスの作成、SageMaker Python SDK のインストール、およびコードへのデコレータでの注釈付けに役立ちます。

1. カスタム `conda` カーネルを使用してノートブックインスタンスを作成します。

   ローカル機械学習コードに @remote デコレータで注釈を付け、SageMaker のトレーニングジョブ内で使用できます。まず、SageMaker ノートブックインスタンスを作成してカスタマイズし、Python バージョン 3.7 以降 (3.10.x まで) のカーネルを使用する必要があります。そのためには、以下の手順を実行します。

   1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) を開きます。

   1. 左側のナビゲーションパネルで、**[ノートブック]** を選択してオプションを展開します。

   1. 展開されたオプションから **[ノートブックインスタンス]** を選択します。

   1. **[ノートブックインスタンスの作成]** ボタンを選択します。新しいページが開きます。

   1. **ノートブックインスタンス名には**、スペースなしで 63 文字以内の名前を入力します。有効な文字は、**A～Z**、**a～z**、**0～9**、および **.****:****\$1****=****@**** \$1****%****-** (ハイフン) です。

   1. **[ノートブックインスタンス設定]** ダイアログボックスで、**[追加設定]** の横にある右矢印を展開します。

   1. **[ライフサイクル設定 - オプション]** で、下向き矢印を展開して **[新しいライフサイクル設定を作成する]** を選択します。新しいダイアログボックスが開きます。

   1. **[名前]** で、構成設定の名前を入力します。

   1. **[スクリプト]** ダイアログボックスの **[ノートブックの開始]** タブで、テキストボックスの既存の内容を次のスクリプトに置き換えます。

      ```
      #!/bin/bash
      
      set -e
      
      sudo -u ec2-user -i <<'EOF'
      unset SUDO_UID
      WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda/
      source "$WORKING_DIR/miniconda/bin/activate"
      for env in $WORKING_DIR/miniconda/envs/*; do
          BASENAME=$(basename "$env")
          source activate "$BASENAME"
          python -m ipykernel install --user --name "$BASENAME" --display-name "Custom ($BASENAME)"
      done
      EOF
      
      echo "Restarting the Jupyter server.."
      # restart command is dependent on current running Amazon Linux and JupyterLab
      CURR_VERSION_AL=$(cat /etc/system-release)
      CURR_VERSION_JS=$(jupyter --version)
      
      if [[ $CURR_VERSION_JS == *$"jupyter_core     : 4.9.1"* ]] && [[ $CURR_VERSION_AL == *$" release 2018"* ]]; then
       sudo initctl restart jupyter-server --no-wait
      else
       sudo systemctl --no-block restart jupyter-server.service
      fi
      ```

   1. **[スクリプト]** ダイアログボックスの **[ノートブックを作成]** タブで、テキストボックスの既存の内容を次のスクリプトに置き換えます。

      ```
      #!/bin/bash
      
      set -e
      
      sudo -u ec2-user -i <<'EOF'
      unset SUDO_UID
      # Install a separate conda installation via Miniconda
      WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
      mkdir -p "$WORKING_DIR"
      wget https://repo.anaconda.com/miniconda/Miniconda3-4.6.14-Linux-x86_64.sh -O "$WORKING_DIR/miniconda.sh"
      bash "$WORKING_DIR/miniconda.sh" -b -u -p "$WORKING_DIR/miniconda" 
      rm -rf "$WORKING_DIR/miniconda.sh"
      # Create a custom conda environment
      source "$WORKING_DIR/miniconda/bin/activate"
      KERNEL_NAME="custom_python310"
      PYTHON="3.10"
      conda create --yes --name "$KERNEL_NAME" python="$PYTHON" pip
      conda activate "$KERNEL_NAME"
      pip install --quiet ipykernel
      # Customize these lines as necessary to install the required packages
      EOF
      ```

   1. ウィンドウの右下にある **[構成を作成]** ボタンを選択します。

   1. ウィンドウの右下にある **[ノートブックインスタンスの作成]** ボタンを選択します。

   1. ノートブックインスタンスの **[ステータス]** が **[保留中]** から **[InService]** に変わるまで待ちます。

1. ノートブックインスタンスで Jupyter Notebook を作成します。

   以下の手順は、新しく作成した SageMaker インスタンスで Python 3.10 を使用して Jupyter Notebook を作成する方法を示しています。

   1. 前のステップのノートブックインスタンスの **[ステータス]** が **[InService]** になったら、次の操作を行います。

      1. 新しく作成したノートブックインスタンスの **[名前]** を含んでいる行の **[アクション]** で **[Jupyter を開く]** を選択します。新しい Jupyter サーバーが開きます。

   1. Jupyter サーバーで、右上のメニューから **[新規]** を選択します。

   1. 下向き矢印から **[conda\$1custom\$1python310]** を選択します。Python 3.10 カーネルを使用する新しい Jupyter Notebook が作成されます。この新しい Jupyter Notebook は、ローカルの Jupyter Notebook と同様に使用できるようになりました。

1. SageMaker Python SDK をインストールします。

   仮想環境が実行されたら、次のコードサンプルを使用して SageMaker Python SDK をインストールします。

   ```
   !pip install sagemaker
   ```

1. @remote デコレータを使用して、SageMaker トレーニングジョブで関数を実行します。

   SageMaker ノートブック内の @remote デコレータでローカル機械学習コードに注釈を付けると、SageMaker トレーニングでコードの機能が自動的に解釈され、SageMaker トレーニングジョブとして実行されます。次の手順を実行して、ノートブックを設定します。

   1. ステップ 1「**カスタムカーネルを使用して SageMaker ノートブックインスタンスを作成します**」で作成した SageMaker ノートブックインスタンスのノートブックメニューでカーネル名を選択します。

      詳細については、「[イメージまたはカーネルの変更](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-run-and-manage-change-image.html)」を参照してください。

   1. 下向き矢印から、3.7 以降のバージョンの Python を使用するカスタム `conda` カーネルを選択します。

      例として、`conda_custom_python310` を選択すると Python 3.10 用のカーネルが選択されます。

   1. **[選択]** を選択します。

   1. カーネルのステータスがアイドル (カーネルが起動したことを示す) になるのを待ちます。

   1. Jupyter サーバーホームで、右上のメニューから **[新規]** を選択します。

   1. 下矢印の横で **[テキストファイル]** を選択します。`untitled.txt.` という名前の新しいテキストファイルが作成されます。

   1. `untitled.txt` から `requirements.txt` に名前を変更し、コードに必要な依存関係を `sagemaker` と一緒に追加します。

   1. 次に示すように、依存関係ファイルを渡して、リモートデコレータを使用してコードを実行します。

      ```
      from sagemaker.remote_function import remote
      
      @remote(instance_type="ml.m5.xlarge", dependencies='./requirements.txt')
      def divide(x, y):
          return x / y
      
      divide(2, 3.0)
      ```

      その他のコードサンプルについては、サンプルノートブック [quick\$1start.ipnyb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb) を参照してください。

### ローカル IDE 内からコードを実行する
<a name="train-remote-decorator-env-ide"></a>

任意のローカル IDE 内でローカル機械学習コードに @remote デコレータで注釈を付けることができます。以下の手順は、必要な前提条件、Python SDK のインストール方法、およびコードに @remote デコレータで注釈を付ける方法を示しています。

1. ( AWS Command Line Interface AWS CLI) を設定し、次のようにロールを作成して、前提条件をインストールします。
   + 「[Set Up Amazon SageMaker AI Prerequisites](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html#gs-cli-prereq)」の「**AWS CLI Prerequisites**」セクションの指示に従って、SageMaker AI ドメインにオンボーディングします。
   + 「[SageMaker AI Roles](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)」の「**実行ロールを作成する**」セクションに従って、IAM ロールを作成します。

1. PyCharm または `conda` を使用するとともに、Python バージョン 3.7 以降 (3.10.x まで) を使用して、仮想環境を作成します。
   + 以下のように PyCharm を使用して仮想環境を設定します。

     1. メインメニューから **[ファイル]** を選択します。

     1. **[新しいプロジェクト]** を選択します。

     1. **[使用する新しい環境]** の下向き矢印から **[Conda]** を選択します。

     1. **[Python のバージョン]** フィールドで、下向き矢印を使用して 3.7 以降の Python のバージョンを選択します。リストから 3.10.x まで選択できます。  
![\[\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/training-pycharm-ide.png)
   + Anaconda がインストールされている場合、以下のように `conda` を使用して仮想環境をセットアップできます。
     + Anaconda Prompt のターミナルインターフェースを開きます。
     + Python バージョン 3.7 以降 (3.10x まで) を使用して、新しい `conda` 環境を作成し、アクティブ化します。次のコードサンプルは、Python バージョン 3.10 を使用して `conda` 環境を作成する方法を示しています。

       ```
       conda create -n sagemaker_jobs_quick_start python=3.10 pip
       conda activate sagemaker_jobs_quick_start
       ```

1. SageMaker Python SDK をインストールします。

   任意の IDE からコードをパッケージ化するには、Python 3.7 以降 (最大 3.10x) を使用して仮想環境を設定する必要があります。また、互換性があるコンテナイメージも必要です。次のコードサンプルを使用して、SageMaker Python SDK をインストールします。

   ```
   pip install sagemaker
   ```

1. @remote デコレータ内部でコードをラップします。SageMaker Python SDK では、コードの機能を自動的に解釈し、SageMaker トレーニングジョブとして実行します。以下のコードサンプルは、必要なライブラリをインポートする方法、SageMaker セッションを設定する方法、および @remote デコレータで関数に注釈を付ける方法を示しています。

   必要な依存関係を直接指定するか、アクティブな `conda` 環境からの依存関係を使用してコードを実行できます。
   + 依存関係を直接指定するには、次の操作を行います。
     + コードがある作業ディレクトリに `requirements.txt` ファイルを作成します。
     + SageMaker ライブラリとともに、コードに必要なすべての依存関係を追加します。次のセクションでは、`divide` 関数例の `requirements.txt` の最小限のコードサンプルを示します。

       ```
       sagemaker
       ```
     + 依存関係ファイルを渡し、@remote デコレータを使用してコードを実行します。以下のコードサンプルでは、SageMaker がジョブの実行に使用する AWS Identity and Access Management (IAM) ロール ARN で `The IAM role name` を置き換えます。

       ```
       import boto3
       import sagemaker
       from sagemaker.remote_function import remote
       
       sm_session = sagemaker.Session(boto_session=boto3.session.Session(region_name="us-west-2"))
       settings = dict(
           sagemaker_session=sm_session,
           role=<The IAM role name>,
           instance_type="ml.m5.xlarge",
           dependencies='./requirements.txt'
       )
       
       @remote(**settings)
       def divide(x, y):
           return x / y
       
       
       if __name__ == "__main__":
           print(divide(2, 3.0))
       ```
   + アクティブな `conda` 環境からの依存関係を使用するには、以下に示すように `dependencies` パラメータの値 `auto_capture` を使用します。

     ```
     import boto3
     import sagemaker
     from sagemaker.remote_function import remote
     
     sm_session = sagemaker.Session(boto_session=boto3.session.Session(region_name="us-west-2"))
     settings = dict(
         sagemaker_session=sm_session,
         role=<The IAM role name>,
         instance_type="ml.m5.xlarge",
         dependencies="auto_capture"
     )
     
     @remote(**settings)
     def divide(x, y):
         return x / y
     
     
     if __name__ == "__main__":
         print(divide(2, 3.0))
     ```
**注記**  
前述のコードを Jupyter Notebook 内に実装することもできます。PyCharm Professional 版は Jupyter をネイティブにサポートしています。詳細については、PyCharm のドキュメントの「[Jupyter notebook support](https://www.jetbrains.com/help/pycharm/ipython-notebook-support.html)」を参照してください。

# リモート関数を呼び出す
<a name="train-remote-decorator-invocation"></a>

@remote デコレータ内の関数を呼び出すには、次のいずれかの方法を使用します。
+ [@remote デコレータを使用して関数を呼び出す](#train-remote-decorator-invocation-decorator).
+ [`RemoteExecutor` API を使用して関数を呼び出す](#train-remote-decorator-invocation-api).

@remote デコレータメソッドを使用して関数を呼び出す場合、トレーニングジョブでは、関数が完了するのを待ってから新しいタスクを開始します。ただし、`RemoteExecutor` API を使用すると、複数のジョブを並列で実行できます。以下のセクションでは、関数を呼び出す両方の方法を示します。

## @remote デコレータを使用して関数を呼び出す
<a name="train-remote-decorator-invocation-decorator"></a>

@remote デコレータを使用して関数に注釈を付けることができます。SageMaker AI はデコレータ内部のコードを SageMaker トレーニングジョブに変換します。その後、トレーニングジョブでは、デコレータ内部の関数を呼び出し、ジョブが完了するのを待ちます。次のコードサンプルは、必要なライブラリをインポートし、SageMaker AI インスタンスを起動して、@remote デコレータで行列乗算に注釈を付ける方法を示しています。

```
from sagemaker.remote_function import remote
import numpy as np

@remote(instance_type="ml.m5.large")
def matrix_multiply(a, b):
    return np.matmul(a, b)
    
a = np.array([[1, 0],
             [0, 1]])
b = np.array([1, 2])

assert (matrix_multiply(a, b) == np.array([1,2])).all()
```

デコレータは次のように定義されます。

```
def remote(
    *,
    **kwarg):
        ...
```

修飾された関数を呼び出すと、SageMaker Python SDK はエラーによって発生した例外をローカルメモリに読み込みます。次のコードサンプルでは、最初の divide 関数の呼び出しが正常に完了し、結果がローカルメモリに読み込まれます。2 回目の divide 関数の呼び出しで、コードからエラーが返され、このエラーがローカルメモリに読み込まれます。

```
from sagemaker.remote_function import remote
import pytest

@remote()
def divide(a, b):
    return a/b

# the underlying job is completed successfully 
# and the function return is loaded
assert divide(10, 5) == 2

# the underlying job fails with "AlgorithmError" 
# and the function exception is loaded into local memory 
with pytest.raises(ZeroDivisionError):
    divide(10, 0)
```

**注記**  
修飾された関数はリモートジョブとして実行されます。スレッドが中断されても、基本となるジョブは停止しません。

### ローカル変数の値を変更する方法
<a name="train-remote-decorator-invocation-decorator-value"></a>

デコレータ関数はリモートマシン上で実行されます。修飾された関数内部の非ローカル変数や入力引数を変更しても、ローカル値は変更されません。

次のコードサンプルでは、デコレータ関数内部にリスト (list) と 辞書 (dict) が追加されています。これはデコレータ関数が呼び出されても変更されません。

```
a = []

@remote
def func():
    a.append(1)

# when func is invoked, a in the local memory is not modified        
func() 
func()

# a stays as []
    
a = {}
@remote
def func(a):
    # append new values to the input dictionary
    a["key-2"] = "value-2"
    
a = {"key": "value"}
func(a)

# a stays as {"key": "value"}
```

デコレータ関数内で宣言されたローカル変数の値を変更するには、関数から変数を返します。次のコードサンプルでは、ローカル変数の値が関数から返されるときに変更されることを示しています。

```
a = {"key-1": "value-1"}

@remote
def func(a):
    a["key-2"] = "value-2"
    return a

a = func(a)

-> {"key-1": "value-1", "key-2": "value-2"}
```

### データのシリアル化と逆シリアル化
<a name="train-remote-decorator-invocation-input-output"></a>

リモート関数を呼び出すと、SageMaker AI は入力ステージと出力ステージ中に関数の引数を自動的にシリアル化します。関数の引数と戻り値は [cloudpickle](https://github.com/cloudpipe/cloudpickle) を使用してシリアル化されます。SageMaker AI は、以下の Python オブジェクトと関数のシリアル化をサポートしています。
+ 辞書、リスト、浮動小数点数、整数、文字列、ブール値、タプルを含む組み込みの Python オブジェクト
+ Numpy 配列
+ Pandas DataFrame
+ Scikit-learn のデータセットと推定器
+ PyTorch モデル
+ TensorFlow モデル
+ XGBoost 用のブースタークラス

以下を使用する場合は、いくつか制限があります。
+ Dask DataFrames
+ XGBoost Dmatrix クラス
+ TensorFlow データセットとサブクラス
+ PyTorch モデル

以下のセクションには、リモート関数での制限がある以前の Python クラスを使用する際のベストプラクティス、シリアル化されたデータを SageMaker AI が保存する場所に関する情報、およびそのデータへのアクセスを管理する方法が含まれています。

#### リモートデータシリアル化のサポートが制限されている Python クラスのベストプラクティス
<a name="train-remote-decorator-invocation-input-output-bestprac"></a>

このセクションに記載されている Python クラスは制限付きで使用できます。次のセクションでは、次の Python クラスの使用方法に関するベストプラクティスについて説明します。
+ [Dask](https://www.dask.org/) DataFrames
+ XGBoost DMatric クラス
+ TensorFlow データセットとサブクラス
+ PyTorch モデル

##### Dask のベストプラクティス
<a name="train-remote-decorator-invocation-input-output-bestprac-dask"></a>

[Dask](https://www.dask.org/) は、Python のパラレルコンピューティングに使用されるオープンソースのライブラリです。このセクションでは、次の内容を説明します。
+ Dask DataFrame をリモート関数に渡す方法
+ サマリー統計を Dask DataFrame から Pandas DataFrame に変換する方法

##### Dask DataFrame をリモート関数に渡す方法
<a name="train-remote-decorator-invocation-input-output-bestprac-dask-pass"></a>

[Dask DataFrames](https://docs.dask.org/en/latest/dataframe.html) は、使用可能な量よりも多くのメモリを必要とするデータセットを格納できるため、大規模なデータセットの処理によく使用されます。これは、Dask DataFrame はローカルデータをメモリにロードしないためです。Dask DataFrame を関数引数としてリモート関数に渡すと、Dask はローカルディスクまたはクラウドストレージ内のデータにデータそのものではなく、参照を渡すことがあります。次のコードは、空の DataFrame を操作するリモート関数内に Dask DataFrame を渡す例を示しています。

```
#Do not pass a Dask DataFrame  to your remote function as follows
def clean(df: dask.DataFrame ):
    cleaned = df[] \ ...
```

Dask は、DataFrame を使用する場合にのみ Dask DataFrame からメモリにデータをロードします。リモート関数内で Dask DataFrame を使用する場合は、データへのパスを指定します。そうすると、Dask はコードの実行時に指定したデータパスから直接データセットを読み取ります。

次のコード例は、リモート関数 `clean` 内で Dask DataFrame を使用する方法を示しています。コード例では、`raw_data_path` は Dask DataFrame の代わりに clean に渡されます。コードを実行すると、`raw_data_path` で指定された Amazon S3 バケットの場所からデータセットが直接読み取られます。次に、`persist` 関数は、データセットをメモリに保持して後続の `random_split` 関数の実行を円滑化し、Dask DataFrame API 関数を使用して S3 バケットの出力データパスに書き戻します。

```
import dask.dataframe as dd

@remote(
   instance_type='ml.m5.24xlarge',
   volume_size=300, 
   keep_alive_period_in_seconds=600)
#pass the data path to your remote function rather than the Dask DataFrame  itself
def clean(raw_data_path: str, output_data_path: str: split_ratio: list[float]):
    df = dd.read_parquet(raw_data_path) #pass the path to your DataFrame 
    cleaned = df[(df.column_a >= 1) & (df.column_a < 5)]\
        .drop(['column_b', 'column_c'], axis=1)\
        .persist() #keep the data in memory to facilitate the following random_split operation

    train_df, test_df = cleaned.random_split(split_ratio, random_state=10)

    train_df.to_parquet(os.path.join(output_data_path, 'train')
    test_df.to_parquet(os.path.join(output_data_path, 'test'))
    
clean("s3://amzn-s3-demo-bucket/raw/", "s3://amzn-s3-demo-bucket/cleaned/", split_ratio=[0.7, 0.3])
```

##### サマリー統計を Dask DataFrame から Pandas DataFrame に変換する方法
<a name="train-remote-decorator-invocation-input-output-bestprac-dask-pd"></a>

Dask DataFrame からのサマリー統計は、以下のコード例のように `compute` メソッドを呼び出すことで Pandas DataFrame に変換できます。この例では、S3 バケットには、メモリまたは Pandas DataFrame に適合しない大きな Dask データフレームが含まれています。次の例では、リモート関数がデータセットをスキャンし、出力統計を含む Dask DataFrame を `describe` から Pandas DataFrame に返します。

```
executor = RemoteExecutor(
    instance_type='ml.m5.24xlarge',
    volume_size=300, 
    keep_alive_period_in_seconds=600)

future = executor.submit(lambda: dd.read_parquet("s3://amzn-s3-demo-bucket/raw/").describe().compute())

future.result()
```

##### XGBoost DMatric クラスのベストプラクティス
<a name="train-remote-decorator-invocation-input-output-bestprac-xgboost"></a>

DMatrix は、XGBoost がデータをロードするために使用する内部データ構造です。DMatrix オブジェクトは、コンピューティングセッション間で簡単に移動するためにピクル化することはできません。DMatrix インスタンスを直接渡すと、`SerializationError` のために失敗します。

##### データオブジェクトをリモート関数に渡して XGBoost でトレーニングする方法
<a name="train-remote-decorator-invocation-input-output-bestprac-xgboost-pass"></a>

Pandas DataFrame を DMatrix インスタンスに変換してリモート関数のトレーニングに使用するには、次のコードサンプルに示すように、リモート関数に直接渡します。

```
import xgboost as xgb

@remote
def train(df, params):
    #Convert a pandas dataframe into a DMatrix DataFrame and use it for training
    dtrain = DMatrix(df) 
    return xgb.train(dtrain, params)
```

##### TensorFlow データセットとサブクラスのベストプラクティス
<a name="train-remote-decorator-invocation-input-output-bestprac-tf"></a>

TensorFlow データセットとサブクラスは、TensorFlow がトレーニング中にデータをロードするために使用する内部オブジェクトです。TensorFlow のデータセットとサブクラスは、コンピューティングセッション間を簡単に移動するためにピクル化することはできません。Tensorflow のデータセットまたはサブクラスを直接渡すと、`SerializationError` のために失敗します。次のコードサンプルに示すように、Tensorflow I/O API を使用してストレージからデータをロードします。

```
import tensorflow as tf
import tensorflow_io as tfio

@remote
def train(data_path: str, params):
    
    dataset = tf.data.TextLineDataset(tf.data.Dataset.list_files(f"{data_path}/*.txt"))
    ...
    
train("s3://amzn-s3-demo-bucket/data", {})
```

##### PyTorch モデルのベストプラクティス
<a name="train-remote-decorator-invocation-input-output-bestprac-pytorch"></a>

PyTorch モデルはシリアル化可能で、ローカル環境とリモート関数の間で渡すことができます。ローカル環境とリモート環境のデバイスタイプ (GPU と CPU) が異なる場合、トレーニング済みのモデルをローカル環境に返すことはできません。たとえば、次のコードが GPU のないローカル環境で開発され、GPU を備えたインスタンスで実行された場合、トレーニング済みのモデルを直接返すと、`DeserializationError` という結果になります。

```
# Do not return a model trained on GPUs to a CPU-only environment as follows

@remote(instance_type='ml.g4dn.xlarge')
def train(...):
    if torch.cuda.is_available():
        device = torch.device("cuda")
    else:
        device = torch.device("cpu") # a device without GPU capabilities
    
    model = Net().to(device)
    
    # train the model
    ...
    
    return model
    
model = train(...) #returns a DeserializationError if run on a device with GPU
```

GPU 環境でトレーニングされたモデルを CPU 機能のみを含むモデルに返すには、次のコード例に示すように PyTorch モデル I/O API を直接使用します。

```
import s3fs

model_path = "s3://amzn-s3-demo-bucket/folder/"

@remote(instance_type='ml.g4dn.xlarge')
def train(...):
    if torch.cuda.is_available():
        device = torch.device("cuda")
    else:
        device = torch.device("cpu")
    
    model = Net().to(device)
    
    # train the model
    ...
    
    fs = s3fs.FileSystem()
    with fs.open(os.path.join(model_path, 'model.pt'), 'wb') as file:
        torch.save(model.state_dict(), file) #this writes the model in a device-agnostic way (CPU vs GPU)
    
train(...) #use the model to train on either CPUs or GPUs

model = Net()
fs = s3fs.FileSystem()with fs.open(os.path.join(model_path, 'model.pt'), 'rb') as file:
    model.load_state_dict(torch.load(file, map_location=torch.device('cpu')))
```

#### シリアル化されたデータを SageMaker AI が保存する場所
<a name="train-remote-decorator-invocation-input-output-storage"></a>

リモート関数を呼び出すと、SageMaker AI は入力ステージと出力ステージ中に関数の引数をシリアル化し、値を返します。このシリアル化されたデータは、S3 バケットのルートディレクトリに保存されます。設定ファイルでルートディレクトリ `<s3_root_uri>` を指定します。パラメータ `job_name` は自動的に生成されます。

ルートディレクトリの下に、SageMaker AI は現在の作業ディレクトリ、シリアル化された関数、シリアル化された関数の引数、結果、およびシリアル化された関数の呼び出しによって発生した例外を格納する `<job_name>` フォルダを作成します。

`<job_name>` 下のディレクトリ `workdir` には、現在の作業ディレクトリの zip アーカイブのアーカイブが含まれています。zip アーカイブには、作業ディレクトリ内のすべての Python ファイルと、リモート関数を実行するのに必要な依存関係を指定する `requirements.txt` ファイルが含まれます。

以下は、設定ファイルで指定する S3 バケットのフォルダ構造の例です。

```
<s3_root_uri>/ # specified by s3_root_uri or S3RootUri
    <job_name>/ #automatically generated for you
        workdir/workspace.zip # archive of the current working directory (workdir)
        function/ # serialized function
        arguments/ # serialized function arguments
        results/ # returned output from the serialized function including the model
        exception/ # any exceptions from invoking the serialized function
```

S3 バケットで指定するルートディレクトリは、長期保存用ではありません。シリアル化されたデータは、シリアル化中に使用された Python バージョンと機械学習 (ML) フレームワークのバージョンと密接に関連付けられます。Python バージョンまたは機械学習フレームワークをアップグレードすると、シリアル化されたデータを使用できなくなる場合があります。代わりに、以下の手順を実行します。
+ モデルとモデルアーティファクトを、ご使用の Python バージョンおよび機械学習フレームワークに依存しない形式で保存します。
+ Python または機械学習フレームワークをアップグレードする場合、長期ストレージからモデル結果にアクセスします。

**重要**  
指定された時間の経過後にシリアル化されたデータを削除するには、S3 バケットに[有効期限設定](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html)を行います。

**注記**  
Python [pickle](https://docs.python.org/3/library/pickle.html) モジュールを使用してシリアル化されたファイルは、CSV、Parquet、JSON などの他のデータ形式よりも移植性が低い場合があります。ソースが不明なピクル化ファイルをロードする場合は注意してください。

リモート関数の設定ファイルに含める内容の詳細については、「[設定ファイル](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html)」を参照してください。

#### シリアル化されたデータへのアクセス
<a name="train-remote-decorator-invocation-input-output-access"></a>

管理者は、シリアル化されたデータの場所や構成ファイル内の暗号化設定など、シリアル化されたデータの設定を行うことができます。デフォルトでは、シリアル化されたデータは AWS Key Management Service (AWS KMS) キーで暗号化されます。管理者は、設定ファイルで指定したルートディレクトリへのアクセスを[バケットポリシー](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html)で制限することもできます。設定ファイルはプロジェクトおよびジョブ間で共有して使用できます。詳細については、「[ 設定ファイル](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html)」を参照してください。

## `RemoteExecutor` API を使用して関数を呼び出す
<a name="train-remote-decorator-invocation-api"></a>

`RemoteExecutor` API を使用して関数を呼び出すことができます。SageMaker AI Python SDK は `RemoteExecutor` 呼び出し内部のコードを SageMaker AI トレーニングジョブに変換します。その後、トレーニングジョブは非同期オペレーションとして関数を呼び出し、Future を返します。`RemoteExecutor` API を使用すると、複数のジョブを並列で実行できます。Python の Future の詳細については、「[Future](https://docs.python.org/3/library/asyncio-future.html)」を参照してください。

以下のコード例は、必要なライブラリをインポートする方法、関数を定義する方法、SageMaker AI インスタンスを起動する方法、および API を使用して `2` ジョブを並列実行するリクエストを送信する方法を示しています。

```
from sagemaker.remote_function import RemoteExecutor

def matrix_multiply(a, b):
    return np.matmul(a, b)


a = np.array([[1, 0],
             [0, 1]])
b = np.array([1, 2])

with RemoteExecutor(max_parallel_job=2, instance_type="ml.m5.large") as e:
    future = e.submit(matrix_multiply, a, b)

assert (future.result() == np.array([1,2])).all()
```

`RemoteExecutor` クラスは [concurrent.futures.Executor](https://docs.python.org/3/library/concurrent.futures.html) ライブラリの実装です。

次のコード例は、`RemoteExecutorAPI` を使用して関数を定義し、それを呼び出す方法を示しています。この例では、`RemoteExecutor` は合計では `4` ジョブを送信しますが、並列では `2` のみ送信します。最後の 2 つのジョブは、最小限のオーバーヘッドでクラスターを再利用します。

```
from sagemaker.remote_function.client import RemoteExecutor

def divide(a, b):
    return a/b 

with RemoteExecutor(max_parallel_job=2, keep_alive_period_in_seconds=60) as e:
    futures = [e.submit(divide, a, 2) for a in [3, 5, 7, 9]]

for future in futures:
    print(future.result())
```

`max_parallel_job` パラメータはレート制限メカニズムとしてのみ機能し、コンピューティングリソースの割り当ては最適化されません。前のコード例では、`RemoteExecutor` では、ジョブが送信される前に 2 つの並列ジョブのコンピューティングリソースを予約しません。`max_parallel_job` または @remote デコレータのその他のパラメータの詳細については、「[Remote function classes and methods specification](https://sagemaker.readthedocs.io/en/stable/remote_function/sagemaker.remote_function.html)」を参照してください。

### `RemoteExecutor` API の Future クラス
<a name="train-remote-decorator-invocation-api-future"></a>

future クラスは、非同期で呼び出されたときのトレーニングジョブからの return 関数を表す public クラスです。future クラスは [concurrent.futures.Future](https://docs.python.org/3/library/concurrent.futures.html) クラスを実装しています。このクラスを使用すると、基になるジョブを操作したり、データをメモリに読み込んだりできます。

# 設定ファイル
<a name="train-remote-decorator-config"></a>

Amazon SageMaker Python SDK は、 AWS インフラストラクチャプリミティブタイプのデフォルト値の設定をサポートしています。管理者によってこれらのデフォルト値が設定された後、SageMaker Python SDK がサポートされている API を呼び出すと、これらのデフォルト値が自動的に渡されます。デコレータ関数の引数は設定ファイルの中に入れることができます。この結果、インフラストラクチャに関連する設定をコードベースから分離できます。リモート関数およびメソッドのパラメータおよび引数の詳細については、「[Remote function classes and methods specification](https://sagemaker.readthedocs.io/en/stable/remote_function/sagemaker.remote_function.html)」を参照してください。

ネットワーク設定、IAM ロール、入力/出力データ用の Amazon S3 フォルダ、および設定ファイル内のタグのインフラストラクチャ設定を行うことができます。設定ファイルは、@remote デコレータまたは `RemoteExecutor` API を使用して関数を呼び出すときに使用できます。

依存関係、リソース、その他の引数を定義する設定ファイルの例を以下に示します。この設定ファイルの例を使用すると、@remote デコレータまたは RemoteExecutor API を使用して起動される関数が呼び出されます。

```
SchemaVersion: '1.0'
SageMaker:
  PythonSDK:
    Modules:
      RemoteFunction:
        Dependencies: 'path/to/requirements.txt'
        EnableInterContainerTrafficEncryption: true
        EnvironmentVariables: {'EnvVarKey': 'EnvVarValue'}
        ImageUri: '366666666666.dkr.ecr.us-west-2.amazonaws.com/my-image:latest'
        IncludeLocalWorkDir: true
        CustomFileFilter: 
          IgnoreNamePatterns:
          - "*.ipynb"
          - "data"
        InstanceType: 'ml.m5.large'
        JobCondaEnvironment: 'your_conda_env'
        PreExecutionCommands:
            - 'command_1'
            - 'command_2'
        PreExecutionScript: 'path/to/script.sh'
        RoleArn: 'arn:aws:iam::366666666666:role/MyRole'
        S3KmsKeyId: 'yourkmskeyid'
        S3RootUri: 's3://amzn-s3-demo-bucket/my-project'
        VpcConfig:
            SecurityGroupIds: 
            - 'sg123'
            Subnets: 
            - 'subnet-1234'
        Tags: [{'Key': 'yourTagKey', 'Value':'yourTagValue'}]
        VolumeKmsKeyId: 'yourkmskeyid'
```

@remote デコレータと `RemoteExecutor` は、以下の設定ファイル内で `Dependencies` を検索します。
+ 管理者定義の設定ファイル。
+ ユーザー定義の設定ファイル。

これらの設定ファイルのデフォルトの場所は、環境によって異なり、環境に対して相対的です。次のコード例は、管理者設定ファイルとユーザー設定ファイルのデフォルトの場所を返します。これらのコマンドは、SageMaker Python SDK を使用しているのと同じ環境で実行する必要があります。

```
import os
from platformdirs import site_config_dir, user_config_dir

#Prints the location of the admin config file
print(os.path.join(site_config_dir("sagemaker"), "config.yaml"))

#Prints the location of the user config file
print(os.path.join(user_config_dir("sagemaker"), "config.yaml"))
```

管理者定義の設定ファイルパスとユーザー定義の設定ファイルパスに `SAGEMAKER_ADMIN_CONFIG_OVERRIDE` および `SAGEMAKER_USER_CONFIG_OVERRIDE` 環境変数をそれぞれ設定することで、これらのファイルのデフォルトの場所を上書きできます。

管理者定義の設定ファイルとユーザー定義の設定ファイルの両方にキーが存在する場合は、ユーザー定義ファイルの値が使用されます。

# ランタイム環境をカスタマイズする
<a name="train-remote-decorator-customize"></a>

ランタイム環境をカスタマイズすると、任意のローカル統合開発環境 (IDE)、SageMaker ノートブック、または SageMaker Studio Classic ノートブックを使用して機械学習コードを記述できます。SageMaker AI は、関数とその依存関係を SageMaker トレーニングジョブとしてパッケージ化し、送信するのに役立ちます。これにより、SageMaker トレーニングサーバーの容量にアクセスしてトレーニングジョブを実行できます。

リモートデコレータと関数を呼び出す `RemoteExecutor` メソッドの両方により、ユーザーはランタイム環境を定義してカスタマイズできます。`requirements.txt` ファイルまたは conda 環境 YAML ファイルのいずれかを使用できます。

conda 環境 YAML ファイルと `requirements.txt` ファイルの両方を使用してランタイム環境をカスタマイズするには、以下のコード例を参照してください。

```
# specify a conda environment inside a yaml file
@remote(instance_type="ml.m5.large",
        image_uri = "my_base_python:latest", 
        dependencies = "./environment.yml")
def matrix_multiply(a, b):
    return np.matmul(a, b)

# use a requirements.txt file to import dependencies
@remote(instance_type="ml.m5.large",
        image_uri = "my_base_python:latest", 
        dependencies = './requirements.txt')
def matrix_multiply(a, b):
    return np.matmul(a, b)
```

または、`dependencies` を `auto_capture` に設定して、アクティブな conda 環境にインストールされた依存関係を SageMaker Python SDK によってキャプチャできます。`auto_capture` が確実に動作するためには、以下が必要です。
+ アクティブな conda 環境が必要です。依存関係の競合の可能性を減らすため、リモートジョブに `base` conda 環境を使用しないことをお勧めします。`base` conda 環境を使用しないことで、リモートジョブでの環境設定も迅速化されます。
+ パラメータ `--extra-index-url` 値の値で pip を使用して依存関係をインストールしないでください。
+ conda でインストールされたパッケージと、ローカル開発環境に pip でインストールされたパッケージとの間に依存関係の競合がないこと。
+ ローカル開発環境には、Linux と互換性のないオペレーティングシステム固有の依存関係が含まれていていないこと。

`auto_capture` が機能しない場合は、このセクションの最初のコーディング例で説明したように、依存関係を requirement.txt または conda environment.yaml ファイルとして渡すことをお勧めします。

# コンテナイメージの互換性
<a name="train-remote-decorator-container"></a>

次の表は、@remote デコレータと互換性のある SageMaker トレーニングイメージのリストを示しています。


| 名前 | Python バージョン | イメージ URI - CPU | イメージ URI - GPU | 
| --- | --- | --- | --- | 
|  データサイエンス  |  3.7(py37)  |  SageMaker Studio Classic ノートブックのみ。SageMaker Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではイメージ URI を自動的に選択します。  |  SageMaker Studio Classic ノートブックのみ。SageMaker Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではイメージ URI を自動的に選択します。  | 
|  Data Science 2.0  |  3.8(py38)  |  SageMaker Studio Classic ノートブックのみ。SageMaker Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではイメージ URI を自動的に選択します。  |  SageMaker Studio Classic ノートブックのみ。SageMaker Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではイメージ URI を自動的に選択します。  | 
|  Data Science 3.0  |  3.10(py310)  |  SageMaker Studio Classic ノートブックのみ。SageMaker Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではイメージ URI を自動的に選択します。  |  SageMaker Studio Classic ノートブックのみ。SageMaker Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではイメージ URI を自動的に選択します。  | 
|  Base Python 2.0  |  3.8(py38)  |  開発環境で Python 3.8 ランタイムを使用されていることを検出したとき、Python SDK ではこのイメージを選択します。それ以外の場合、SageMaker Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではこのイメージを自動的に選択します。  |  SageMaker Studio Classic ノートブックのみ。SageMaker Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではイメージ URI を自動的に選択します。  | 
|  Base Python 3.0  |  3.10(py310)  |  開発環境で Python 3.8 ランタイムを使用されていることを検出したとき、Python SDK ではこのイメージを選択します。それ以外の場合、SageMaker Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではこのイメージを自動的に選択します。  |  SageMaker Studio Classic ノートブックのみ。Studio Classic ノートブックのカーネルイメージとして使用されたとき、Python SDK ではイメージ URI を自動的に選択します。  | 
|  SageMaker トレーニング用 DLC-TensorFlow 2.12.0  |  3.10(py310)  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.12.0-cpu-py310-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.12.0-gpu-py310-cu118-ubuntu20.04-sagemaker  | 
|  SageMaker トレーニング用 DLC-Tensorflow 2.11.0  |  3.9(py39)  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.11.0-cpu-py39-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.11.0-gpu-py39-cu112-ubuntu20.04-sagemaker  | 
|  SageMaker トレーニング用 DLC-TensorFlow 2.10.1  |  3.9(py39)  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.10.1-cpu-py39-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.10.1-gpu-py39-cu112-ubuntu20.04-sagemaker  | 
|  SageMaker トレーニング用 DLC-TensorFlow 2.9.2  |  3.9(py39)  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.9.2-cpu-py39-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.9.2-gpu-py39-cu112-ubuntu20.04-sagemaker  | 
|  SageMaker トレーニング用 DLC-TensorFlow 2.8.3  |  3.9(py39)  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.8.3-cpu-py39-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/tensorflow-training:2.8.3-gpu-py39-cu112-ubuntu20.04-sagemaker  | 
|  SageMaker トレーニング用 DLC-PyTorch 2.0.0  |  3.10(py310)  |  763104351884.dkr.ecr.<region>.amazonaws.com/pytorch-training:2.0.0-cpu-py310-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/pytorch-training:2.0.0-gpu-py310-cu118-ubuntu20.04-sagemaker  | 
|  SageMaker トレーニング用 DLC-PyTorch 1.13.1  |  3.9(py39)  |  763104351884.dkr.ecr.<region>.amazonaws.com/pytorch-training:1.13.1-cpu-py39-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/pytorch-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker  | 
|  SageMaker トレーニング用 DLC-PyTorch 1.12.1  |  3.8(py38)  |  763104351884.dkr.ecr.<region>.amazonaws.com/pytorch-training:1.12.1-cpu-py38-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/pytorch-training:1.12.1-gpu-py38-cu113-ubuntu20.04-sagemaker  | 
|  SageMaker トレーニング用 DLC-PyTorch 1.11.0  |  3.8(py38)  |  763104351884.dkr.ecr.<region>.amazonaws.com/pytorch-training:1.11.0-cpu-py38-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/pytorch-training:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker  | 
|  SageMaker トレーニング用 DLC-MXNet 1.9.0  |  3.8(py38)  |  763104351884.dkr.ecr.<region>.amazonaws.com/mxnet-training:1.9.0-cpu-py38-ubuntu20.04-sagemaker  |  763104351884.dkr.ecr.<region>.amazonaws.com/mxnet-training:1.9.0-gpu-py38-cu112-ubuntu20.04-sagemaker  | 

**注記**  
 AWS Deep Learning Containers (DLC) イメージを使用してローカルでジョブを実行するには、[DLC ドキュメント](https://github.com/aws/deep-learning-containers/blob/master/available_images.md)にあるイメージ URIs を使用します。DLC イメージは依存関係の `auto_capture` 値をサポートしていません。  
[SageMaker Studio で SageMaker AI ディストリビューション](https://github.com/aws/sagemaker-distribution#amazon-sagemaker-studio)を使用するジョブは、`sagemaker-user` という名前の非ルートユーザーとしてコンテナで実行されます。このユーザーは、`/opt/ml` と `/tmp` にアクセスするための完全なアクセス許可が必要です。次のスニペットに示すように、`sudo chmod -R 777 /opt/ml /tmp` を `pre_execution_commands` リストに追加して、このアクセス許可を付与します。  

```
@remote(pre_execution_commands=["sudo chmod -R 777 /opt/ml /tmp"])
def func():
    pass
```

カスタムイメージを使用してリモート機能を実行することもできます。リモート関数との互換性を保つため、カスタムイメージは Python バージョン 3.7.x-3.10.x を使用してビルドされる必要があります。以下は、Python 3.10 による Docker イメージを使用する方法を示す最小限の Dockerfile サンプルです。

```
FROM python:3.10

#... Rest of the Dockerfile
```

イメージ内に `conda` 環境を作成し、それを使用してジョブを実行するには、環境変数 `SAGEMAKER_JOB_CONDA_ENV` を `conda` 環境名に設定します。イメージに `SAGEMAKER_JOB_CONDA_ENV` 値が設定されている場合、リモート関数はトレーニングジョブの実行中に新しい conda 環境を作成できません。Python バージョン 3.10 の `conda` 環境を使用する次の Dockerfile の例を参照してください。

```
FROM continuumio/miniconda3:4.12.0  

ENV SHELL=/bin/bash \
    CONDA_DIR=/opt/conda \
    SAGEMAKER_JOB_CONDA_ENV=sagemaker-job-env

RUN conda create -n $SAGEMAKER_JOB_CONDA_ENV \
   && conda install -n $SAGEMAKER_JOB_CONDA_ENV python=3.10 -y \
   && conda clean --all -f -y \
```

SageMaker AI が [mamba](https://mamba.readthedocs.io/en/latest/user_guide/mamba.html) を使用してコンテナイメージ内の Python 仮想環境を管理する場合、[miniforge から mamba ツールキット](https://github.com/conda-forge/miniforge)をインストールします。mamba を使用するには、以下のコードサンプルを Dockerfile に追加します。次に、SageMaker AI は実行時に `mamba` の使用可否を検出し、`conda` の代わりにそれを使用します。

```
#Mamba Installation
RUN curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Mambaforge-Linux-x86_64.sh" \
    && bash Mambaforge-Linux-x86_64.sh -b -p "/opt/conda"  \
    && /opt/conda/bin/conda init bash
```

Amazon S3 バケットでカスタム conda チャネルを使用すると、リモート関数の使用時に mamba を使用できなくなります。mamba を使用する場合は、Amazon S3 でカスタム conda チャネルを使用していないことを確認してください。詳細については、「**Custom conda repository using Amazon S3**」の「**前提条件**」セクションを参照してください。

以下は、互換性がある Docker イメージを作成する方法を示す Dockerfile の完全な例です。

```
FROM python:3.10

RUN apt-get update -y \
    # Needed for awscli to work
    # See: https://github.com/aws/aws-cli/issues/1957#issuecomment-687455928
    && apt-get install -y groff unzip curl \
    && pip install --upgrade \
        'boto3>1.0<2' \
        'awscli>1.0<2' \
        'ipykernel>6.0.0<7.0.0' \
#Use ipykernel with --sys-prefix flag, so that the absolute path to 
    #/usr/local/share/jupyter/kernels/python3/kernel.json python is used
    # in kernelspec.json file
    && python -m ipykernel install --sys-prefix

#Install Mamba
RUN curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Mambaforge-Linux-x86_64.sh" \
    && bash Mambaforge-Linux-x86_64.sh -b -p "/opt/conda"  \
    && /opt/conda/bin/conda init bash

#cleanup
RUN apt-get clean \
    && rm -rf /var/lib/apt/lists/* \
    && rm -rf ${HOME}/.cache/pip \
    && rm Mambaforge-Linux-x86_64.sh

ENV SHELL=/bin/bash \
    PATH=$PATH:/opt/conda/bin
```

 前述の Dockerfile サンプルを実行して生成されたイメージは、[SageMaker Studio Classic カーネルイメージ](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-byoi.html)として使用することもできます。

# Amazon SageMaker Experiments によるパラメータとメトリクスの記録
<a name="train-remote-decorator-experiments"></a>

このガイドでは、Amazon SageMaker Experiments を使用してパラメータとメトリクスを記録する方法を説明します。SageMaker AI 実験は実行で構成され、実行はモデルトレーニングの 1 回のインタラクションのすべての入力、パラメータ、構成、結果で構成されます。

@remote デコレータまたは `RemoteExecutor` API を使用して、リモート関数からパラメータとメトリクスを記録できます。

リモート関数からパラメータとメトリクスを記録するには、以下の方法のいずれかを選択します。
+ SageMaker Experiments ライブラリから `Run` を使用して、リモート関数内で実行された SageMaker AI 実験をインスタンス化します。詳細については、「[Create an Amazon SageMaker AI Experiment](https://docs.aws.amazon.com/sagemaker/latest/dg/experiments-create.html)」を参照してください。
+ SageMaker AI Experiments ライブラリのリモート関数内で `load_run` 関数を使用します。これにより、リモート関数の外部で宣言された `Run` インスタンスがロードされます。

以下のセクションでは、前述の方法を使用して SageMaker AI 実験の実行を使用して系統を作成および追跡する方法を示します。また、SageMaker トレーニングではサポートされていないケースについても説明します。

## @remote デコレータを使用して SageMaker Experiments と統合する
<a name="train-remote-decorator-experiments-remote"></a>

SageMaker AI で実験をインスタンス化するか、またはリモート関数内部から現在の SageMaker AI 実験を読み込むことができます。以下のセクションでは、いずれかの方法を使用する方法を示します。

### SageMaker Experiments を使用して実験を作成する
<a name="train-remote-decorator-experiments-remote-create"></a>

SageMaker AI 実験で実行される実験を作成できます。これを行うには、実験名、実行名、その他のパラメータをリモート関数に渡します。

次のコードサンプルでは、実験の名前、実行の名前、各実行中に記録するパラメータをインポートします。パラメータ `param_1` および `param_2` は、トレーニングループ内で経時的に記録されます。一般的なパラメータには、バッチサイズやエポックなどが含まれています。この例では、実行のメトリクス `metric_a` および `metric_b` がトレーニングループ内で経時的に記録されます。その他の一般的なメトリクスには、`accuracy` または `loss` が含まれる場合があります。

```
from sagemaker.remote_function import remote
from sagemaker.experiments.run import Run

# Define your remote function
@remote
def train(value_1, value_2, exp_name, run_name):
    ...
    ...
    #Creates the experiment
    with Run(
        experiment_name=exp_name,
        run_name=run_name,
    ) as run:
        ...
        #Define values for the parameters to log
        run.log_parameter("param_1", value_1)
        run.log_parameter("param_2", value_2) 
        ...
        #Define metrics to log
        run.log_metric("metric_a", 0.5)
        run.log_metric("metric_b", 0.1)


# Invoke your remote function        
train(1.0, 2.0, "my-exp-name", "my-run-name")
```

### @remote デコレータによって開始されたジョブを使用して現在の SageMaker Experiments を読み込む
<a name="train-remote-decorator-experiments-remote-current"></a>

SageMaker Experiments ライブラリの `load_run()` 関数を使用して、実行コンテキストから現在の実行オブジェクトを読み込みます。`load_run()` 関数は、リモート関数内でも使用できます。次のコード例に示すように、実行オブジェクトの `with` ステートメントによってローカルで初期化された実行オブジェクトを読み込みます。

```
from sagemaker.experiments.run import Run, load_run

# Define your remote function
@remote
def train(value_1, value_2):
    ...
    ...
    with load_run() as run:
        run.log_metric("metric_a", value_1)
        run.log_metric("metric_b", value_2)


# Invoke your remote function
with Run(
    experiment_name="my-exp-name",
    run_name="my-run-name",
) as run:
    train(0.5, 1.0)
```

## `RemoteExecutor` API で開始されたジョブ内の現在の実験実行を読み込む
<a name="train-remote-decorator-experiments-api"></a>

ジョブが `RemoteExecutor` API で開始された場合も、現在の SageMaker AI 実験を読み込むことができます。次のコードサンプルは、SageMaker Experiments `load_run` 関数で `RemoteExecutor` API を使用する方法を示しています。これにより、現在の SageMaker AI 実験実行を読み込み、`RemoteExecutor` によって送信されたジョブのメトリクスをキャプチャできます。

```
from sagemaker.experiments.run import Run, load_run

def square(x):
    with load_run() as run:
        result = x * x
        run.log_metric("result", result)
    return result


with RemoteExecutor(
    max_parallel_job=2,
    instance_type="ml.m5.large"
) as e:
    with Run(
        experiment_name="my-exp-name",
        run_name="my-run-name",
    ):
        future_1 = e.submit(square, 2)
```

## @remote デコレータでコードに注釈を付ける際に SageMaker Experiments のサポートされていない使用法を実行する
<a name="train-remote-decorator-experiments-unsupported"></a>

SageMaker AI は、@remote 関数に `Run` 型オブジェクトを渡したり、グローバル `Run` オブジェクトを使用したりする操作をサポートしていません。以下の例は、`SerializationError` をスローするコードを示しています。

次のコードサンプルでは、`Run` 型オブジェクトを @remote デコレータに渡そうとするとエラーが生成されます。

```
@remote
def func(run: Run):
    run.log_metrics("metric_a", 1.0)
    
with Run(...) as run:
    func(run) ---> SerializationError caused by NotImplementedError
```

次のコード例では、リモート関数の外部でインスタンス化されたグローバル `run` オブジェクトを使用しようとしています。このコード例では、`train()` 関数は `with Run` コンテキスト内で定義され、内部からグローバル実行オブジェクトを参照します。`train()` が呼び出されると、エラーが生成されます。

```
with Run(...) as run:
    @remote
    def train(metric_1, value_1, metric_2, value_2):
        run.log_parameter(metric_1, value_1)
        run.log_parameter(metric_2, value_2)
    
    train("p1", 1.0, "p2", 0.5) ---> SerializationError caused by NotImplementedError
```

# モジュラーコードと @remote デコレータの使用
<a name="train-remote-decorator-modular"></a>

開発中、ワークスペース管理が容易になるようにコードをモジュールに整理し、@remote 関数を使用して関数を呼び出すことができます。ローカルモジュールを開発環境からリモートジョブ環境にレプリケートすることもできます。このためには、次のコードサンプルに示すように、パラメータ `include_local_workdir` を `True` に設定します。

```
@remote(
  include_local_workdir=True,
)
```

**注記**  
@remote デコレータとパラメータは、どの依存ファイルでもなく、メインファイルに含まれる必要があります。

`include_local_workdir` が `True` に設定されると、SageMaker AI はプロセスの現在のディレクトリのディレクトリ構造を維持したまま、すべての Python スクリプトをパッケージ化します。また、ジョブの作業ディレクトリでも依存関係を利用できるようになります。

例えば、MNIST データセットを処理する Python スクリプトが `main.py` スクリプトと依存 `pytorch_mnist.py` スクリプトに分割されるとします。 `main.py` は依存スクリプトを呼び出します。また、`main.py` スクリプトには、図のように依存関係をインポートするコードが含まれています。

```
from mnist_impl.pytorch_mnist import ...
```

`main.py` ファイルには `@remote` デコレータも含まれている必要があり、`include_local_workdir` パラメータを `True` に設定する必要があります。

デフォルトでは、`include_local_workdir` パラメータにはディレクトリ内のすべての Python スクリプトが含まれます。このパラメータを `custom_file_filter` パラメータと組み合わせて使用することで、ジョブにアップロードするファイルをカスタマイズできます。S3 にアップロードするジョブの依存関係をフィルタリングする関数、またはリモート関数で無視するローカルディレクトリとファイルを指定する `CustomFileFilter` オブジェクトを渡すことができます。`include_local_workdir` が `True` に設定されている場合にのみ `custom_file_filter` を使用できます。そう出ない場合、パラメータは無視されます。

次の例では、`CustomFileFilter` を使用して、S3 にファイルをアップロードするときに、`data` という名前のすべてのノートブックファイルとフォルダまたはファイルを無視します。

```
@remote(
   include_local_workdir=True,
   custom_file_filter=CustomFileFilter(
      ignore_name_patterns=[ # files or directories to ignore
        "*.ipynb", # all notebook files
        "data", # folter or file named data
      ]
   )
)
```

次の例は、ワークスペース全体をパッケージ化する方法を示しています。

```
@remote(
   include_local_workdir=True,
   custom_file_filter=CustomFileFilter(
      ignore_pattern_names=[] # package whole workspace
   )
)
```

次の例は、関数を使用してファイルをフィルタリングする方法を示しています。

```
import os

def my_filter(path: str, files: List[str]) -> List[str]:
    to_ignore = []
   for file in files:
       if file.endswith(".txt") or file.endswith(".ipynb"):
           to_ignore.append(file)
   return to_ignore

@remote(
   include_local_workdir=True,
   custom_file_filter=my_filter
)
```

## 作業ディレクトリ構築のベストプラクティス
<a name="train-remote-decorator-modular-bestprac"></a>

以下のベストプラクティスは、モジュラーコードで `@remote` デコレータを使用しながらディレクトリ構造を整理する方法の提案です。
+ @remote デコレータを、ワークスペースのルートレベルディレクトリにあるファイルに配置します。
+ ローカルモジュールをルートレベルで構築します。

以下のイメージ例は、推奨ディレクトリ構造を示しています。この例の構造では、`main.py` スクリプトはルートレベルのディレクトリにあります。

```
.
├── config.yaml
├── data/
├── main.py <----------------- @remote used here 
├── mnist_impl
│ ├── __pycache__/
│ │ └── pytorch_mnist.cpython-310.pyc
│ ├── pytorch_mnist.py <-------- dependency of main.py
├── requirements.txt
```

以下のイメージ例は、@remote デコレータでコードに注釈を付けるために使用すると動作の一貫性が損なわれるディレクトリ構造を示しています。

この構造例では、@remote デコレータを含んでいる `main.py` スクリプトは、ルートレベルのディレクトリに**ありません**。次のような構造はお勧め**しません**。

```
.
├── config.yaml
├── entrypoint
│ ├── data
│ └── main.py <----------------- @remote used here
├── mnist_impl
│ ├── __pycache__
│ │ └── pytorch_mnist.cpython-310.pyc
│ └── pytorch_mnist.py <-------- dependency of main.py
├── requirements.txt
```

# ランタイム依存関係用のプライベートリポジトリ
<a name="train-remote-decorator-private"></a>

実行前コマンドまたはスクリプトを使用すると、ジョブ環境で pip や conda などの依存関係マネージャを設定できます。ネットワーク分離を実現するには、これらのオプションのいずれかを使用して依存関係マネージャをリダイレクトし、プライベートリポジトリにアクセスして、VPC 内のリモート関数を実行します。実行前のコマンドまたはスクリプトは、リモート関数が実行される前に実行されます。これらのコマンドまたはスクリプトは、@remote デコレータまたは `RemoteExecutor` API を使用するか、設定ファイル内で定義できます。

以下のセクションでは、 で管理されているプライベート Python パッケージインデックス (PyPI) リポジトリにアクセスする方法を示します AWS CodeArtifact。また、このセクションでは、Amazon Simple Storage Service (Amazon S3) でホストされているカスタム conda チャネルにアクセスする方法についても説明します。

## AWS CodeArtifact で管理されるカスタム PyPI リポジトリの使用方法
<a name="train-remote-decorator-private-pypi"></a>

CodeArtifact を使用してカスタム PyPI リポジトリを管理する前提条件として、以下が必要です。
+ プライベート PyPI リポジトリが作成済みである必要があります。 AWS CodeArtifact を使用して、プライベートパッケージリポジトリを作成および管理できます。CodeArtifact の詳細については、『[CodeArtifact ユーザーガイド](https://docs.aws.amazon.com/codeartifact/latest/ug/welcome.html)』を参照してください。
+ VPC が CodeArtifact リポジトリにアクセスできる必要があります。VPC から CodeArtifact リポジトリへの接続を許可するには、以下を実行する必要があります。
  + [CodeArtifact 用の VPC エンドポイントを作成する。](https://docs.aws.amazon.com/codeartifact/latest/ug/create-vpc-endpoints.html)
  + [VPC 用の Amazon S3 ゲートウェイエンドポイントを作成する](https://docs.aws.amazon.com/codeartifact/latest/ug/create-s3-gateway-endpoint.html)。これにより、CodeArtifact ではパッケージアセットを保存できるようになります。

以下の実行前コマンドの例は、SageMaker AI トレーニングジョブの pip が CodeArtifact リポジトリを指すように設定する方法を示しています。詳細については、「[Configure and use pip with CodeArtifact](https://docs.aws.amazon.com/codeartifact/latest/ug/python-configure-pip.html)」を参照してください。

```
# use a requirements.txt file to import dependencies
@remote(
    instance_type="ml.m5.large"
    image_uri = "my_base_python:latest", 
    dependencies = './requirements.txt',
    pre_execution_commands=[
        "aws codeartifact login --tool pip --domain my-org --domain-owner <000000000000> --repository my-codeartifact-python-repo --endpoint-url https://vpce-xxxxx.api.codeartifact.us-east-1.vpce.amazonaws.com"
    ]
)
def matrix_multiply(a, b):
    return np.matmul(a, b)
```

## Amazon S3 でホストされているカスタム conda チャネルを使用する方法
<a name="train-remote-decorator-private-conda"></a>

Amazon S3 を使用してカスタム conda リポジトリを管理する前提条件として、以下が必要です。
+ プライベート conda チャネルが Amazon S3 バケットであらかじめ設定され、すべての依存パッケージはインデックスが作成されて Amazon S3 バケットにアップロードされている必要があります。conda パッケージのインデックスを作成する方法については、「[カスタムチャネルの作成](https://conda.io/projects/conda/en/latest/user-guide/tasks/create-custom-channels.html)」を参照してください。
+ VPC が Amazon S3 バケットにアクセスできる必要があります。詳細については、[Amazon S3 のエンドポイント](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html)を参照してください。
+ ジョブイメージの Base Conda 環境に `boto3` がインストールされている必要があります。環境を確認するには、Anaconda プロンプトに次のように入力して、生成されたリストに `boto3` が表示されることを確認します。

  ```
  conda list -n base
  ```
+ ジョブイメージは [mamba](https://mamba.readthedocs.io/en/latest/installation.html) ではなく conda を使用してインストールする必要があります。環境を確認するには、前のコードプロンプトによって `mamba` が返されないことを確認します。

以下の実行前コマンドの例は、SageMaker トレーニングジョブの conda が Amazon S3 のプライベートチャンネルを指すように設定する方法を示しています。実行前コマンドは、デフォルトチャンネルを削除し、カスタムチャンネルを `.condarc` conda 設定ファイルに追加します。

```
# specify your dependencies inside a conda yaml file
@remote(
    instance_type="ml.m5.large"
    image_uri = "my_base_python:latest", 
    dependencies = "./environment.yml",
    pre_execution_commands=[
        "conda config --remove channels 'defaults'"
        "conda config --add channels 's3://my_bucket/my-conda-repository/conda-forge/'",
        "conda config --add channels 's3://my_bucket/my-conda-repository/main/'"
    ]
)
def matrix_multiply(a, b):
    return np.matmul(a, b)
```

# サンプルノートブックの例
<a name="train-remote-decorator-examples"></a>

既存のワークスペース環境のトレーニングコードと関連するデータ処理コードおよびデータセットを SageMaker トレーニングジョブに変換できます。以下のノートブックでは、XGBoost アルゴリズムと Hugging Face を使用して、画像分類の問題に合わせて環境やジョブ設定などをカスタマイズする方法を示します。

[quick\$1start ノートブック](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb)には以下のコードサンプルが含まれています。
+ 設定ファイルを使用してジョブ設定をカスタマイズする方法。
+ Python 関数をジョブとして非同期的に呼び出す方法。
+ 追加の依存関係を導入してジョブのランタイム環境をカスタマイズする方法。
+ @remote 関数メソッドでローカル依存関係を使用する方法。

以下のノートブックは、さまざまな機械学習問題の種類と実装の追加のコード例を示しています。
+ 画像分類問題に @remote デコレータを使用するコード例を確認するには、[pytorch\$1mnist.ipynb](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-remote-function/pytorch_mnist_sample_notebook) ノートブックを開きます。この分類問題では、MNIST (Modified National Institute of Standards and Technology) サンプルデータセットを使用して、手書きの数字を認識します。
+ スクリプトに関連する前述の画像分類問題に @remote デコレータを使用するコード例については、Pytorch MNIST サンプルスクリプト、[train.py](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-remote-function/pytorch_mnist_sample_script) を参照します。
+ @remote デコレータを使用してどのように XGBoost アルゴリズムが実装されたかを確認するには、[xgboost\$1abalone.ipynb](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-remote-function/xgboost_abalone) ノートブックを開きます。
+ Hugging Face が @remote デコレータとどのように統合されているかを確認するには、[huggingface.ipynb](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-remote-function/huggingface_text_classification) ノートブックを開きます。