모델용 직렬화

워크플로 전반에서 모델을 재사용하려면 Palantir이 저장된 가중치를 역직렬화할 수 있어야 합니다. 직렬화 과정이 모델 유형에 따라 특정할 수 있으므로, 모델 어댑터의 작성자는 이 작업이 어떻게 이루어져야 하는지 설명해야 합니다. 이는 컨테이너 모델에 대해서는 걱정할 필요가 없으며, 일반적으로 컨테이너 생명주기의 일부이거나 외부 모델인 경우 외부에서 호스팅되는 가중치가 있습니다.

자동 직렬화

플랫폼 내에서 모델 가중치의 직렬화와 역직렬화를 단순화하기 위해 Palantir은 palantir_models_serializers 라이브러리를 제공하며, 이 라이브러리는 모델을 저장하고 로드하기 위한 많은 기본 직렬화 방법을 제공합니다.

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

기본 직렬화 도구 사용 방법

기본 직렬화 도구는 model adapter의 __init__ 메서드에 @auto_serialize 주석을 달아 사용할 수 있습니다. Palantir은 선택한 직렬화 방법으로 모델 어댑터의 내용을 자동으로 저장하고 로드합니다. 여러 인수를 auto_serialize 할 수 있으며, 각각 다른 직렬화 도구를 사용할 수 있습니다. __init__ 메서드의 모든 인수에는 @auto_serialize 정의에서 동일한 인수가 있어야 합니다.

auto_serialization을 사용한 모델 정의 예시

아래 예제는 모델을 학습하고 게시하는 유효한 파이썬 변환입니다. 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
from transforms.api import transform
from palantir_models.transforms import ModelOutput

from sklearn.linear_model import LinearRegression
import numpy as np

# 모델을 학습하고 저장하는 함수 정의
@transform(
    model_output=ModelOutput("/Foundry/path/to/model_asset"),  # 모델을 저장할 경로 지정
)
def compute(model_output):
    x_values = [i for i in range(100)]  # x값 생성
    y_values = [2 * i for i in x_values]  # y값 생성

    X = np.array(x_values, dtype=np.float32).reshape(-1, 1)  # x값을 넘파이 배열로 변환 후 2차원으로 재구성
    y = np.array(y_values, dtype=np.float32).reshape(-1, 1)  # y값을 넘파이 배열로 변환 후 2차원으로 재구성

    model = LinearRegression()  # 선형 회귀 모델 생성
    model.fit(X, y)  # 모델 학습

    model_output.publish(
        model_adapter=AutoSerializationAdapter(  # 생성한 모델 어댑터 사용
            model,
            {'prediction_column': 'prediction'}
        )
    )

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

    @classmethod
    def api(cls):
        inputs = {"df_in": pm.Pandas()}  # 입력 데이터 형태 지정
        outputs = {"df_out": pm.Pandas()}  # 출력 데이터 형태 지정
        return inputs, outputs

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

# 자동 직렬화 어댑터 클래스 정의
class AutoSerializationAdapter(pm.ModelAdapter):

    # 생성자 함수에서 자동 직렬화를 수행하는 데코레이터를 사용합니다.
    # model은 DillSerializer를 사용하고, config는 JsonSerializer를 사용합니다.
    @pm.auto_serialize(
        model=DillSerializer(),
        config=JsonSerializer()
    )
    def __init__(self, model, config={}):
        self.model = model
        # config에 'prediction_column'이 있으면 이를 사용하고, 그렇지 않으면 'prediction'을 기본값으로 사용합니다.
        self.prediction_column = config['prediction_column'] if 'prediction_column' in config else 'prediction'

    # api 함수는 입력과 출력을 반환합니다. 여기서는 입력과 출력 모두 Pandas 데이터프레임입니다.
    @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[self.prediction_column] = self.model.predict(df_in)
        return df_in

기본 직렬화 도구

Dill

palantir_models_serializers.DillSerializer는 dill을 이용하여 파이썬 오브젝트를 직렬화합니다. dill.dump과 dill.load를 호출하여 오브젝트를 디스크에 저장하고 불러옵니다.

DillSerializer 클래스는 scikit-learn 및 statsmodels를 포함한 많은 파이썬 오브젝트를 직렬화하는데 사용할 수 있습니다.

Cloudpickle

palantir_models_serializers.CloudPickleSerializer는 Cloudpickle을 이용하여 파이썬 오브젝트를 직렬화합니다. cloudpickle.dump과 cloudpickle.load를 호출하여 오브젝트를 디스크에 저장하고 불러옵니다.

CloudPickleSerializer 클래스는 scikit-learn 및 statsmodels를 포함한 많은 파이썬 오브젝트를 직렬화하는데 사용할 수 있습니다.

JSON

palantir_models_serializers.JsonSerializer는 파이썬 딕셔너리를 JSON으로 직렬화합니다. 파이썬 딕셔너리에 yaml.safe_dump과 json.safe_load를 호출합니다.

YAML

palantir_models_serializers.YamlSerializer는 파이썬 딕셔너리를 JSON으로 직렬화합니다. 파이썬 딕셔너리에 yaml.safe_dump과 yaml.safe_load를 호출합니다.

Hugging Face

현재 palantir_models_serializers 라이브러리는 Hugging Face 모델에 대한 세 가지 기본 직렬화 도구를 제공합니다: HfPipelineSerializer, HfAutoTokenizerSerializer, 그리고 HfAutoModelSerializer. 이 세 가지 Hugging Face 직렬화 도구는 모두 파이썬 환경에 transformers 라이브러리가 의존성으로 추가되어 있어야 합니다.

HfPipelineSerializer

palantir_models_serializers.HfPipelineSerializer는 save_pretrained을 이용하여 transformers.pipeline 오브젝트를 직렬화하고, 로드할 때 파이프라인 오브젝트를 다시 인스턴스화합니다.

HfPipelineSerializer에는 파이프라인의 task를 나타내는 필수 스트링 파라미터가 하나 있습니다. 추가 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
import palantir_models as pm
from palantir_models_serializers import HfPipelineSerializer
from transformers import pipeline
import pandas as pd

class HFNerAdapter(pm.ModelAdapter):

    @pm.auto_serialize(
        pipeline=HfPipelineSerializer("ner"),  # NER(개체명 인식) 파이프라인
    )
    def __init__(self, pipeline):
        self.pipeline = pipeline

    @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):  # 예측 메서드
        result = self.pipeline(df_in["text"].tolist())  # 텍스트를 NER 파이프라인에 전달하여 결과를 얻음
        df_in["generation"] = result  # 결과를 데이터프레임에 추가
        return df_in  # 데이터프레임 반환

HfAutoModelSerializer와 HfAutoTokenizerSerializer

palantir_models_serializers.HfAutoModelSerializer와 palantir_models_serializers.HfAutoTokenizerSerializer는 transformers.AutoModel과 transformers.AutoTokenizer 모델을 save_pretrained와 from_pretrained를 사용하여 직렬화합니다.

일부 모델 및 토크나이저의 경우, 일반 클래스보다 특정 모델 또는 토크나이저 클래스를 사용하는 것이 권장됩니다. 이 경우, 특정 클래스를 첫 번째 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
import palantir_models as pm
from palantir_models_serializers import HfAutoModelSerializer, HfAutoTokenizerSerializer
from transformers import AutoModelForSeq2SeqLM
import pandas as pd
import torch

# HuggingFace의 텍스트 생성 모델을 사용하는 어댑터 클래스를 정의합니다.
class HFTextGenerationAdapter(pm.ModelAdapter):

    # 모델과 토크나이저의 인스턴스를 자동으로 직렬화하는 데코레이터를 사용합니다.
    @pm.auto_serialize(
        model=HfAutoModelSerializer(AutoModelForSeq2SeqLM),  # Seq2Seq 모델을 위한 직렬화 클래스
        tokenizer=HfAutoTokenizerSerializer()  # 토크나이저를 위한 직렬화 클래스
    )
    def __init__(self, model, tokenizer):
        self.model = model  # 모델 인스턴스 저장
        self.tokenizer = tokenizer  # 토크나이저 인스턴스 저장

    @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 출처를 참조하세요.