API: ModelAdapter リファレンス

モデルアダプタは、公開されたPythonライブラリで、Foundryと保存されたモデル作成物との間の通信レイヤーを提供し、Foundryが任意のモデルをロード、初期化、推論実行することを可能にします。

ModelAdapterを実装するには、以下に示すクラスを理解する必要があります：

ModelAdapter の実装

ModelAdapterクラスは、すべてのモデルアダプタの実装が拡張しなければならない抽象基本クラスです。すべてのモデルアダプタが実装しなければならない4つの抽象メソッドがあります：

1. load()
2. save()
   • デフォルトのシリアライザで定義されたモデルアダプタには、load()とsave()は必要ありません。
3. api()
4. predict() は単一出力のため、run_inference() は複数出力のため

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import palantir_models as pm
import models_api.models_api_executable as executable_api

class ExampleModelAdapter(pm.ModelAdapter):

    @classmethod
    def load(
        cls,
        state_reader: pm.ModelStateReader,
        container_context: Optional[executable_api.ContainerizedApplicationContext] = None,
        external_model_context: Optional[executable_api.ExternalModelExecutionContext] = None
    ) -> "pm.ModelAdapter":
        """
        Pythonまたはバイナリモデル:
            これは、FoundryがModelAdapterをデシリアライズするために呼び出すメソッドです。このModelAdapterの作者は、モデルの状態をロードし、モデルを初期化するためのロジックを書くことが期待されています。

        コンテナモデル:
            これは、FoundryがModelAdapterのサイドカーとしてコンテナを起動した後に呼び出すメソッドです。このModelAdapterの作者は、アダプタが必要とするクラス変数を初期化するために、container_contextの内容を使用することが期待されています。

        外部ホストモデル:
            これは、モデルアダプタが初期化されたときにFoundryが呼び出すメソッドです。このModelAdapterの作者は、外部ホストモデルへの接続を初期化し、持続化するためのロジックを書くことが期待されています。

        :param state_reader: モデルファイルを読み取るために使用できるModelStateReaderオブジェクト。
        :param container_context: これはコンテナバックドモデルのためだけに提供され、デフォルトはNoneです。コンテナコンテキストは、コンテナ名からサービスURIへのマッピングと共有ディレクトリマウントパスを含みます。
        :param external_model_context: これは外部ホストモデルのためだけに提供され、デフォルトはNoneです。external_model_contextには、このModel Adapterを使用する外部ホストモデルを作成するときにユーザーが定義した設定への参照が含まれています。

        :return: ModelAdapterのインスタンス。
        """

    def save(self, state_writer: pm.ModelStateWriter) -> None:
        """
        これは、Foundryがモデルアダプタをシリアライズするために呼び出すメソッドです。このメソッドは、このModelAdapterがFoundryで新しく訓練されたか再フィットされたモデルをラップするために使用される場合にのみ必要です。

        このModelAdapterの作者は、訓練済みモデルの状態と関連メタデータをModelStateWriterに保存するためのロジックを書くことが期待されています。

        :param state_writer: モデルがシリアライズされ保存されるModelStateWriterオブジェクト。
        """

    @classmethod
    def api(cls) -> pm.ModelApi:
        """
        これは、このモデルの期待される入力と出力のデータ構造を定義します。

        :return: モデルのModelApiオブジェクト
        """

    def run_inference(self, inputs, outputs) -> None:
        """
        このメソッドは、ModelAdapter.apiメソッドで定義された関連する入力と出力を持って呼び出されます。

        関連するモデルで推論を実行します。

        :param inputs: ModelAdapter.apiメソッドで定義された入力の名前付きタプル。
        :param outputs: ModelAdapter.apiメソッドで定義された出力の名前付きタプル。
          出力はrun_inferenceメソッド内で書き込まれるべきです。
        """

    def predict(self, *args, **kwargs) -> Union[Tabular, Parameter]:
        """
        このメソッドは、複数 (>=1) の入力から単一の出力 (表形式またはパラメータ) モデルに対する推論を実行するために使用されます。
        入力は、api()メソッドでそれらを定義する名前でこのメソッドのシグネチャに書き込まれることが期待されています。結果の出力はこのメソッドによって返されます。

        predict()が使用される場合、ユーザーによってrun_inference()メソッドは定義されません。
        """

モデルの save() と load()

palantir_models_serializers ライブラリは、一般的なモデリングフレームワークのモデルのシリアル化（保存）とデシリアル化（読み込み）に使用できる多くのデフォルトのシリアライザを提供しています。

場合によっては、ユーザーがモデルのシリアル化またはデシリアル化のためのカスタムロジックを実装したいと思うこともあるでしょう。たとえば、ユーザーが使用しているモデリングフレームワークに対するデフォルトのシリアライザがない場合や、任意の時点でメモリにロードされるモデルを手動で制御する必要がある場合などです。

これらのより複雑なケースでは、以下の save と load の実装を参照してください。

Save

ModelStateWriter

ModelStateWriter は、ModelAdapter.save メソッドに提供され、ModelAdapter がモデルの作成物を Foundry ストレージに保存/シリアル化できるようにします。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# ModelStateWriterはpalantir_models.modelsからインポートできます

from io import IOBase
from typing import ContextManager

class ModelStateWriter:
    def open(self, asset_file_path: str, mode: str = "wb") -> ContextManager[IOBase]:
        """
        モデルのアーティファクトとパラメータをシリアライズするためのファイルライクなオブジェクトを開きます。
        """

    def put_file(self, local_file_path, asset_file_path=None):
        """
        このモデルのリポジトリにローカルファイルを配置します。
        :param asset_file_path: 提供された場合、ファイルはリポジトリのこのパスに配置されます。
            それ以外の場合、ファイルはリポジトリのルートディレクトリに配置されます。
        """

    def put_directory(self, local_root_path, asset_root_path = "/"):
        """
        ローカルディレクトリとその内容をこのモデルのリポジトリに配置します。
        :param asset_root_path: このディレクトリを配置するためのリポジトリのルートパスに対する相対パス。
        """

save()メソッドは、model.publish()を通じてトランスフォームでモデルアダプタが公開されるたびに呼び出され、その際にModelStateWriterの内容がzipファイルにパッケージ化され、新たに作成されたモデルバージョンが参照する作成物リポジトリに永続化されます。

例：ModelStateWriter

以下の例は、モデルをmodel.pklファイルとして保存します。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# palantir_models.modelsからModelAdapter, ModelStateWriterをインポートします
from palantir_models.models import ModelAdapter, ModelStateWriter

# ExampleModelAdapterという名前のクラスを定義します。このクラスはModelAdapterを継承しています。
class ExampleModelAdapter(ModelAdapter):
    # 初期化メソッドを定義します。引数としてmodelを受け取ります。
    def __init__(self, model):
        # 受け取ったmodelをインスタンス変数として保存します。
        self.model = model

    # ...

    # saveという名前のメソッドを定義します。引数としてstate_writerを受け取ります。
    def save(self, state_writer: ModelStateWriter):
        # state_writerのopenメソッドを使って、"model.pkl"という名前のファイルをバイナリ書き込みモードで開きます。
        with state_writer.open("model.pkl", "wb") as model_outfile:
            # pickleモジュールのdump関数を使って、modelをmodel_outfileに保存します。
            pickle.dump(self.model, model_outfile)

    # ...

Load

ModelStateReader

ModelStateReaderは、ModelAdapter.load メソッドに提供され、ModelAdapter が保存されたモデルの作成物を読み込み／デシリアライズし、モデルを初期化することができます。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# ModelStateReaderはpalantir_models.modelsからインポートできます
from tempfile import TemporaryDirectory

class ModelStateReader:
    def open(self, asset_file_path: str, mode: str = "rb") -> ContextManager[IOBase]:
        """
        モデルのアーティファクトとパラメータをデシリアライズするためのファイルライクなオブジェクトを開きます。
        """

    def extract_to_temp_dir(self, root_dir: str = None) -> AnyStr:
        """
        このモデルに関連するモデルのアーティファクトを含むTempDirectoryを返します。
        :param root_dir: 指定した場合、エクストラクトのルートディレクトリ
        """

    def extract(self, destination_path: str = None) -> None:
        """
        リポジトリを指定されたローカルディレクトリパスに抽出します。
        :param destination_path: 指定した場合、リポジトリが抽出されるディレクトリ
        """

load()メソッドは、モデルアダプターがインスタンス化されるたびに呼び出されます（トランスフォーム内のModelInput経由、またはモデルによってバックアップされたライブデプロイメントまたはバッチデプロイメントを開始する場合）。このメソッドは、ModelStateWriterが書き込むのと同じ作成物リポジトリにアクセスし、その内容にModelStateReader経由でアクセスを提供します。load()は、すべてのトランスフォームや推論ロジックが実行される前に呼び出されます。

例：ModelStateReader

次の例では、モデルファイルをロードし、それで初期化されたモデルアダプターのインスタンスを返します。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# palantir_models.modelsからModelAdapterとModelStateReaderをインポートします
from palantir_models.models import ModelAdapter, ModelStateReader

# ExampleModelAdapterクラスを定義します。このクラスはModelAdapterを継承しています
class ExampleModelAdapter(ModelAdapter):
    # 初期化メソッドを定義します
    def __init__(self, model):
        # modelをインスタンス変数として保持します
        self.model = model

    # クラスメソッドとしてloadメソッドを定義します。このメソッドはModelStateReaderインスタンスを引数に取ります
    @classmethod
    def load(cls, state_reader: ModelStateReader):
        # state_readerを使って"model.pkl"をバイナリ読み込みモードで開きます
        with state_reader.open("model.pkl", "rb") as model_infile:
            # pickleを使ってモデルを読み込みます
            model = pickle.load(model_infile)
        # 読み込んだモデルを持ったExampleModelAdapterインスタンスを生成し、それを返します
        return cls(model)

    ...

上記で示された save() メソッドと併用すると、このメソッドは save() メソッドで永続化された同じ model.pkl オブジェクトを取得します。ModelStateReader オブジェクトもコンテナを利用したモデルに提供され、ユーザーがアップロードした zip ファイルによって支えられています。

ContainerizedApplicationContext

ContainerizedApplicationContext はオプションで、モデルがコンテナイメージまたはイメージによって支えられている場合に限り、ModelAdapter.load メソッドに提供されます。コンテキストオブジェクトには共有ディレクトリマウントパスと、コンテナ名からそのサービス URI へのマッピングが含まれています。各コンテナは複数のサービス URI を持つことができ、複数のポートを開くことは有効です。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
# このクラスタイプは著者が作成したアダプタ内でインポートする必要はありません
class ContainerizedApplicationContext:
    def services(self) -> Dict[str, List[str]]:
        """
        個々のコンテナ名から、そのコンテナが提供するサービスのURIのリストへのマッピング。
        """

    def shared_empty_dir_mount_path(self) -> str:
        """
        全てのコンテナとモデルアダプターで利用可能な共有空ディレクトリのマウントパス。
        このディレクトリはコンテナとモデルのエントリポイントから読み書きが可能です。
        """

例として、次のようにサービス変数が設定される場合があります：

Copied!
1
2
3
4
{
    "container1": ["localhost:8080"],  # "container1"という名前のコンテナは "localhost:8080" でアクセスできます。
    "container2": ["localhost:8080", "localhost:8081"],  # "container2"という名前のコンテナは "localhost:8080" または "localhost:8081" でアクセスできます。
}

例：ContainerizedApplicationContext

以下の例では、指定されたボリュームパス、ホスト、ポートを使用してモデルアダプターを初期化します。これは提供された ContainerizedApplicationContext から取得されます。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# モデルの適応と状態の読み取りに必要なパッケージをインポートします
from palantir_models.models import ModelAdapter, ModelStateReader
# モデルのAPIを実行可能な形式でインポートします
import models_api.models_api_executable as executable_api

# ExampleModelAdapterという名前の新しいクラスを作成します
class ExampleModelAdapter(ModelAdapter):
    def __init__(self, shared_volume_path, model_host_and_port):
        # 共有ボリュームへのパスを初期化します
        self.shared_volume_path = shared_volume_path
        # モデルのホストとポートを初期化します
        self.model_host_and_port = model_host_and_port

    @classmethod
    def load(cls, state_reader, container_context: executable_api.ContainerizedApplicationContext):
        # コンテナコンテキストから共有空ディレクトリのマウントパスを取得します
        shared_volume_path = container_context.shared_empty_dir_mount_path
        # コンテナコンテキストからサービス"container1"のホストとポートを取得します
        model_host_and_port = container_context.services["container1"][0]
        # 初期化したパラメータを使用して新しいクラスインスタンスを返します
        return cls(shared_volume_path, model_host_and_port)

    ...

ExternalModelContext

ExternalModelContext はオプションであり、モデルが外部ホスト型のモデルである場合、そしてその場合にのみ、ModelAdapter.load メソッドに提供されます。このコンテキストオブジェクトには、外部ホスト型モデルを表すオブジェクトと、この外部ホスト型モデルに接続するために必要な、ユーザー定義の復号化されたシークレットのマップが含まれます。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# このクラスタイプを作成するアダプター内でインポートする必要はありません
class ExternalModelContext:
    def external_model(self) -> models_api_external_ExternalModel:
        """
        主にbase_urlとconnection_configurationを含む、外部ホストされたモデルを表すオブジェクトです。
        """

    def resolved_credentials(self) -> Dict[str, str]:
        """
        この外部ホストされたモデルとの接続に必要な、ユーザー定義の解読された秘密値のマッピングです。
        """

# このクラスタイプを作成するアダプター内でインポートする必要はありません
class models_api_external_ExternalModel:
    def base_url(self) -> str:
        """
        この外部ホストされたモデルがホストされている場所を表すユーザー定義のURLです。
        """

    def connection_configuration(self) -> Dict[str, str]:
        """
        ユーザー定義の暗号化されていない設定フィールドの辞書です。
        これは、モデル名、推論パラメータ、予測閾値などの特定の設定詳細を保存することを意図しています。
        """

例：ExternalApplicationContext

次の例は、外部にホストされたモデルへのリクエストを実行するモデルアダプターを初期化します。外部にホストされたモデルの操作に関する詳細は、ドキュメンテーションを参照してください。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
from palantir_models.models import ModelAdapter, ModelStateReader
import models_api.models_api_executable as executable_api

class ExampleModelAdapter(ModelAdapter):
    def __init__(self, url, credentials_map, configuration_map):
        # "接続設定"マップからモデル設定を抽出します
        model_name = configuration_map['model_name']
        model_parameter = configuration_map['model_parameter']

        # "認証設定"マップからモデルの認証情報を抽出します
        secret_key = credentials_map['secret_key']

        # モデルロード時にhttpクライアントを初期化します
        self.client = ExampleClient(url, model_name, model_parameter, secret_key)

    @classmethod
    def load(
            cls,
            state_reader: ModelStateReader,
            container_context: Optional[executable_api.ContainerizedApplicationContext] = None,
            external_model_context: Optional[executable_api.ExternalModelExecutionContext] = None,
            ) -> "ModelAdapter":
        return cls(
            # 外部モデルの基本URLを指定します
            url=external_model_context.external_model.base_url,
            # 解決された認証情報を指定します
            credentials_map=external_model_context.resolved_credentials,
            # 接続設定を指定します
            configuration_map=external_model_context.external_model.connection_configuration,
        )

    ...

モデルAPI

モデルアダプターの api() メソッドは、このモデルアダプターの推論ロジックを実行するために期待される入力と出力を指定します。入力と出力は別々に指定されます。

例 api()

モデル入力

ModelInput タイプには、ModelAdapter.api メソッドで定義できる入力タイプが含まれています。モデルアダプターは次の入力タイプをサポートしています：

1. タブラー
2. パラメーター
3. ファイルシステム
4. MediaReference

注意：MediaReference のサポートは現在ベータ版であり、Python トランスフォームでの推論のみをサポートしています。モデルとの MediaReferences は、自動評価、バッチ展開、または Modeling Objectives アプリケーションでのライブ展開をサポートしていません。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# DFType, そして ModelInputは palantir_models.models.apiからインポートできます

class ModelInput:
    Tabular = TabularInput
    FileSystem = FileSystemInput
    Parameter = ParameterInput
    MediaReference = MediaReferenceInput

class TabularInput:
    def __init__(self, name: str, df_type: DFType = DFType.SPARK, columns: List[ModelApiColumn]):
        """
        ModelAdapterが表形式の入力を期待することを指定するために使用されます。
        この入力タイプは、適用可能な場合、表形式の入力を`df_type`で指定されたタイプに変換します。
        Pandasのデータフレーム、Sparkのデータフレーム、そしてTransformInputsは表形式の入力タイプとして認識されます。
        """

class ParameterInput:
    def __init__(self, name: str, type: type, default = None):
        """
        ModelAdapterがタイプ'type'の定数値パラメータを期待することを指定するために使用されます。
        パラメータ入力の利用可能なタイプは次の通りです: str, int, float, bool, list, set, dict, tuple.
        .transform()の引数に直接渡されない場合、提供されたデフォルト値が使用されます。
        """

class FileSystemInput:
    def __init__(self, name: str):
        """
        ModelAdapterがファイルシステム入力を期待することを指定するために使用されます。
        """

class MediaReferenceInput:
    def __init__(self, name: str):
        """
        ModelAdapterがメディアリファレンスを入力として期待することを指定するために使用されます。
        """

class DFType(Enum):
    SPARK = "spark"
    PANDAS = "pandas"

class ModelApiColumn(NamedTuple):
    """
    表形式の入力の列の名前とタイプを指定するために使用されます。
    """
    name: str
    type: type
    required: bool = True

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# ModelOutputはpalantir_models.models.apiからインポートすることができます

class ModelOutput:
    FileSystem = FileSystemOutput  # ファイルシステム出力を定義
    Parameter = ParameterOutput  # パラメータ出力を定義

class TabularOutput:
    def __init__(self, name: str):
        """
        ModelAdapterがタブラ出力を生成することを指定するために使用されます。
        タブラ出力タイプとしてサポートされているのはPandasまたはSparkのデータフレームのみです。
        """

class ParameterOutput:
    def __init__(self, name: str, type: type, default = None):
        """
        ModelAdapterが'type'型の定数値パラメータを生成することを指定するために使用します。
        パラメータ出力の可能な型は次のとおりです: str, int, float, bool, list, set, dict, tuple。
        `run_inference()`経由で書き込まれなかった場合、提供されたデフォルト値が使用されます。
        """

利用可能なモデル出力の両方は、それぞれの入力 counterpart と同様に動作します。主な違いの一つは、TabularOutputがdf_typeパラメーターを持っていないことです。これは、Pandas と Spark の両方のデータフレームを受け入れることができます。

モデル推論

predict() メソッド

テーブル型またはパラメーター型の単一出力を持つモデルについては、predict() メソッドを使用して、モデルアダプターの推論ロジックを定義することができます。このメソッドは、モデルアダプターの api() メソッドで定義された入力オブジェクトの名前を引数とします。引数が定義された順序を保持する必要はありませんが、名前は一致していなければなりません。

predict() メソッドの例

以下の例では、複数のテーブル入力、単一のテーブル出力モデルアダプターのための predict() メソッドを定義しています。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import palantir_models as pm

class ExampleModelAdapter(pm.ModelAdapter):
    ...

    @classmethod
    def api(cls):
        # 入力として2つのPandasデータフレームを定義
        inputs = {"input_1": pm.Pandas(), "input_2": pm.Pandas()}
        # 出力として1つのPandasデータフレームを定義
        outputs = {"output_dataframe": pm.Pandas()}
        return inputs, outputs

    def predict(self, input_1, input_2):
        # input_1とinput_2を使った推論ロジックをここで実行し、結果のデータフレームを生成
        resulting_dataframe = ... 
        return resulting_dataframe

上記の例では、2つの入力（input_1 と input_2）は predict() メソッドのシグネチャで名前によって参照されています。関数が返すデータフレーム、resulting_dataframe は、output_dataframe という名前の単一の出力に書き込まれます。

run_inference() メソッド

複数の出力を持つモデルや、ファイルシステムに書き込むモデルの場合、カスタム推論ロジックは run_inference() メソッドを通じて定義する必要があります。このメソッドは2つの引数、inputs と outputs を取ります。これらの引数は、api() メソッドで定義された入力と出力の name パラメーターに対応する NamedTuples です。

入力

名前で入力を参照すると、同じ名前の api() 入力に対応する model.transform() に渡されたオブジェクトにアクセスします。

例：入力

以下の ModelAdapter 定義を考えてみましょう：

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from palantir_models as pm

class ExampleModelAdapter(pm.ModelAdapter):
    ...

    @classmethod
    def api(cls):
        # 入力データの定義。df_inという名前のPandasデータフレームを想定。
        inputs = {
            "df_in": pm.Pandas([("input_feature", float)])
        }
        # 出力データの定義。df_out_oneとdf_out_twoという2つのPandasデータフレームを出力とする。
        outputs = {
            "df_out_one": pm.Pandas([("feature_one", int)]),
            "df_out_two": pm.Pandas([("output_feature_1", int),
                                     ("output_feature_2", float)])
        }
        return inputs, outputs

    def run_inference(self, inputs, outputs):
        # 入力データフレームの取得
        my_input_df = inputs.df_in

        # 出力データフレームの取得
        my_output_one = outputs.df_out_one
        my_output_two = outputs.df_out_two

    ...

そして、以下の .transform() への呼び出し：

Copied!
1
2
3
4
5
6
7
8
@transform(
    my_input_data=Input(...),  # 入力データを指定します。
    my_output_data_one=Output(...),  # 出力データ1を指定します。
    my_output_data_two=Output(...),  # 出力データ2を指定します。
    my_model=ModelInput(...)  # モデル入力を指定します。
)
def compute(my_input_data, my_output_data_one, my_output_data_two, my_model):
    my_model_outputs = my_model.transform(my_input_data)  # モデルを使って入力データを変換します。

モデルアダプターの run_inference() メソッドにある my_input_df オブジェクトは、Pandas型のタブラー入力である "input_dataframe" という名前の入力へのリファレンスであり、トランスフォームから渡される my_input_data TransformInputのpandas表現と等しくなります。

出力

出力を名前で参照すると、同じ名前の api() 出力に対応する書き込み可能なオブジェクトが提供されます。これらのオブジェクトは .write() メソッドを持ち、各出力にどのデータを書き込むかを指定します。

例：出力

以下のような ModelAdapter の定義があるとします：

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from palantir_models as pm

class ExampleModelAdapter(pm.ModelAdapter):
    ...

    # クラスメソッドのapiは、モデルの入力と出力を定義します
    @classmethod
    def api(cls):
        # 入力は浮動小数点型の特徴量を持つPandasデータフレームです
        inputs = {
            "input_dataframe": pm.Pandas([('input_feature', float)])
        }
        # 出力は整数型の特徴量を持つ2つのPandasデータフレームです
        outputs = {
            "output_dataframe_one": pm.Pandas([('output_feature', int)]),
            "output_dataframe_two": pm.Pandas([('output_feature', int)]),
        }
        return inputs, outputs

    # run_inferenceメソッドは、入力データフレームに何らかの処理を施し、新しい出力データフレームを生成します
    def run_inference(self, inputs, outputs):
        my_input_df = inputs.input_dataframe
        my_output_dataframe_one = do_something_to_input_and_return_a_new_dataframe(my_input_df)
        my_output_dataframe_two = do_something_else_to_input_and_return_a_new_dataframe(my_input_df)
        # 生成された出力データフレームを書き込みます
        outputs.output_dataframe_one.write(my_output_dataframe_one)
        outputs.output_dataframe_two.write(my_output_dataframe_two)

    ...

そして、次の.transform()の呼び出し：

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# デコレータで関数を変換します。入力と出力、モデルのパラメータを指定します。
@transform(
    my_input_data=Input(...),  # 入力データ
    my_output_data_one=Output(...),  # 出力データ1
    my_output_data_two=Output(...),  # 出力データ2
    my_model=ModelInput(...)  # モデル
)
# computeという名前の関数を定義します。引数には上記で指定した入力データ、出力データ、モデルを指定します。
def compute(my_input_data, my_output_data_one, my_output_data_two, my_model):
    my_model_outputs = my_model.transform(my_input_data)  # モデルを使って入力データを変換します
    my_output_dataframe_one = my_model_outputs.output_dataframe_one  # 変換したデータの一部を出力データ1として指定します
    my_output_dataframe_two = my_model_outputs.output_dataframe_two  # 変換したデータの一部を出力データ2として指定します
    my_output_data_one.write_pandas(my_output_dataframe_one)  # 出力データ1をPandasの形式で書き出します
    my_output_data_two.write_pandas(my_output_dataframe_two)  # 出力データ2をPandasの形式で書き出します

my_output_dataframe_one および my_output_dataframe_two オブジェクトは、モデルアダプターの run_inference() メソッドで output_dataframe_one と output_dataframe_two の出力に書き込まれたオブジェクトと同等になります（この場合は、my_output_dataframe_one と my_output_dataframe_two）。

メディアリファレンス

Foundry 内のメディアリファレンスに関する情報はこちらで見つけることができます。

モデルアダプターの api() でパラメーター入力または MediaReference タイプのタブラー入力列が指定された場合、model.transform() 経由で提供されたメディアリファレンス文字列は MediaReference オブジェクトに変換されます。このオブジェクトタイプは、メディアリファレンスと対話するためのメソッドを提供します。

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class MediaReference:
    @property
    def media_reference(self):
        """
        生のメディア参照文字列を返します。
        """

    @property
    def media_item_rid(self):
        """
        メディア参照から抽出されたメディアアイテムのridを返します。
        """

    def get_media_item(self):
        """
        メディアアイテムをファイルライクなオブジェクトとして返します。
        """

    def get_media_item_via_access_pattern(self, access_pattern_name, access_pattern_path):
        """
        メディアアイテムのアクセスパターンをファイルライクなオブジェクトとして返します。
        メディアセットの永続性ポリシーにより、一度計算されたアクセスパターンがキャッシュされる可能性があります。
        """

    def transform_media_item(self, output_path, transformation):
        """
        変換をメディアアイテムに適用し、それをファイルライクなオブジェクトとして返します。
        出力パスは変換に提供されます。
        変換計算はこのSparkモジュールではなく、Mioによって行われます。
        """

    def get_media_item_metadata(self):
        """
        メディアアイテムのメタデータ（幅、高さなど）を返します。
        """