モデルのシリアル化

ワークフロー間でモデルを再利用するために、Palantir は保存された重みをデシリアル化できる必要があります。シリアル化プロセスはモデルタイプに特有のものであるため、モデルアダプターの作成者がこれをどのように行うべきか詳細を記述することが期待されます。ただし、これはコンテナモデルや外部モデルには関係ありません。コンテナモデルでは、シリアル化は通常コンテナのライフサイクルの一部であり、外部モデルは外部でホストされた重みを持っています。

オートシリアル化

プラットフォーム内のモデルの重みのシリアル化とデシリアル化を簡素化するために、Palantir は palantir_models_serializers ライブラリを提供しており、モデルの保存と読み込みのための多くのデフォルトのシリアル化方法が提供されています。

• Dill
• Cloudpickle
• JSON
• YAML
• Hugging Face
• PyTorch
• Tensorflow
• XGBoost

デフォルトのシリアライザーの使い方

デフォルトのシリアライザーは、モデルアダプター の __init__ メソッドに @auto_serialize アノテーションを付けることで使用できます。Palantir は選択したシリアル化方法でモデルアダプターの内容を自動的に保存および読み込みます。異なるシリアライザーで複数の引数を auto_serialize することができます。 __init__ メソッド内のすべての引数は、 @auto_serialize 定義内で同じ引数を持たなければなりません。

auto_serialization を使用したモデル定義の例

以下は、モデルをトレーニングおよび公開する有効な Pythonトランスフォーム です。 AutoSerializationAdapter は DillSerializer を使用してモデルをシリアル化します。

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
# 必要なライブラリをインポートします
from transforms.api import transform
from palantir_models.transforms import ModelOutput
from sklearn.linear_model import LinearRegression
import numpy as np

# デコレータを使って、transform関数を定義します
# この関数は、モデルの出力を計算します
@transform(
    model_output=ModelOutput("/Foundry/path/to/model_asset"), # モデルの出力パスを指定します
)
def compute(model_output):
    # x値とy値を生成します
    x_values = [i for i in range(100)]
    y_values = [2 * i for i in x_values]

    # x値とy値をnumpy配列に変換します
    X = np.array(x_values, dtype=np.float32).reshape(-1, 1)
    y = np.array(y_values, dtype=np.float32).reshape(-1, 1)

    # 線形回帰モデルを生成し、データにフィットさせます
    model = LinearRegression()
    model.fit(X, y)

    # モデルの出力を公開します
    model_output.publish(
        model_adapter=AutoSerializationAdapter(
            model,
            {'prediction_column': 'prediction'}
        )
    )

# palantirのモデルとシリアライザをインポートします
import palantir_models as pm
from palantir_models_serializers import DillSerializer

# 自動シリアライゼーションアダプタクラスを作成します
class AutoSerializationAdapter(pm.ModelAdapter):

    # デコレータを使って、モデルの自動シリアライゼーションを設定します
    @pm.auto_serialize(
        model=DillSerializer() # モデルのシリアライザとしてDillSerializerを使用します
    )
    def __init__(self, model):
        self.model = model

    # APIの入力と出力を定義します
    @classmethod
    def api(cls):
        inputs = {"df_in": pm.Pandas()}
        outputs = {"df_out": pm.Pandas()}
        return inputs, outputs

    # predict関数を定義します
    def predict(self, df_in):
        df_in['prediction'] = self.model.predict(df_in)
        return df_in

複数の auto_serialization を使用したモデル定義の例

上記のモデルアダプタは、デフォルトの JsonSerializer でシリアライズされるオプションの設定辞書を含めるように拡張できます。

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
import palantir_models as pm
from palantir_models_serializers import DillSerializer, JsonSerializer

class AutoSerializationAdapter(pm.ModelAdapter):

    # 自動シリアライズ用のデコレータ
    @pm.auto_serialize(
        model=DillSerializer(),  # モデルのシリアライズに Dill シリアライザを使用
        config=JsonSerializer()  # 設定のシリアライズに JSON シリアライザを使用
    )
    def __init__(self, model, config={}):
        self.model = model
        # 設定から予測カラムを取得、存在しなければデフォルト値 'prediction' を使用
        self.prediction_column = config['prediction_column'] if 'prediction_column' in config else 'prediction'

    @classmethod
    def api(cls):
        inputs = {"df_in": pm.Pandas()}  # 入力は Pandas データフレーム
        outputs = {"df_out": pm.Pandas()}  # 出力も Pandas データフレーム
        return inputs, outputs

    def predict(self, df_in):
        # 予測カラムにモデルの予測結果を追加
        df_in[self.prediction_column] = self.model.predict(df_in)
        return df_in

デフォルトのシリアライザ

Dill

palantir_models_serializers.DillSerializer は、dill を使用して Python オブジェクトをシリアライズし、dill.dump と dill.load を呼び出してユーザーのオブジェクトをディスクに保存および読み込みます。

DillSerializer クラスは、scikit-learn や statsmodels などの多くの Python オブジェクトをシリアライズするために使用できます。

Cloudpickle

palantir_models_serializers.CloudPickleSerializer は、Cloudpickle を使用して Python オブジェクトをシリアライズし、cloudpickle.dump と cloudpickle.load を呼び出してユーザーのオブジェクトをディスクに保存および読み込みます。

CloudPickleSerializer クラスは、scikit-learn や statsmodels などの多くの Python オブジェクトをシリアライズするために使用できます。

JSON

palantir_models_serializers.JsonSerializer は、Python の辞書を JSON としてシリアライズし、ユーザーの Python の辞書に対して yaml.safe_dump と json.safe_load を呼び出します。

YAML

palantir_models_serializers.YamlSerializer は、JSON で Python の辞書をシリアライズし、ユーザーの Python の辞書に対して yaml.safe_dump と yaml.safe_load を呼び出します。

Hugging Face

palantir_models_serializers ライブラリは、現在 Hugging Face モデル 用の 3 つのデフォルトシリアライザを提供しています：HfPipelineSerializer、HfAutoTokenizerSerializer、および HfAutoModelSerializer。3 つの Hugging Face シリアライザすべてには、transformers ライブラリが Python 環境の依存関係として追加される必要があります。

HfPipelineSerializer

palantir_models_serializers.HfPipelineSerializer は、transformers.pipeline オブジェクトを save_pretrained でシリアライズし、ロード時にパイプラインオブジェクトを再インスタンス化します。

HfPipelineSerializer には、パイプラインの タスク を表す必須の文字列パラメーターが 1 つあります。追加の kwargs は、パイプラインの読み込みに使用されます。

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
import palantir_models as pm
from palantir_models_serializers import HfPipelineSerializer
from transformers import pipeline
import pandas as pd

# HFNerAdapterクラスの定義
class HFNerAdapter(pm.ModelAdapter):

    # コンストラクタ
    @pm.auto_serialize(
        pipeline=HfPipelineSerializer("ner"),  # NERパイプラインをシリアライズ
    )
    def __init__(self, pipeline):
        self.pipeline = pipeline

    # APIの入力と出力を定義
    @classmethod
    def api(cls):
        inputs = {"df_in" : pm.Pandas([("text", str)])}  # 入力: DataFrame (text列)
        outputs = {"df_out" : pm.Pandas([("text", str), ("generation", str)])}  # 出力: DataFrame (text列, generation列)
        return inputs, outputs

    # 予測関数
    def predict(self, df_in: pd.DataFrame):
        result = self.pipeline(df_in["text"].tolist())  # 入力テキストをパイプラインに渡す
        df_in["generation"] = result  # 結果をgeneration列に追加
        return df_in

HfAutoModelSerializer と HfAutoTokenizerSerializer

palantir_models_serializers.HfAutoModelSerializer および palantir_models_serializers.HfAutoTokenizerSerializerは、save_pretrained および from_pretrained を用いて transformers.AutoModel および transformers.AutoTokenizer モデルをシリアライズします。

なお、一部のモデルとトークナイザでは、ジェネリックなものではなく特定のモデルやトークナイザクラスを使用することが推奨されています。これらの場合、特定のクラスをシリアライザの最初の model_class 引数として渡すことができます。

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
import palantir_models as pm
from palantir_models_serializers import HfAutoModelSerializer, HfAutoTokenizerSerializer
from transformers import AutoModelForSeq2SeqLM
import pandas as pd
import torch

# Hugging Faceのテキスト生成アダプター
class HFTextGenerationAdapter(pm.ModelAdapter):

    # シリアライズされたモデルとトークナイザーを初期化
    @pm.auto_serialize(
        model=HfAutoModelSerializer(AutoModelForSeq2SeqLM),
        tokenizer=HfAutoTokenizerSerializer()
    )
    def __init__(self, model, tokenizer):
        self.model = model
        self.tokenizer = tokenizer

    # APIの入力と出力を定義
    @classmethod
    def api(cls):
        inputs = {"df_in" : pm.Pandas([("text", str)])}
        outputs = {"df_out" : pm.Pandas([("text", str), ("generation", str)])}
        return inputs, outputs

    # 予測を行う関数
    def predict(self, df_in: pd.DataFrame):
        # 入力データをトークナイズ
        input_ids = self.tokenizer(
            df_in["text"].tolist(),
            return_tensors="pt",
            padding=True
        ).input_ids

        # モデルでテキスト生成を実行
        outputs = self.model.generate(input_ids)
        # 生成されたテキストをデコード
        result = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)

        # 結果をデータフレームに追加
        df_in["generation"] = result
        return df_in

PyTorch

palantir_models_serializers.PytorchStateSerializer は、torch.save および torch.load を使用して torch.nn.Module をシリアル化し、オブジェクトをディスクに保存および読み込みします。

TensorFlow

palantir_models_serializers.TensorflowKerasSerializer は、obj.save および tensorflow.keras.models.load_model を使用して tensorflow.keras.Model をシリアル化し、モデルをディスクに保存および読み込みします。モデルがデシリアル化されているとき、Foundry は obj.compile() を呼び出します。

XGBoost

palantir_models_serializers.XGBoostSerializer は、save_model および load_model を使用して xgboost.sklearn.XGBModel をシリアル化し、モデルをディスクに保存および読み込みします。XGBModel クラスは、xgboost.XGBClassifier、xgboost.XGBRegressor、および xgboost.XGBRanker を含む多くの XGBoost モデルの基本クラスです。

独自の AutoSerializer の作成

各シリアル化の 完全な実装 と 新しいデフォルトシリアル化の追加方法 に関するドキュメントを参照してください。

上記に記載されていない追加のデフォルトシリアル化が必要だと考える場合は、Palantir の担当者にお問い合わせください。

カスタムシリアル化

デフォルトのシリアル化が不十分な場合、ユーザーは load() および save() メソッドを実装できます。追加の詳細と例については、API リファレンス を参照してください。