【コード解説・PyTorch】手話認識入門12 - 様々な改善手法3: 時系列クリッピングによるデータ拡張

著者: Natsuki Takayama

作成日: 2024年05月16日(木) 00:00

最終更新日: 2024年05月23日(木) 21:29

カテゴリ: コンピュータビジョン

こんにちは．高山です．
先日の記事で告知しました手話入門記事の第十二回になります．

今回は手話動画から抽出した追跡点系列に対して，データ拡張を施すことで認識性能を改善する手法を紹介します．
具体的には，図1に示すように手話中の追跡点系列を任意の時間範囲で切り抜く (クリッピングと言います) 手法を紹介します．

学習データに含まれている手話動作は，ホームポジション (図1では脚の上に手を置いた状態) から始まり，ホームポジションで終わるような綺麗なデータばかりではありません．
クリッピングにより学習データのバリエーションを増やすことで，撮影のバラツキに対して頑健になることが期待できます．
また，様々な長さのデータを学習させることで，認識モデルの安定性が向上することも期待できます．

今回解説するスクリプトはGitHub上に公開しています．
複数の実験を行っている都合で，CPUで動かした場合は結構時間がかるのでご注意ください．

1. 概要

1.1 今回説明する内容

実装の詳細に先立って，今回紹介する内容の概要を説明したいと思います．
図2は，先日の記事で説明した機械学習モデル構築のワークフローの何処が今回の説明箇所に該当するかを示しています．

図2: 学習モデル構築のワークフローと紹介箇所 — 学習モデル構築のワークフローと紹介箇所

今回説明するデータ拡張は，学習用データセットからデータを取り出す際に行う，前処理に該当します．
特徴量エンジニアリングとデータ拡張の関係については，第一回の記事 (第1.2項と第1.3項) または第十一回の記事 (第1.1項) をご参照ください．

[Amershi'19]: S. Amershi, et al., "Software Engineering for Machine Learning: A Case Study," IEEE/ACM ICSE-SEIP 2019.

1.2 追跡点系列のクリッピング処理

図3に，追跡点系列のクリッピング処理工程を示します．

処理はクリッピング区間の算出と適用だけですので，非常にシンプルです．
クリッピング区間をランダムなパラメータで算出することで，毎回異なる長さの学習データを生成できます．

図3中央に，クリッピング前後でデータがどのように変化するかを示します．
ここでは，時系列データに対する処理が分かりやすいように追跡点系列を画像形式で表しています．
横軸はフレーム数を示し，縦軸は追跡点番号を示します．
各ピクセルの色 (値) は追跡点の \(x\) 座標値を示しています．
このように画像形式で表した特徴量は，特徴マップと呼ばれます．

特徴マップにおいては，クリッピングは赤矩形の部分を抜き出す操作に相当します．
追跡点や時系列データの処理は複雑になりがちですが，特徴マップ上の画像処理として捉えてあげると分かりやすくなることもあります．
もしご自身が似たような処理で悩んでいることがあれば，視点を変えてみると上手く行くかもしれません．

1.3 先に結果

第2節以降では，いつも通り実装の紹介をしながら実験結果をお見せします．
コード紹介記事の方針として記事単体で全処理が分かるように書いており，かつ，今回に関しては今までのコードにクラスを1個追加すれば良いので，結果を先にお見せしたいと思います．

図4は，データ拡張が無い場合とある場合の，Validation Lossと認識率の推移を示しています．

横軸は学習・評価ループの繰り返し数 (Epoch) を示します．
縦軸はそれぞれの評価指標を示します．

各線の色と実験条件の関係は次のとおりです．

青線 (Default): Pre-LN構成のTransformer
橙線 (+ T-Clip): 時系列クリッピング処理適用

デフォルトのモデルには，第九回の記事で紹介した，Pre-LN構成のTransformerモデルを用います．
比較結果から，時系列クリッピング処理を適用することでロスの挙動は安定しています．
認識性能は...上がっているような...変わってないような...という感じですね(^^;)．

なお，今回の実験では話を簡単にするために，実験条件以外のパラメータは固定にし，乱数の制御もしていません．
必ずしも同様の結果になるわけではないので，ご了承ください．

他の細かな点については，後半に説明します．

2. 前準備

2.1 データセットのダウンロード

ここからは実装方法の説明をしていきます．
まずは，前準備としてGoogle Colabにデータセットをアップロードします．ここの工程はこれまでの記事と同じですので，既に行ったことのある方は第2.3項まで飛ばしていただいて構いません．

まず最初に，データセットの格納先からデータをダウンロードし，ご自分のGoogle driveへアップロードしてください．

次のコードでGoogle driveをColabへマウントします．
Google Driveのマウント方法については，補足記事にも記載してあります．

from google.colab import drive

drive.mount("/content/drive")

ドライブ内のファイルをColabへコピーします．
パスはアップロード先を設定する必要があります．

# Copy to local.
!cp [path_to_dataset]/gislr_dataset_top10.zip gislr_top10.zip

データセットはZIP形式になっているので unzip コマンドで解凍します．

!unzip gislr_top10.zip

Archive:  gislr_top10.zip
   creating: dataset_top10/
  inflating: dataset_top10/16069.hdf5
  ...
  inflating: dataset_top10/sign_to_prediction_index_map.json

成功すると dataset_top10 以下にデータが解凍されます．
HDF5ファイルはデータ本体で，手話者毎にファイルが別れています．
JSONファイルは辞書ファイルで，TXTファイルは本データセットのライセンスです．

!ls dataset_top10

16069.hdf5  25571.hdf5  29302.hdf5  36257.hdf5  49445.hdf5  62590.hdf5
18796.hdf5  26734.hdf5  30680.hdf5  37055.hdf5  53618.hdf5  LICENSE.txt
2044.hdf5   27610.hdf5  32319.hdf5  37779.hdf5  55372.hdf5  sign_to_prediction_index_map.json
22343.hdf5  28656.hdf5  34503.hdf5  4718.hdf5   61333.hdf5

単語辞書には単語名と数値の関係が10単語分定義されています．

!cat dataset_top10/sign_to_prediction_index_map.json

{
    "listen": 0,
    "look": 1,
    "shhh": 2,
    "donkey": 3,
    "mouse": 4,
    "duck": 5,
    "uncle": 6,
    "hear": 7,
    "pretend": 8,
    "cow": 9
}

ライセンスはオリジナルと同様に，CC-BY 4.0 としています．

!cat dataset_top10/LICENSE.txt

The dataset provided by Natsuki Takayama (Takayama Research and Development Office) is licensed under CC-BY 4.0.
Author: Copyright 2024 Natsuki Takayama
Title: GISLR Top 10 dataset
Original licenser: Deaf Professional Arts Network and the Georgia Institute of Technology
Modification
- Extract 10 most frequent words.
- Packaged into HDF5 format.

次のコードでサンプルを確認します．
サンプルは辞書型のようにキーバリュー形式で保存されており，下記のように階層化されています．

- サンプルID (トップ階層のKey)
  |- feature: 入力特徴量で `[C(=3), T, J(=543)]` 形状．C，T，Jは，それぞれ特徴次元，フレーム数，追跡点数です．
  |- token: 単語ラベル値で `[1]` 形状．0から9の数値です．

with h5py.File("dataset_top10/16069.hdf5", "r") as fread:
    keys = list(fread.keys())
    print(keys)
    group = fread[keys[0]]
    print(group.keys())
    feature = group["feature"][:]
    token = group["token"][:]
    print(feature.shape)
    print(token)

['1109479272', '11121526', ..., '976754415']
<KeysViewHDF5 ['feature', 'token']>
(3, 23, 543)
[1]

2.2 モジュールのダウンロード

次に，過去の記事で実装したコードをダウンロードします．
本項は前回までに紹介した内容と同じですので，飛ばしていただいても構いません．コードはGithubのsrc/modules_gislrにアップしてあります (今後の記事で使用するコードも含まれています)．

まず，下記のコマンドでレポジトリをダウンロードします．
(目的のディレクトリだけダウンロードする方法はまだ調査中です(^^;))

!wget https://github.com/takayama-rado/trado_samples/archive/master.zip

--2024-01-21 11:01:47--  https://github.com/takayama-rado/trado_samples/archive/master.zip
Resolving github.com (github.com)... 140.82.112.3
...
2024-01-21 11:01:51 (19.4 MB/s) - ‘master.zip’ saved [75710869]

ダウンロードしたリポジトリを解凍します．

!unzip -o master.zip -d master

Archive:  master.zip
641b06a0ca7f5430a945a53b4825e22b5f3b8eb6
   creating: master/trado_samples-main/
  inflating: master/trado_samples-main/.gitignore
  ...

モジュールのディレクトリをカレントディレクトリに移動します．

!mv master/trado_samples-main/src/modules_gislr .

他のファイルは不要なので削除します．

!rm -rf master master.zip gislr_top10.zip

!ls
dataset_top10 drive modules_gislr  sample_data

2.3 モジュールのロード

主要な処理の実装に先立って，下記のコードでモジュールをロードします．

import copy
import json
import math
import os
import random
import sys
from functools import partial
from inspect import signature
from pathlib import Path
from typing import (
    Any,
    Dict,
    List
)

# Third party's modules
import numpy as np

import torch
from torch import nn
from torch.nn import functional as F
from torch.utils.data import (
    DataLoader)

from torchvision.transforms import Compose

# Local modules
sys.path.append("modules_gislr")
from modules_gislr.dataset import (
    HDF5Dataset,
    merge_padded_batch)
from modules_gislr.defines import (
    get_fullbody_landmarks
)
from modules_gislr.layers import (
    Identity,
    GPoolRecognitionHead,
    TransformerEnISLR
)
from modules_gislr.train_functions import (
    test_loop,
    val_loop,
    train_loop
)
from modules_gislr.transforms import (
    PartsBasedNormalization,
    ReplaceNan,
    SelectLandmarksAndFeature,
    ToTensor
)

【コード解説】
- 標準モジュール
  - copy: データコピーライブラリ．Transformerブロック内でEncoder層をコピーするために使用します．
  - json: JSONファイル制御ライブラリ．辞書ファイルのロードに使用します．
  - math: 数学計算処理ライブラリ
  - os: システム処理ライブラリ
  - random: ランダム値生成ライブラリ
  - sys: Pythonインタプリタの制御ライブラリ．
    今回はローカルモジュールに対してパスを通すために使用します．
  - functools: 関数オブジェクトを操作するためのライブラリ．
    今回はDataLoaderクラスに渡すパディング関数に対して設定値をセットするために使用します．
  - inspect.signature: オブジェクトの情報取得ライブラリ．
  - pathlib.Path: オブジェクト指向のファイルシステム機能．
    主にファイルアクセスに使います．osモジュールを使っても同様の処理は可能です．
    高山の好みでこちらのモジュールを使っています(^^;)．
  - typing: 関数などに型アノテーションを行う機能．
    ここでは型を忘れやすい関数に付けていますが，本来は全てアノテーションをした方が良いでしょう(^^;)．
- 3rdパーティモジュール
  - numpy: 行列演算ライブラリ
  - torch: ニューラルネットワークライブラリ
  - torchvision: PyTorchと親和性が高い画像処理ライブラリ．
    今回はDatasetクラスに与える前処理をパッケージするために用います．
- ローカルモジュール: sys.pathにパスを追加することでロード可能
  - dataset: データセット操作用モジュール
  - defines: 各部位の追跡点，追跡点間の接続関係，およびそれらへのアクセス処理を
    定義したモジュール
  - layers: ニューラルネットワークのモデルやレイヤモジュール
  - transforms: 入出力変換処理モジュール
  - train_functions: 学習・評価処理モジュール

3. 時系列クリッピング処理の実装

時系列クリッピング処理は下記のようになります．

class RandomClip():
    def __init__(self,
                 apply_ratio,
                 clip_range,
                 offset=-1,
                 min_apply_size=10):
        self.apply_ratio = apply_ratio
        self.clip_range = clip_range
        self.offset = offset
        self.min_apply_size = min_apply_size

    def __call__(self,
                 data: Dict[str, Any]) -> Dict[str, Any]:
        """Execute clipping.
        """
        if random.random() > self.apply_ratio:
            return data

        feature = data["feature"]
        base_timelen = feature.shape[1]
        if base_timelen > self.min_apply_size:
            aug_tscale = np.random.random() * (self.clip_range[1] - self.clip_range[0]) + self.clip_range[0]
            aug_timelen = int(base_timelen * (1 - aug_tscale))
            if aug_timelen < base_timelen:
                if self.offset < 0:
                    offset = np.random.randint(0, base_timelen - aug_timelen)
                else:
                    offset = self.offset
                # `[C, T, J]`
                feature = feature[:, offset: aug_timelen + offset, :]

        data["feature"] = feature
        return data

    def __str__(self):
        return f"{self.__class__.__name__}:{self.__dict__}"

【コード解説】
- 引数
  - apply_ratio: データ拡張の適用確率．
  - clip_range: クリッピング長の範囲．
    2要素の配列で `(min, max)` のように指定します．
    min, max は共に 0 以上 1 以下の値です．
    `clip_range` の範囲でランダムにクリッピング長を算出します．
  - offset: クリッピング開始点．
    `offset < 0` の場合は，(クリッピング終了点が入力データに収まる範囲で)
    ランダムにクリッピング開始点を決定します．
    `offset >= 0` の場合は，クリッピング開始点は固定です．
    `offset > min_apply_size` かつ，`offset > 元データの入力長` の場合は，
    エラーになるので注意してください．
  - min_apply_size: クリッピングを行う最短入力長．
- 7-10行目: 初期化処理
- 12-33行目: クリッピング処理
  - 16-17行目: ランダムに $[0, 1]$ の値を取得し，`apply_ratio` より上の値の場合は何もしない
  - 20-21行目: クリッピング長が `min_apply_size` より長いか判定
  - 22-23行目: `clip_range` の範囲でランダムにクリッピング長を算出
  - 24-30行目: `offset` に基づいてクリッピング開始点を算出し，クリッピングを適用
- 35-36行目: print()に対して，クラス名と設定値を返す

4. 認識モデルの動作確認

今回は，第九回の記事で紹介した，Pre-LN構成のTransformerモデルをそのまま用いて実験を行います．
ここではモデルの推論動作が正常に動くかだけ確かめます．

次のコードでデータセットからHDF5ファイルとJSONファイルのパスを読み込みます．

# Access check.
dataset_dir = Path("dataset_top10")
files = list(dataset_dir.iterdir())
dictionary = [fin for fin in files if ".json" in fin.name][0]
hdf5_files = [fin for fin in files if ".hdf5" in fin.name]

print(dictionary)
print(hdf5_files)

dataset_top10/sign_to_prediction_index_map.json
[PosixPath('dataset_top10/2044.hdf5'), PosixPath('dataset_top10/32319.hdf5'), PosixPath('dataset_top10/18796.hdf5'), PosixPath('dataset_top10/36257.hdf5'), PosixPath('dataset_top10/62590.hdf5'), PosixPath('dataset_top10/16069.hdf5'), PosixPath('dataset_top10/29302.hdf5'), PosixPath('dataset_top10/34503.hdf5'), PosixPath('dataset_top10/37055.hdf5'), PosixPath('dataset_top10/37779.hdf5'), PosixPath('dataset_top10/27610.hdf5'), PosixPath('dataset_top10/53618.hdf5'), PosixPath('dataset_top10/49445.hdf5'), PosixPath('dataset_top10/30680.hdf5'), PosixPath('dataset_top10/22343.hdf5'), PosixPath('dataset_top10/55372.hdf5'), PosixPath('dataset_top10/26734.hdf5'), PosixPath('dataset_top10/28656.hdf5'), PosixPath('dataset_top10/61333.hdf5'), PosixPath('dataset_top10/4718.hdf5'), PosixPath('dataset_top10/25571.hdf5')]

次のコードで辞書ファイルをロードして，認識対象の単語数を格納します．

# Load dictionary.
with open(dictionary, "r") as fread:
    key2token = json.load(fread)

VOCAB = len(key2token)

次のコードで前処理を定義します．
固定の前処理には，以前に説明した追跡点の選定と，追跡点の正規化を適用して実験を行います．

今回は孤立手話単語認識なので，少し大きめの範囲 (0.4 から 0.6) でクリッピングをするように設定しています．
連続手話単語認識などでは，値を大きくしすぎると単語が丸々カットされて，認識性能が落ちてしまう場合もあるので注意してください．

_, use_landmarks = get_fullbody_landmarks()
use_features = ["x", "y"]
trans_select_feature = SelectLandmarksAndFeature(landmarks=use_landmarks, features=use_features)
trans_repnan = ReplaceNan()
trans_norm = PartsBasedNormalization(align_mode="framewise", scale_mode="unique")

pre_transforms = Compose([trans_select_feature,
                          trans_repnan,
                          trans_norm])
transforms_default = Compose([ToTensor()])

transforms_w_daug = Compose([
    RandomClip(
        apply_ratio=0.5,
        clip_range=(0.4, 0.6)),
    ToTensor()])

次のコードで，前処理を適用したHDF5DatasetとDataLoaderをインスタンス化し，データを取り出します．
HDF5Dataset をインスタンス化する際に，transforms 引数に transforms_w_daug を渡してデータ拡張を有効にしています (10行目)．

batch_size = 2
feature_shape = (len(use_features), -1, len(use_landmarks))
token_shape = (1,)
merge_fn = partial(merge_padded_batch,
                   feature_shape=feature_shape,
                   token_shape=token_shape,
                   feature_padding_val=0.0,
                   token_padding_val=0)

dataset = HDF5Dataset(hdf5_files, pre_transforms=pre_transforms, transforms=transforms_w_daug)

dataloader = DataLoader(dataset, batch_size=batch_size, collate_fn=merge_fn)
try:
    data = next(iter(dataloader))
    feature_origin = data["feature"]

    print(feature_origin.shape)
except Exception as inst:
    print(inst)

torch.Size([2, 2, 64, 130])

次のコードでモデルをインスタンス化して，動作チェックをします．
追跡点抽出の結果，入力追跡点数は130で，各追跡点はXY座標値を持っていますので，入力次元数は260になります．
出力次元数は単語数なので10になります．
また，Transformer層の入力次元数は64に設定し，PFFN内部の拡張次元数は256に設定しています．

# Define model.
# in_channels: J * C (130*2=260)
#   J: use_landmarks (130)
#   C: use_channels (2)
# out_channels: 10
in_channels = len(use_landmarks) * len(use_features)
inter_channels = 64
out_channels = VOCAB
activation = "relu"
tren_num_layers = 2
tren_num_heads = 2
tren_dim_ffw = 256
tren_dropout_pe = 0.1
tren_dropout = 0.1
tren_layer_norm_eps = 1e-5
tren_norm_first = True
tren_add_bias = True
tren_add_tailnorm = True

model = TransformerEnISLR(in_channels=in_channels,
                          inter_channels=inter_channels,
                          out_channels=out_channels,
                          activation=activation,
                          tren_num_layers=tren_num_layers,
                          tren_num_heads=tren_num_heads,
                          tren_dim_ffw=tren_dim_ffw,
                          tren_dropout_pe=tren_dropout_pe,
                          tren_dropout=tren_dropout,
                          tren_layer_norm_eps=tren_layer_norm_eps,
                          tren_norm_first=tren_norm_first,
                          tren_add_bias=tren_add_bias,
                          tren_add_tailnorm=tren_add_tailnorm)
print(model)

# Sanity check.
logit = model(feature_origin)
print(logit.shape)
attw0 = model.tr_encoder.layers[0].attw.detach().cpu().numpy()
attw1 = model.tr_encoder.layers[0].attw.detach().cpu().numpy()
print(attw0.shape, attw1.shape)

TransformerEnISLR(
  (linear): Linear(in_features=260, out_features=64, bias=True)
  (activation): ReLU()
  (tr_encoder): TransformerEncoder(
    (pos_encoder): PositionalEncoding(
      (dropout): Dropout(p=0.1, inplace=False)
    )
    (layers): ModuleList(
      (0-1): 2 x TransformerEncoderLayer(
        (self_attn): MultiheadAttention(
          (w_key): Linear(in_features=64, out_features=64, bias=True)
          (w_value): Linear(in_features=64, out_features=64, bias=True)
          (w_query): Linear(in_features=64, out_features=64, bias=True)
          (w_out): Linear(in_features=64, out_features=64, bias=True)
          (dropout_attn): Dropout(p=0.1, inplace=False)
        )
        (ffw): PositionwiseFeedForward(
          (w_1): Linear(in_features=64, out_features=256, bias=True)
          (w_2): Linear(in_features=256, out_features=64, bias=True)
          (dropout): Dropout(p=0.1, inplace=False)
          (activation): ReLU()
        )
        (dropout): Dropout(p=0.1, inplace=False)
        (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)
        (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)
      )
    )
    (norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)
  )
  (head): GPoolRecognitionHead(
    (head): Linear(in_features=64, out_features=10, bias=True)
  )
)
torch.Size([2, 10])
(2, 2, 64, 64) (2, 2, 64, 64)

5. 学習と評価の実行

5.1 共通設定

では，実際に学習・評価を行います．
まずは，実験全体で共通して用いる設定値を次のコードで実装します．

# Set common parameters.
batch_size = 32
load_into_ram = True
test_pid = 16069
num_workers = os.cpu_count()
print(f"Using {num_workers} cores for data loading.")
lr = 3e-4

epochs = 50
eval_every_n_epochs = 1
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using {device} for computation.")

train_hdf5files = [fin for fin in hdf5_files if str(test_pid) not in fin.name]
val_hdf5files = [fin for fin in hdf5_files if str(test_pid) in fin.name]
test_hdf5files = [fin for fin in hdf5_files if str(test_pid) in fin.name]

_, use_landmarks = get_fullbody_landmarks()
use_features = ["x", "y"]

Using 2 cores for data loading.
Using cuda for computation.

5.2 学習・評価の実行

次のコードで学習・バリデーション・評価処理それぞれのためのDataLoaderクラスを作成します．
今回は，クリッピング処理の有無に寄る認識性能の違いを見たいので，実験毎にデータセットクラスをインスタンス化します．

# Build dataloaders.
train_dataset = HDF5Dataset(train_hdf5files, pre_transforms=pre_transforms,
    transforms=transforms, load_into_ram=load_into_ram)
val_dataset = HDF5Dataset(val_hdf5files, pre_transforms=pre_transforms,
    transforms=transforms, load_into_ram=load_into_ram)
test_dataset = HDF5Dataset(test_hdf5files, pre_transforms=pre_transforms,
    transforms=transforms, load_into_ram=load_into_ram)

train_dataloader = DataLoader(train_dataset, batch_size=batch_size, collate_fn=merge_fn, num_workers=num_workers, shuffle=True)
val_dataloader = DataLoader(val_dataset, batch_size=batch_size, collate_fn=merge_fn, num_workers=num_workers, shuffle=False)
test_dataloader = DataLoader(test_dataset, batch_size=1, collate_fn=merge_fn, num_workers=num_workers, shuffle=False)

次のコードでモデルをインスタンス化します．

tren_norm_first = True
tren_add_tailnorm = True

model_default = TransformerEnISLR(
    in_channels=in_channels,
    inter_channels=inter_channels,
    out_channels=out_channels,
    activation=activation,
    tren_num_layers=tren_num_layers,
    tren_num_heads=tren_num_heads,
    tren_dim_ffw=tren_dim_ffw,
    tren_dropout_pe=tren_dropout_pe,
    tren_dropout=tren_dropout,
    tren_layer_norm_eps=tren_layer_norm_eps,
    tren_norm_first=tren_norm_first,
    tren_add_bias=tren_add_bias,
    tren_add_tailnorm=tren_add_tailnorm)
print(model_default)

loss_fn = nn.CrossEntropyLoss(reduction="mean")
optimizer = torch.optim.Adam(model_default.parameters(), lr=lr)

TransformerEnISLR(
  (linear): Linear(in_features=260, out_features=64, bias=True)
  (activation): ReLU()
  (tr_encoder): TransformerEncoder(
    (pos_encoder): PositionalEncoding(
      (dropout): Dropout(p=0.1, inplace=False)
    )
    (layers): ModuleList(
      (0-1): 2 x TransformerEncoderLayer(
        (self_attn): MultiheadAttention(
          (w_key): Linear(in_features=64, out_features=64, bias=True)
          (w_value): Linear(in_features=64, out_features=64, bias=True)
          (w_query): Linear(in_features=64, out_features=64, bias=True)
          (w_out): Linear(in_features=64, out_features=64, bias=True)
          (dropout_attn): Dropout(p=0.1, inplace=False)
        )
        (ffw): PositionwiseFeedForward(
          (w_1): Linear(in_features=64, out_features=256, bias=True)
          (w_2): Linear(in_features=256, out_features=64, bias=True)
          (dropout): Dropout(p=0.1, inplace=False)
          (activation): ReLU()
        )
        (dropout): Dropout(p=0.1, inplace=False)
        (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)
        (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)
      )
    )
    (norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)
  )
  (head): GPoolRecognitionHead(
    (head): Linear(in_features=64, out_features=10, bias=True)
  )
)

次のコードで学習・評価処理を行います．

# Train, validation, and evaluation.
model_default.to(device)

train_losses = []
val_losses = []
test_accs = []
print("Start training.")
for epoch in range(epochs):
    print("-" * 80)
    print(f"Epoch {epoch+1}")

    train_losses = train_loop(train_dataloader, model_default, loss_fn, optimizer, device)
    val_loss = val_loop(val_dataloader, model_default, loss_fn, device)
    val_losses.append(val_loss)

    if (epoch+1) % eval_every_n_epochs == 0:
        acc = test_loop(test_dataloader, model_default, device)
        test_accs.append(acc)
train_losses_default = np.array(train_losses)
val_losses_default = np.array(val_losses)
test_accs_default = np.array(test_accs)

print(f"Minimum validation loss:{val_losses_default.min()} at {np.argmin(val_losses_default)+1} epoch.")
print(f"Maximum accuracy:{test_accs_default.max()} at {np.argmax(test_accs_default)*eval_every_n_epochs+1} epoch.")

Start training.
--------------------------------------------------------------------------------
Epoch 1
Start training.
/usr/lib/python3.10/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.
  self.pid = os.fork()
loss:3.339170 [    0/ 3881]
loss:1.838009 [ 3200/ 3881]
Done. Time:5.526299692999999
Training performance: 
 Avg loss:2.149870

Start validation.
Done. Time:0.22855789999999843
Validation performance: 
 Avg loss:2.059021

Start evaluation.
Done. Time:1.176137577999981
Test performance: 
 Accuracy:23.5%
--------------------------------------------------------------------------------
...
--------------------------------------------------------------------------------
Epoch 50
Start training.
loss:0.247186 [    0/ 3881]
loss:0.305739 [ 3200/ 3881]
Done. Time:2.642088887
Training performance: 
 Avg loss:0.194697

Start validation.
Done. Time:0.23894152299999405
Validation performance: 
 Avg loss:0.879709

Start evaluation.
Done. Time:1.1367939610000235
Test performance: 
 Accuracy:80.5%
Minimum validation loss:0.7402541786432266 at 47 epoch.
Maximum accuracy:83.5 at 47 epoch.

以後，同様の処理を設定毎に繰り返します．
コード構成は同じですので，ここでは説明を割愛させていただきます．また，この後グラフ等の描画も行っておりますが，本記事の主要点ではないため説明を割愛させていただきます．

なお，冒頭のメッセージは，マルチスレッドを fork という方法で立ち上げた場合に出る警告のようです．
内部動作に寄るもので，ユーザ側からの対策方法は分かっていませんが，現象にご興味がある方はこちらのリンクをご参照ください．

5.3 実験結果

認識性能の比較結果を図5に示します．
こちらは図4の再掲図です．

横軸は学習・評価ループの繰り返し数 (Epoch) を示します．
縦軸はそれぞれの評価指標を示します．

各線の色と実験条件の関係は次のとおりです．

青線 (Default): Pre-LN構成のTransformer
橙線 (+ T-Clip): 時系列クリッピング処理適用

デフォルトのモデルには，第九回の記事で紹介した，Pre-LN構成のTransformerモデルを用います．
比較結果から，時系列クリッピング処理を適用することでロスの挙動は安定しています．
第1.3項で述べたように，認識性能は...上がっているような...変わってないような...という感じですね(^^;)．

要因としては，

パラメータのチューニング
オリジナルのモデルにおいてAttentionが頑張って学習不足を補っている

ことなどが挙げられます．
また，クリッピングはデータの時間長は変えますが切り抜いた部分の特徴量はそのままなので，認識結果にそこまで差が出なかったことなども考えられます．

今回は追跡点系列を時間軸に沿ってクリッピングをして，データ拡張を行う手法を紹介しましたが，如何でしたでしょうか?
データ拡張は様々な手法が提案されており，組み合わせることでより多彩なデータを作りだすことが可能です．
次回以降もデータ拡張手法を紹介していきますので，是非ご自身で色々な組み合わせを試してみてください．

また，今回の本筋ではなかったのでさらっと流しましたが，第1.2項で述べたように時系列データを特徴マップで表現するのは，データを様々な視点で捉えるという観点から重要です．
時系列データを特徴マップに落とし込んで，画像処理のテクニックを適用するというアプローチもよく行われますので，機会があればまた別記事で紹介したいと思います．

今回紹介した話が，これから手話認識を勉強してみようとお考えの方に何か参考になれば幸いです．