PythonDeep Learning

skorch callbacks (3) ML Pipeline

, , , , ,

  • PyTorch는 현재 가장 인기있는 딥러닝 라이브러리 중 하나입니다.

  • 학습 세부 사항을 지정하기 위해 Callback으로 다양한 기능을 지원합니다.

  • skorch는 PyTorch를 scikit-learn과 함께 사용할 수 있게 해 줍니다.

  • skorch도 PyTorch callback을 이용할 수 있습니다.

  • 글이 길어 세 개로 나눕니다.

  • 세 번째로, skorch를 사용해 ML Pipeline을 완성합니다.

  • 여러 callback으로 자세한 설정을 반영합니다.

3.2. skorch

Colab code: skorch callbacks

  • Colab에는 skorch가 기본으로 설치되어 있지 않습니다.
  • 간단한 명령으로 skorch를 설치합니다.
1
!pip install skorch

3.2.1. preprocessor 포함 pipeline 작성

skorch: skorch.regressor

  • 앞에서 만든 get_preprocessor()함수는 전처리 Pipeline을 출력합니다.

  • Pipeline을 연장해 이 뒤에 PyTorch로 만든 Neural Network를 덧붙입니다.

  • 우리가 푸는 문제는 펭귄의 체중을 구하는 regression문제입니다.

  • skorch에서 제공하는 NeuralNetRegressor()로 PyTorch 신경망을 감쌉니다.

  • loss function, optimizer 등은 NeuralNetRegressor() 안에 criterion, optimizer 등의 매개변수를 사용해 입력합니다.

  • optimizer=optim.Adam으로 Adam을 선택했습니다.

  • PyTorch에서 Adam()안에 들어가던 매개변수 lr=1e-3은 optimizer__lr=1e-3으로 바뀌어 들어갑니다.

1
2
3
4
5
6
7
8
9
10
11
12
import skorch
from skorch import NeuralNetRegressor

# skorch로 PyTorch neural network wrapping
net_sk = NeuralNetRegressor(Net(), device=device, verbose=1,
                            criterion=RMSELoss,         # loss function
                            optimizer=optim.Adam,       # optimizer
                            optimizer__lr=1e-3)         # learning rate of the optimizer

# training
for epoch in range(300):
    net_sk.fit(X_train_np, y_train.astype(np.float32).values.reshape(-1, 1))
  • 실행 결과 : 너무 길어서 out of memory 오류가 뜰 수 있습니다. 침착하게 새로 고침을 누르시면 됩니다.
  • 또는, verbose=1을 verbose=0으로 바꾸시는 것도 방법입니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
... (생략) ...

     10      271.1115      286.5908  0.0111
Re-initializing module.
Re-initializing criterion.
Re-initializing optimizer.
  epoch    train_loss    valid_loss     dur
-------  ------------  ------------  ------
      1      272.8632      286.3571  0.0108
      2      267.6815      285.4084  0.0145
      3      268.0632      284.9375  0.0106
      4      269.3830      284.9683  0.0104
      5      270.7425      285.2378  0.0101
      6      271.6377      285.5552  0.0108
      7      271.9493      285.8589  0.0082
      8      271.8214      286.1465  0.0080
      9      271.4798      286.4032  0.0087
     10      271.1165      286.5942  0.0088

  • 학습이 model.fit()으로 잘 됩니다.

  • NeuralNetRegressor로 한 번 감싼 것 만으로 scikit-learn API를 사용할 수 있게 되었습니다.

  • X_train대신 전처리를 거친 X_train_np를 입력했습니다.

  • y_train대신으로는 y_train.astype(np.float32).values.reshape(-1, 1)이 들어갔습니다.

  • pandas Series에서 데이터 타입을 바꾸고, 값을 추출해서, shape을 바꾼 것입니다.

  • 예측도 model.forward() 대신 model.predict()로 진행합니다.

1
2
3
4
5
6
7
# prediction
y_pred_train = net_sk.predict(X_train_np)
y_pred_val = net_sk.predict(X_val_np)
y_pred_test = net_sk.predict(X_test_np)

# parity plot
plot_parity3(net_sk, Xs=[X_train_np, X_val_np, X_test_np])


3.2.2. ML pipeline 작성

skorch: skorch.callbacks.InputShapeSetter
stackoverflow: How to pass input dim from fit method to skorch wrapper?

  • 앞에서 만든 전처리기, get_preprocessor()를 포함하는 Pipeline을 만듭니다.

  • method매개변수로 neural network 뿐 아니라 linear regression, random forest를 선택할 수 있게 합니다.

  • Neural network는 이들 방법들과 달리 input dimension이 중요합니다.

  • 신경망 구조를 만들 때 필요한 변수이기 때문입니다.

  • callback은 여러 설정을 지정할 수 있는 방법입니다. InputShapeSetter를 callback에 기본값으로 박아 넣습니다.

  • 그 외에 여러 keyword arguments를 입력할 수 있도록 **kwargs를 NeuralNetRegressor()에 추가합니다.

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
# machine learning models
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor

# embedding pytorch model in scikit-learn Pipeline
from skorch import NeuralNetRegressor
from skorch.helper import predefined_split
from skorch.callbacks import Callback

# dynamic input size of the PyTorch module
class InputShapeSetter(Callback):
    def on_train_begin(self, net, X, y):
        net.set_params(module__ninput=X.shape[1])

def get_model(method="lr", device=device, cols_cat=cols_cat, cols_num=cols_num, degree=1, 
              callbacks=[InputShapeSetter()], **kwargs):
    if method == "lr":
        ml = LinearRegression(fit_intercept=True)
    elif method == "rf":
        ml = RandomForestRegressor(random_state=rng)
    elif method == "nn":
        ml = NeuralNetRegressor(Net(), device=device, callbacks=callbacks, **kwargs)
    else:
        print("# 'method' should be in ['lr', 'rf', 'nn'].")
        return None
    
    preprocessor = get_preprocessor(cols_cat=cols_cat, cols_num=cols_num, degree=degree)
    model = Pipeline([("preprocessor", preprocessor), 
                      ("ml", ml)])
    
    return model
  • 이제 get_model()을 사용해 ML pipeline을 제작할 수 있습니다.
  • method에 입력하는 값에 따라 선형 회귀, 앙상블 트리, 신경망을 선택할 수 있습니다.
1
2
model = get_model("nn", max_epochs=epochs, verbose=1, criterion=RMSELoss, optimizer=optim.Adam, optimizer__lr = 1e-3)
model


  • 웬만한 매개변수는 모두 NeuralNetRegressor()에 들어갑니다.
  • 어떤 매개변수들이 있는지 출력해서 확인합니다.
1
model["ml"].get_params()
  • 실행 결과
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
{'_kwargs': {'optimizer__lr': 0.001},
 'batch_size': 128,
 'callbacks': [<__main__.InputShapeSetter at 0x7f4911406cd0>],
 'callbacks__epoch_timer': <skorch.callbacks.logging.EpochTimer at 0x7f49745b2a50>,
 'callbacks__print_log': <skorch.callbacks.logging.PrintLog at 0x7f49701261d0>,
 'callbacks__print_log__floatfmt': '.4f',
 'callbacks__print_log__keys_ignored': None,
 'callbacks__print_log__sink': <function print>,
 'callbacks__print_log__stralign': 'right',
 'callbacks__print_log__tablefmt': 'simple',
 'callbacks__train_loss': <skorch.callbacks.scoring.PassthroughScoring at 0x7f49745b2450>,
 'callbacks__train_loss__lower_is_better': True,
 'callbacks__train_loss__name': 'train_loss',
 'callbacks__train_loss__on_train': True,
 'callbacks__valid_loss': <skorch.callbacks.scoring.PassthroughScoring at 0x7f49745b24d0>,
 'callbacks__valid_loss__lower_is_better': True,
 'callbacks__valid_loss__name': 'valid_loss',
 'callbacks__valid_loss__on_train': False,
 'criterion': __main__.RMSELoss,
 'dataset': skorch.dataset.Dataset,
 'device': 'cuda:0',
 'iterator_train': torch.utils.data.dataloader.DataLoader,
 'iterator_valid': torch.utils.data.dataloader.DataLoader,
 'lr': 0.01,
 'max_epochs': 1000,
 'module': Net(
   (layer0): Linear(in_features=12, out_features=16, bias=True)
   (layer1): Linear(in_features=16, out_features=16, bias=True)
   (layer2): Linear(in_features=16, out_features=12, bias=True)
   (layer3): Linear(in_features=12, out_features=8, bias=True)
   (layer4): Linear(in_features=8, out_features=1, bias=True)
   (activation): ReLU()
 ),
 'optimizer': torch.optim.adam.Adam,
 'optimizer__lr': 0.001,
 'predict_nonlinearity': 'auto',
 'train_split': <skorch.dataset.ValidSplit object at 0x7f497434cc90>,
 'verbose': 1,
 'warm_start': False}

3.2.3. train and validate (self)

skorch: NeuralNet#train_split

  • X_train과 y_train만 사용해서 학습시킵니다.
1
model.fit(X_train, y_train.values.reshape(-1, 1).astype(np.float32))
  • 실행 결과
1
2
3
4
5
6
7
8
9
10
11
12
13
Re-initializing module because the following parameters were re-set: module__ninput.
Re-initializing criterion.
Re-initializing optimizer.
  epoch    train_loss    valid_loss     dur
-------  ------------  ------------  ------
      1     4280.8532     4388.5093  0.0188
      2     4280.8443     4388.4990  0.0129
      
      ... (생략) ...
      
    998      295.5285      270.6504  0.0106
    999      295.5276      270.6288  0.0153
   1000      295.5247      270.6030  0.0102

  • validation set을 입력하지 않았음에도 valid_loss가 출력됩니다.

  • train data의 20%를 validation set으로 따로 떼어 놓기 때문입니다.

  • 맨 처음 전체 데이터의 60%만 train set으로 지정했습니다.

  • 여기서 다시 80%만 학습에 투입되었으니 총 48%. 반도 안되는 데이터로 학습한 셈입니다.

  • train_split=None을 입력하면 모든 데이터를 다 학습에 투입하지만 validation 결과가 출력되지 않습니다.

  • learning curve는 신경망에서 .history 속성을 추출해 확인할 수 있습니다.

1
2
3
4
5
history = model["ml"].history
train_loss = history[:, "train_loss"]
valid_loss = history[:, "valid_loss"]

plot_epoch(train_loss, valid_loss)


  • 학습도 정상적으로 이루어졌습니다.
1
plot_parity3(model)


3.2.4. train and validate (predefined validation set)

skorch: skorch.dataset.Dataset

  • 먼저 준비한 validation set을 사용하려면 train_split에 validation set을 입력합니다.
  • validation set은 skorch의 Dataset을 사용해 만듭니다.
  • 내친 김에 y data도 ML Pipeline에 만들기 좋은 형태, 즉 float32, (-1, 1) shape으로 변경해서 모아놓습니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from skorch.dataset import Dataset

# ys (numpy)
y_train_np = y_train.values.reshape(-1, 1).astype(np.float32)
y_val_np = y_val.values.reshape(-1, 1).astype(np.float32)
y_test_np = y_test.values.reshape(-1, 1).astype(np.float32)

# predefined validation set
preprocessor = get_preprocessor()
X_val_pp = preprocessor.fit(X_train).transform(X_val)
valid_dataset = Dataset(X_val_pp, y_val_np)

# model training
model = get_model("nn", max_epochs=epochs, verbose=1, criterion=RMSELoss, optimizer=optim.Adam, optimizer__lr = 1e-3,
                  # predefined validataion set
                  train_split=predefined_split(valid_dataset))  
model.fit(X_train, y_train_np)
  • 실행 결과
1
2
3
4
5
6
7
8
9
10
11
12
13
Re-initializing module because the following parameters were re-set: module__ninput.
Re-initializing criterion.
Re-initializing optimizer.
  epoch    train_loss    valid_loss     dur
-------  ------------  ------------  ------
      1     4302.1941     4250.5781  0.0160
      2     4302.1851     4250.5693  0.0175
      
      ... (생략) ...
      
    998      280.9618      267.7317  0.0121
    999      280.9596      267.7302  0.0122
   1000      280.9580      267.7280  0.0141
  • learning curve를 확인합니다.
  • 여기서 얻은 learning curve를 reference로 사용하겠습니다.
1
2
3
4
5
history = model["ml"].history
train_loss_0 = history[:, "train_loss"]
valid_loss_0 = history[:, "valid_loss"]

plot_epoch(train_loss_0, valid_loss_0)


  • parity plot도 확인합니다.
1
plot_parity3(model)


3.2.5. learning rate scheduler

skorch: Learning rate schedulers
Pega Devlog: Fast.ai의 fit_one_cycle 방법론 이해

  • callbacks에 learning late scheduler를 추가해 learning rate를 조정할 수 있습니다.
  • input dimension 조정을 위해 callbacks 기본값으로 InputShapeSetter()가 들어가 있습니다.
  • 이를 삭제하지 않도록 유의하면서 learning rate scheduler를 추가합니다.
1
2
3
4
5
6
7
8
9
10
11
12
from skorch.callbacks import LRScheduler

model = get_model("nn", max_epochs=epochs, verbose=1, criterion=RMSELoss, optimizer=optim.Adam, optimizer__lr = 1e-3,
                  train_split=predefined_split(valid_dataset),               # predefined validataion set                
                  callbacks=[# input dimension setter
                             ("input_shape_setter", InputShapeSetter()),
                             
                             # LR scheduler
                             ("lr_scheduler", LRScheduler(policy=OneCycleLR, # LR scheduler
                                                         max_lr=0.1,
                                                         total_steps=epochs))])
model.fit(X_train, y_train_np)
  • 학습 과정은 생략하고 learning curve를 비교해서 봅니다.
1
2
3
4
5
6
7
8
9
10
11
12
ax = plot_epoch(train_loss_0, valid_loss_0)
lines = ax.lines
for line in lines:
    line.set_alpha(0.3)

history = model["ml"].history
train_loss = history[:, "train_loss"]
valid_loss = history[:, "valid_loss"]

ax = plot_epoch(train_loss, valid_loss, ax=ax)
handles, labels = ax.get_legend_handles_labels()
ax.legend(handles=handles, labels=labels, ncol=2, title="base      OneCycleLR")


  • learning rate scheduler가 적용되어 학습 양상이 바뀌었습니다.
  • parity plot도 여전히 좋습니다.
1
plot_parity3(model)


3.2.6. early stopping

skorch: skorch.callbacks.EarlyStopping

  • 불필요하게 학습을 길게 하는 경향을 줄이고자 early stopping을 적용합니다.
  • EarlyStopping()을 callbacks에 추가하고 기준을 설정합니다.
  • valid_loss가 20번 줄어들지 않으면 학습을 중단하도록 monitor="valid_loss", patience=20을 설정했습니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from skorch.callbacks import EarlyStopping

model = get_model("nn", max_epochs=epochs, verbose=1, criterion=RMSELoss, optimizer=optim.Adam, optimizer__lr = 1e-3,
                  train_split=predefined_split(valid_dataset),               # predefined validataion set        

                  callbacks=[# input dimension setter
                             ("input_shape_setter", InputShapeSetter()),

                             # LR scheduler
                             ("lr_scheduler", LRScheduler(policy=OneCycleLR, 
                                                         max_lr=0.1,
                                                         total_steps=epochs)),

                             # early stopping
                             ("early_stopping", EarlyStopping(monitor="valid_loss",
                                                              patience=20))])
model.fit(X_train, y_train.values.reshape(-1, 1).astype(np.float32))
  • learning curve를 비교합니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
ax = plot_epoch(train_loss_0, valid_loss_0)
lines = ax.lines
for line in lines:
    line.set_alpha(0.3)

history = model["ml"].history
train_loss = history[:, "train_loss"]
valid_loss = history[:, "valid_loss"]

ax = plot_epoch(train_loss, valid_loss, ax=ax)
handles, labels = ax.get_legend_handles_labels()
ax.legend(handles=handles, labels=labels, ncol=2, title="base      LRS+ES")
ax.set_xlim(0, 200)


  • parity plot도 정상적입니다.
1
plot_parity3(model)


3.2.7. Saving and Loading (manual)

skorch: Saving and Loading

  • 모델 파라미터를 pickle 형식으로 저장하고 불러올 수 있습니다.
1
2
# save parameters
model["ml"].save_params(f_params="nn_params.pkl")
  • 모델을 새로 만들면 paramter를 불러오기 전에 초기화하는 과정이 필요합니다.
  • .initialize()를 사용합니다.
1
2
3
4
# load parameters
model_new = get_model(method="nn")
model_new["ml"].initialize()
model_new["ml"].load_params(f_params="nn_params.pkl")
  • 새로 만든 모델에 parameter를 불러와서 적용합니다.
  • 단, 신경망 parameter에만 해당하는 상황이므로 preprocessor는 기존 모델의 preprocessor를 사용합니다.
1
2
3
4
5
6
# check reproducibility
y_pred_train = model_new["ml"].predict(model["preprocessor"].transform(X_train))
y_pred_val = model_new["ml"].predict(model["preprocessor"].transform(X_val))
y_pred_test = model_new["ml"].predict(model["preprocessor"].transform(X_test))

plot_parity3(model_new, preds=[y_pred_train, y_pred_val, y_pred_test])

  • 학습을 하지 않았음에도 parity plot이 똑같이 재현되었습니다.

3.2.8. Saving and Loading (callbacks)

skorch: Saving and Loading Using Callbacks

  • callback을 이용하면 valid loss가 줄어들때마다 저장할 수 있습니다.
  • valid loss가 줄어들때마다 저장하는 cp와 epoch마다 저장하는 train_end_cp를 동시에 지정합니다.
  • exp1 폴더를 만들어 여기에 함께 저장하도록 합니다.
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
from skorch.callbacks import Checkpoint, TrainEndCheckpoint

# save the model parameters, optimizer, and history
cp = Checkpoint(dirname='exp1')
train_end_cp = TrainEndCheckpoint(dirname='exp1')

model = get_model("nn", max_epochs=epochs, verbose=1, criterion=RMSELoss, optimizer=optim.Adam, optimizer__lr = 1e-3,
                  train_split=predefined_split(valid_dataset),                               

                  callbacks=[# input dimension setter
                             ("input_shape_setter", InputShapeSetter()),

                             # LR scheduler
                             ("lr_scheduler", LRScheduler(policy=OneCycleLR, 
                                                         max_lr=0.1,
                                                         total_steps=epochs)),

                             # early stopping
                             ("early_stopping", EarlyStopping(monitor="valid_loss",
                                                              patience=20)),
                             
                             # Checkpoints
                             ("checkpoint", cp),
                             ("train_end_checkpoint", train_end_cp)
                             ])
model.fit(X_train, y_train.values.reshape(-1, 1).astype(np.float32))
  • 실행 결과
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Re-initializing module because the following parameters were re-set: module__ninput.
Re-initializing criterion.
Re-initializing optimizer.
  epoch    train_loss    valid_loss    cp      lr     dur
-------  ------------  ------------  ----  ------  ------
      1     4301.9097     4250.2661     +  0.0040  0.0093
      2     4301.8677     4250.2241     +  0.0040  0.0107
      3     4301.8278     4250.1914     +  0.0040  0.0083
      4     4301.7949     4250.1577     +  0.0040  0.0111
      
      ... (생략) ...
      
     96      294.3520      265.7108        0.0260  0.0112
     97      296.6454      273.7495        0.0264  0.0098
     98      290.3884      289.0570        0.0268  0.0071
     99      289.6089      273.4566        0.0273  0.0093
    100      284.6194      261.8893     +  0.0277  0.0092
    101      290.8631      262.4448        0.0281  0.0107
    102      289.3116      275.2869        0.0286  0.0077
    103      286.5198      278.3972        0.0290  0.0075
    104      283.5437      266.5125        0.0295  0.0106

  • cp라는 열이 하나 생겼고, 여기 +가 붙은 곳들이 있습니다.

  • valid_loss가 기존 기록보다 작아진 지점입니다.

  • History도 파일에서 불러와서 그립니다.

  • 부를 때는 skorch.history.History를 사용합니다.

  • 세 개의 learning curve를 겹쳐 그리느라 코드가 다소 복잡해졌습니다.

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
from skorch.history import History

# base plot
ax = plot_epoch(train_loss_0, valid_loss_0)
lines = ax.lines
for line in lines:
    line.set_alpha(0.3)

# history
history = History().from_file("./exp1/history.json")
train_loss = history[:, "train_loss"]
valid_loss = history[:, "valid_loss"]
ax = plot_epoch(train_loss, valid_loss, ax=ax)

# event_cp : cp == True
epoch = history[:, "epoch"]
event_cp = history[:, "event_cp"]
df_cp = pd.DataFrame({"epoch":epoch, "event_cp":event_cp, "train_loss":train_loss, "valid_loss":valid_loss})
df_cp = df_cp.loc[df_cp["event_cp"]==True]

ax.scatter(df_cp["epoch"], df_cp["train_loss"], fc=c_train, alpha=0.5, label="train_cp")
ax.scatter(df_cp["epoch"], df_cp["valid_loss"], fc=c_val, alpha=0.5, label="valid_cp")

ax.legend(ncol=3, title="base      LRS+ES           checkpoint", loc="center right")
ax.set_xlim(0, 200)


  • 희미하게 그려진 것은 skorch에 validation set을 사용한 base line입니다.
  • 그리고 Learning Rate Scheduler와 Early Stopping을 적용한 것을 LRS + ES로 표기했습니다.
  • 앞에서와 같이 학습이 훨씬 빨리 끝났습니다.
  • 그리고 이 중 checkpoint가 적용된 것을 scatter plot으로 표현했습니다.
  • one-cycle-fit의 영향으로 learning curve가 요동치는 와중에서도 train과 valid에서 단조 감소하는 모습만이 기록되었습니다.

3.2.9. valid loss가 가장 적었던 checkpoint 불러서 learning rate 낮추기

skorch: skorch.callbacks.LoadInitState

  • 각 checkpoint에서는 history 외에도 criterion, optimizer, parameter 등의 상태를 저장합니다.

  • Colab 왼쪽의 폴더 모양을 클릭해 저장한 파일을 확인하면 볼 수 있습니다.


  • 학습이 과하게 진행되어 overfitting이 되면 지나가버린 과거의 최적점이 아쉽습니다.

  • 지나친 최적점을 불러와서 훨씬 낮은 learning rate로 살살 학습시키면 더 좋을 것 같습니다.

  • 이 때 skorch에서 제공하는 LoadInitState를 사용할 수 있습니다.

  • cp = Checkpoint()로 저장된 위치를 지정하고,

  • load_state = LoadInitState(cp)로 불러와 상태를 불러옵니다.

  • 마지막으로 callbacks에 cp와 load_state를 추가합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from skorch.callbacks import LoadInitState

cp = Checkpoint(dirname='exp1')
load_state = LoadInitState(cp)

model = get_model("nn", max_epochs=epochs, verbose=1, criterion=RMSELoss, optimizer=optim.Adam, 
                  # learning rate 조정
                  optimizer__lr = 1e-5,

                  # predefined validataion set
                  train_split=predefined_split(valid_dataset),                               

                  callbacks=[# input dimension setter
                             ("input_shape_setter", InputShapeSetter()),

                             # early stopping
                             ("early_stopping", EarlyStopping(monitor="valid_loss",
                                                              patience=100)),
                             
                             # Checkpoints
                             ("checkpoint", cp),
                             ("load_initial_state", load_state)
                             ])
model.fit(X_train, y_train.values.reshape(-1, 1).astype(np.float32))

3.2.10. Saving and Loading (model itself)

  • 모델 전체를 저장할 때는 pickle을 권장하고 있습니다.
  • pickle.dump()와 pickle.load()를 사용해 모델을 읽고 씁니다.
1
2
3
4
5
6
7
# saving
with open('skorch_dl.pkl', 'wb') as f:
    pickle.dump(model, f)
    
# loading
with open('skorch_dl.pkl', 'rb') as f:
    model_pkl = pickle.load(f)
  • 저장한 모델을 불러오면서 이름을 model_pkl로 바꿨습니다.
  • 이 모델의 parity plot을 그려서 잘 저장되었고 불러졌는지 확인합니다.
1
2
# check reproducibility
plot_parity3(model=model_pkl)


  • 추가 학습 없이도 원래의 성능이 확인되었습니다.

4. 정리 : skorch ML pipeline

  • 이제까지 세 편의 글에 걸쳐 데이터를 정리한 후,

  • scikit-learn preprocessor를 만들고,

  • PyTorch neural network를 구축한 후,

  • skorch로 이들을 엮은 뒤 callbacks로 여러 옵션을 뿌렸습니다.

  • 최종적으로 사용한 코드가 여기 저기 흩뿌려져 있어 활용이 어려울 듯도 싶습니다.

  • skorch ML pipeline 코드를 아래에 정리합니다.

  • 목적은 Ctrl+C/V와 약간의 수정으로 사용하는 것입니다.

4.1. skorch ML pipeline

  • scikit-learn preprocessor
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
# preprocessors
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import FunctionTransformer
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import PolynomialFeatures

# pipeline
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.base import BaseEstimator, TransformerMixin

# Preprocessings for Categorical and Numerical features
def get_concat(cols_cat=cols_cat, cols_num=cols_num, degree=1):
    # categorical features: one-hot encoding
    cat_features = cols_cat
    cat_transformer = OneHotEncoder(sparse=False, handle_unknown="ignore")

    # numerical features: standard scaling & polynomial features
    num_features = cols_num
    num_transformer = Pipeline(steps=[("polynomial", PolynomialFeatures(degree=degree)),
                                      ("scaler", StandardScaler())])
    
    numcat = ColumnTransformer(transformers=[("categorical", cat_transformer, cat_features),
                                          ("numerical", num_transformer, num_features)])
    return numcat

# Float64 to Float32 for PyTorch
class FloatTransformer(BaseEstimator, TransformerMixin):
    def __init__(self):
        pass
    def fit(self, X, y=None):
        return self
    def transform(self, X):
        return np.array(X, dtype=np.float32)


# preprocessing Pipeline
def get_preprocessor(cols_cat=cols_cat, cols_num=cols_num, degree=1):
    concat = get_concat(cols_cat=cols_cat, cols_num=cols_num, degree=degree)
    ft = FloatTransformer()

    pipeline= Pipeline(steps=[("concat", concat), 
                              ("float64to32", ft)])
    return pipeline
  • PyTorch Neural Network
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
import torch
from torch import nn
from torch import optim

# neural network: ninput(12)-16-16-12-8-1
class Net(nn.Module):
    def __init__(self, ninput=12):
        super().__init__()
        self.layer0 = nn.Linear(ninput, 16)
        self.layer1 = nn.Linear(16, 16)
        self.layer2 = nn.Linear(16, 12)
        self.layer3 = nn.Linear(12, 8)
        self.layer4 = nn.Linear(8, 1)
        self.activation = nn.ReLU()

    def forward(self, x):
        x = self.activation(self.layer0(x))
        x = self.activation(self.layer1(x))
        x = self.activation(self.layer2(x))
        x = self.activation(self.layer3(x))
        x = self.layer4(x)
        return x

# loss: RMSE
class RMSELoss(nn.Module):
    def __init__(self, eps=1e-6):
        super().__init__()
        self.mse = nn.MSELoss()
        self.eps = eps
    def forward(self, true, pred):
        loss = torch.sqrt(self.mse(true, pred) + self.eps)
        return loss
  • skorch ML Pipeline
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
# machine learning models
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor

# embedding pytorch model in scikit-learn Pipeline
from skorch import NeuralNetRegressor
from skorch.helper import predefined_split

# callbacks
from skorch.callbacks import Callback
from skorch.callbacks import LRScheduler
from skorch.callbacks import EarlyStopping
from skorch.callbacks import Checkpoint, TrainEndCheckpoint

# dynamic input size of the PyTorch module
class InputShapeSetter(Callback):
    def on_train_begin(self, net, X, y):
        net.set_params(module__ninput=X.shape[1])

# save the model parameters, optimizer, and history
cp = Checkpoint(dirname='exp_test')
train_end_cp = TrainEndCheckpoint(dirname='exp_test')

# skorch ML pipeline
def get_model(method="lr", device=device, cols_cat=cols_cat, cols_num=cols_num, degree=1, 
              callbacks=[("input_shape_setter", InputShapeSetter()),
                         ("lr_scheduler", LRScheduler(policy=OneCycleLR, max_lr=0.1, total_steps=epochs)),
                         ("early_stopping", EarlyStopping(monitor="valid_loss", patience=20)),
                         ("checkpoint", cp), ("train_end_checkpoint", train_end_cp)], 
              **kwargs):
    
    if method == "lr":
        ml = LinearRegression(fit_intercept=True)
    elif method == "rf":
        ml = RandomForestRegressor(random_state=rng)
    elif method == "nn":
        ml = NeuralNetRegressor(Net(), device=device, callbacks=callbacks, **kwargs)
    else:
        print("# 'method' should be in ['lr', 'rf', 'nn'].")
        return None
    
    preprocessor = get_preprocessor(cols_cat=cols_cat, cols_num=cols_num, degree=degree)
    model = Pipeline([("preprocessor", preprocessor), 
                      ("ml", ml)])
    
    return model

4.2. Visualizations

  • learning curve
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def plot_epoch(history=None, loss_trains=None, loss_vals=None, ax=None):
    
    if any([history, loss_trains]) == False:
        print("# one of 'history' and 'loss_trains' has to be used!")
        return ax
    
    if ax == None:
        fig, ax = plt.subplots(figsize=(10, 5))

    if loss_trains == None:
        loss_trains = history[:, "train_loss"]

    if history != None and loss_vals == None:
        loss_vals = history[:, "valid_loss"]

    ax.plot(list(range(1, len(loss_trains)+1)), loss_trains, c=c_train, label="train")
    if loss_vals != None:
        ax.plot(list(range(1, len(loss_vals)+1)), loss_vals, c=c_val, label="valid")
    ax.grid(axis="y")
    ax.set_xlabel("epochs", fontdict=font_label)
    ax.legend()

    return ax
  • parity plots
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def plot_parity3(model, target=["train", "val", "test"], figsize=(10, 4),
                 Xs=None, trues=None, preds=None, colors=None):
    if not Xs:
        Xs = [eval(f"X_{t}") for t in target]
    if not trues:
        trues = [eval(f"y_{t}") for t in target]
    if not preds:
        preds = [model.predict(X) for X in Xs]
    if not colors:
        colors = [eval(f"c_{t}") for t in target]

    fig, axs = plt.subplots(ncols=len(target), figsize=figsize, constrained_layout=True)
    for ax, true, pred, c, title in zip(axs, trues, preds, colors, titles):
        plot_parity(true, pred, ax=ax, scatter_kws={"fc":c, "ec":c, "alpha":0.5}, title=title)
        if ax != axs[0]:
            ax.set_ylabel("")

4.3. test run

  • 정의한 함수들로 예제를 돌려봅니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# predefined validation set
preprocessor = get_preprocessor()
X_val_pp = preprocessor.fit(X_train).transform(X_val)
valid_dataset = Dataset(X_val_pp, y_val_np)

# ML pipeline preparation
model_test = get_model("nn", max_epochs=epochs, verbose=1, criterion=RMSELoss, optimizer=optim.Adam, optimizer__lr = 1e-3,
                       train_split=predefined_split(valid_dataset))
model_test.fit(X_train, y_train_np)

# learning curve
history = History().from_file("./exp_test/history.json")
ax = plot_epoch(history)

# parity plots
plot_parity3(model_test)
  • 실행 결과
1
2
3
4
5
6
7
8
9
10
11
12
13
Re-initializing module because the following parameters were re-set: module__ninput.
Re-initializing criterion.
Re-initializing optimizer.
  epoch    train_loss    valid_loss    cp      lr     dur
-------  ------------  ------------  ----  ------  ------
      1     4301.9874     4250.3501     +  0.0040  0.0135
      2     4301.9537     4250.3169     +  0.0040  0.0139
      
      ... (생략) ...
      
    110      283.9839      270.7625        0.0322  0.0108
    111      282.3574      270.6689        0.0326  0.0145
Stopping since valid_loss has not improved in the last 20 epochs.


  • 잘 돌아갑니다. :)
  • 전체를 실행해볼 수 있는 코드는 여기 있습니다: Notebook


도움이 되셨나요? 카페인을 투입하시면 다음 포스팅으로 변환됩니다

Share