세상의 변화에 대해 관심이 많은 이들의 Tech Blog search

Pytorch Geometric Message Passing 설명

|

본 글에서는 Pytorch Geometric에서 가장 기본이 되는 MessagePassing class에 대해 설명하고, 활용 방법에 대해서도 정리하도록 할 것이다.

GNN의 여러 대표 알고리즘이나 torch_geometric.nn의 대표 layer에 대한 간략한 설명을 참고하고 싶다면 Github을 참고해도 좋다.


Message Passing 설명

1. Background

GNN은 대체적으로 Neighborhood Aggregation & Combine 구조의 결합으로 구성되는데, 이를 또 다른 말로 표현하면 Message Passing이라고 할 수 있다.

특정 node를 설명하기 위한 재료로 그 node의 neighborhood의 특징을 모으는 과정이 바로 Message Passing인 것이다.

[x^{l+1}i = \gamma^l (x_i^l, AGG{j \in \mathcal{N}_i} \phi^l (x_j^l, …) )]

디테일의 차이는 있지만 GNN의 많은 대표 알고리즘들은 각자의 Message Passing 논리가 있고, Pytorch Geometric에서는 이러한 scheme을 효과적으로 구현하기 위해 MessagePassing이라는 class를 제공하고 있다.

Source 코드는 이 곳에서 확인할 수 있다.

MessagePassing은 torch.nn.Module을 상속받았기 때문에 이 class를 상속할 경우 다양한 Graph Convolutional Layer를 직접 구현할 수 있게 된다. (물론 굉장히 많은 Layer가 이미 기본적으로 제공되고 있다.)


2. MessagePassing 구조

MessagePassing을 생성할 때는 아래와 같은 사항을 정의해주어야 한다.

MessagePassing(aggr="add", flow="source_to_target", node_dim=-2)

위 예시는 기본 값을 나타낸 것으로, 설계에 따라 aggregation 방법을 mean/max 등으로 바꾸거나 할 수 있다.

source code를 보면 여러 메서드가 정의되어 있는 것을 알 수 있는데, 가장 중요한 메서드는 propagate이다. 이 메서드는 내부적으로 message, aggregate, update를 자동적으로 call한다. 앞서 보았던 식으로 설명하면 이해가 좀 더 편한데,

[x^{l+1}i = \gamma^l (x_i, AGG{j \in \mathcal{N}_i} \phi^l (x_j^l, …) )]

위 식에서 먼저 $\phi$ 에 해당하는 부분이 message이다. 이 영역은 대체적으로 미분 가능한 MLP로 구성하는데, 이웃 node x_j 의 정보를 어떻게 가공하여 target node x_i 에 전달할지를 정의하는 부분이다. 참고로 i, j notation은 Pytorch Geometric 전체에서 명확히 구분하고 있으니 임의로 바꾸는 것을 추천하지는 않는다.

식에서 $AGG$ 라고 되어 있는 부분이 당연히 aggregate를 의미한다. 이웃 node의 특성을 모으는 과정이다. 여러 방법이 있으나 일단은 간단하게 sum을 생각해보자.

$\gamma$ 함수가 update 부분을 담당하게 된다. 이전 layer의 값이 현재 layer로 업데이트 되는 것이다.


3. Code 설명

MessagePassing 코드를 보면 상단에 아래와 같은 부분이 있다.

class MessagePassing(torch.nn.Module):
    special_args: Set[str] = {
        'edge_index', 'adj_t', 'edge_index_i', 'edge_index_j', 'size',
        'size_i', 'size_j', 'ptr', 'index', 'dim_size'
    }

    def __init__(self, aggr: Optional[str] = "add",
                 flow: str = "source_to_target", node_dim: int = -2):

        super(MessagePassing, self).__init__()

        self.aggr = aggr
        assert self.aggr in ['add', 'mean', 'max', None]

        self.flow = flow
        assert self.flow in ['source_to_target', 'target_to_source']

        self.node_dim = node_dim

        # 함수를 검사하여 인자를 OrderedDict 형태로 취함
        # pop_first=True 이면 첫 인자는 버림
        self.inspector = Inspector(self)
        self.inspector.inspect(self.message)   # message 메서드
        ...

이후에도 확인하겠지만, 이 class를 구현할 때 여러 메서드들 작성해야 하는데, 대부분 additional argument를 허용하는 구조로 되어 있다. 그래서 MessagePassing class에서는 이러한 인자들을 inspector를 통해 제어한다.

import re
import inspect
from collections import OrderedDict
from typing import Dict, List, Any, Optional, Callable, Set

class Inspector(object):
    def __init__(self, base_class: Any):
        self.base_class: Any = base_class
        self.params: Dict[str, Dict[str, Any]] = {}

    def inspect(self, func: Callable,
                pop_first: bool = False) -> Dict[str, Any]:
        params = inspect.signature(func).parameters
        params = OrderedDict(params)
        if pop_first:
            params.popitem(last=False)
        self.params[func.__name__] = params

    def keys(self, func_names: Optional[List[str]] = None) -> Set[str]:
        keys = []
        for func in func_names or list(self.params.keys()):
            keys += self.params[func].keys()
        return set(keys)

    def __implements__(self, cls, func_name: str) -> bool:
        if cls.__name__ == 'MessagePassing':
            return False
        if func_name in cls.__dict__.keys():
            return True
        return any(self.__implements__(c, func_name) for c in cls.__bases__)

    def implements(self, func_name: str) -> bool:
        return self.__implements__(self.base_class.__class__, func_name)

    def types(self, func_names: Optional[List[str]] = None) -> Dict[str, str]:
        out: Dict[str, str] = {}
        for func_name in func_names or list(self.params.keys()):
            func = getattr(self.base_class, func_name)
            arg_types = parse_types(func)[0][0]
            for key in self.params[func_name].keys():
                if key in out and out[key] != arg_types[key]:
                    raise ValueError(
                        (f'Found inconsistent types for argument {key}. '
                         f'Expected type {out[key]} but found type '
                         f'{arg_types[key]}.'))
                out[key] = arg_types[key]
        return out

    def distribute(self, func_name, kwargs: Dict[str, Any]):
        # func_name = 예) 'message'
        # kwargs = coll_dict
        # inspector.params['message']에 있는 argument들을 불러온 뒤
        # 이들에게 해당하는 데이터를 coll_dict에서 가져옴
        out = {}
        for key, param in self.params[func_name].items():
            data = kwargs.get(key, inspect.Parameter.empty)
            if data is inspect.Parameter.empty:
                if param.default is inspect.Parameter.empty:
                    raise TypeError(f'Required parameter {key} is empty.')
                data = param.default
            out[key] = data
        return out

아래 코드는 어떤 함수가 갖고 있는 argument들을 불러오는 것을 의미한다.

params = inspect.signature(func).parameters

예를 들어 아래 코드를 실행하면,

import inspect
from collections import OrderedDict

def func(a='OH', b=7, *args, **kwargs):
    pass

params = inspect.signature(func).parameters
params = OrderedDict(params)

다음과 같은 결과를 확인할 수 있다.

OrderedDict([('a', <Parameter "a='OH'">), ('b', <Parameter "b=7">), ('args', <Parameter "*args">), ('kwargs', <Parameter "**kwargs">)])

위 사항을 인지하고 다시 코드를 보면,

class MessagePassing(torch.nn.Module):
    special_args: Set[str] = {
        'edge_index', 'adj_t', 'edge_index_i', 'edge_index_j', 'size',
        'size_i', 'size_j', 'ptr', 'index', 'dim_size'
    }

    def __init__(self, aggr: Optional[str] = "add",
                 flow: str = "source_to_target", node_dim: int = -2):

        super(MessagePassing, self).__init__()

        self.aggr = aggr
        assert self.aggr in ['add', 'mean', 'max', None]

        self.flow = flow
        assert self.flow in ['source_to_target', 'target_to_source']

        self.node_dim = node_dim

        # 함수를 검사하여 인자를 OrderedDict 형태로 취함
        # pop_first=True 이면 첫 인자는 버림
        self.inspector = Inspector(self)
        self.inspector.inspect(self.message)
        self.inspector.inspect(self.aggregate, pop_first=True)
        self.inspector.inspect(self.message_and_aggregate, pop_first=True)
        self.inspector.inspect(self.update, pop_first=True)

        self.__user_args__ = self.inspector.keys(
            ['message', 'aggregate', 'update']).difference(self.special_args)
        self.__fused_user_args__ = self.inspector.keys(
            ['message_and_aggregate', 'update']).difference(self.special_args)

        # Support for "fused" message passing.
        # message_and_aggregate 메서드를 구현하면 self.fuse = True
        # self.inspector.base_class.__dict__.keys()에서 확인 가능
        self.fuse = self.inspector.implements('message_and_aggregate')

위 과정이 여러 메서드의 인자들을 수집한 후 이를 OrderedDict에 저장하는 과정임을 알 수 있다.

코드를 밑바닥에서 보면 파악하는 속도가 느리기 때문에 실제 데이터를 바탕으로 이어서 확인해보도록 하겠다.

import torch
from torch_geometric.datasets import Planetoid
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degree
import torch_geometric.transforms as T

# Load Cora Dataset
dataset = 'Cora'
path = os.path.join(os.getcwd(), 'data', dataset)
dataset = Planetoid(path, dataset, transform=T.NormalizeFeatures())
data = dataset[0]

x, edge_index = data.x, data.edge_index

print(x.shape, edge_index.shape)
# (torch.Size([2708, 1433]), torch.Size([2, 10556]))

2708개의 node가 존재하고, 이 node들은 10556개의 edge를 통해 graph를 구성하고 있음을 알 수 있다. 초반에 확인한 flow=”source_to_target”는 edge_index의 첫 행은 source node, 두 번째 행은 target node로 구성되어 있다는 것을 의미한다.

이제 공식 문서의 예제에서 처럼 GCN Layer를 한 번 정의해보자.

class GCNConv(MessagePassing):
    def __init__(self, in_channels, out_channels):
        super(GCNConv, self).__init__(aggr='add')
        self.lin = torch.nn.Linear(in_channels, out_channels)

    def forward(self, x, edge_index):
        # x has shape [N, in_channels]
        # edge_index has shape [2, E]

        # Step 1: Add self-loops to the adjacency matrix.
        edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))

        # Step 2: Linearly transform node feature matrix.
        x = self.lin(x)

        # Step 3: Compute normalization.
        row, col = edge_index
        deg = degree(col, x.size(0), dtype=x.dtype)
        deg_inv_sqrt = deg.pow(-0.5)
        deg_inv_sqrt[deg_inv_sqrt == float('inf')] = 0
        norm = deg_inv_sqrt[row] * deg_inv_sqrt[col]

        # Step 4-5: Start propagating messages.
        return self.propagate(edge_index, x=x, norm=norm)

    def message(self, x_j, norm):
        # x_j has shape [E, out_channels]

        # Step 4: Normalize node features.
        return norm.view(-1, 1) * x_j

conv = GCNConv(x.shape[1], 32)

몇 가지 사항에 대해 확인해 보자.

# conv.inspector.params
# = message_passing이 갖고 있는 method의 인자들을 일부(pop_item=True)를 제외하고 취한 것
# Ex) {'message': OrderedDict([('x_j', <Parameger "x_j">)])}
for param, item in conv.inspector.params.items():
    print(param, ': ', item)

# check
print(conv.__user_args__)
print(conv.__fused_user_args__)
print(conv.fuse)

"""
message :  OrderedDict([('x_j', <Parameter "x_j">), ('norm', <Parameter "norm">)])
aggregate :  OrderedDict([('index', <Parameter "index: torch.Tensor">), ('ptr', <Parameter "ptr: Optional[torch.Tensor] = None">), ('dim_size', <Parameter "dim_size: Optional[int] = None">)])
message_and_aggregate :  OrderedDict()
update :  OrderedDict()

# check
{'norm', 'x_j'}
set()
False
"""

step 3까지 모두 진행했다고 해보자. 그러면 propagate 메서드에서 수행할 작업은 edge_index, 즉 주어진 graph 구조에 맞게 x의 feature들을 통합하는 과정이 될 것이다.

propagate 메서드 상단 부분을 보자. 복잡함을 피하기 위해 fused version 부분은 제거하였다. (실제로 사용할 때는 message_and_aggregate를 구현하는 것이 좋을 때가 많다. 왜냐하면 불필요한 연산을 줄임으로써 속도를 개선하고 메모리 사용량을 줄일 수 있기 때문이다. 아예 구현하지 않으면 호출될 일이 없다.)

def propagate(self, edge_index: Adj, size: Size = None, **kwargs):
    size = self.__check_input__(edge_index, size)

    # Run "fused" message and aggregation (if applicable).
    # (생략)

    # Otherwise, run both functions in separation.
    elif isinstance(edge_index, Tensor) or not self.fuse:
        coll_dict = self.__collect__(
            self.__user_args__, edge_index, size, kwargs)

위 메서드에서 kwargs 부분은 중요하다. 왜냐하면 MessagePassing 클래스는 내부적으로 message, aggregate, update에서 추가한 argument들(위 예시에서는 norm 같은 경우)을 propagate 메서드에서 사용할 수 있게 해두었기 때문이다. 그렇기 때문에 위 GCN Layer에서도 아래와 같이 추가적인 argument를 전달할 수 있는 것이다.

# Step 4-5: Start propagating messages.
return self.propagate(edge_index, x=x, norm=norm)

coll_dict는 이 프로세스를 통과하고 있는 주요 변수/데이터를 딕셔너리 형태로 저장한 것이다. 위 예시에서 coll_dict는 아래와 같은 형상을 하고 있다.

{'norm': tensor([0.2500, 0.2236, 0.2500,  ..., 0.5000, 0.2000, 0.2000]),
 'x_j': tensor([[-0.0106, -0.0185, -0.0095,  ...,  0.0051, -0.0180,  0.0261],
                 ...,
                [-0.0148, -0.0149, -0.0153,  ..., -0.0033, -0.0236,  0.0217]],
                 grad_fn=<IndexSelectBackward>),
 'adj_t': None,
 'edge_index': tensor([[   0,    0,    0,  ..., 2705, 2706, 2707],
                       [ 633, 1862, 2582,  ..., 2705, 2706, 2707]]),
 'edge_index_i': tensor([ 633, 1862, 2582,  ..., 2705, 2706, 2707]),
 'edge_index_j': tensor([   0,    0,    0,  ..., 2705, 2706, 2707]),
 'ptr': None,
 'index': tensor([ 633, 1862, 2582,  ..., 2705, 2706, 2707]),
 'size': [2708, None],
 'size_i': 2708,
 'size_j': 2708,
 'dim_size': 2708}

나머지 과정을 확인해 보자. 복잡한 설명을 피하기 위해 중간 부분은 생략하였다.

msg_kwargs = self.inspector.distribute('message', coll_dict)
out = self.message(**msg_kwargs)

# For `GNNExplainer`, we require a separate message and aggregate
# (생략)

aggr_kwargs = self.inspector.distribute('aggregate', coll_dict)
out = self.aggregate(out, **aggr_kwargs)

update_kwargs = self.inspector.distribute('update', coll_dict)
output = self.update(out, **update_kwargs)

위 과정은 message, aggregate, update을 차례로 실행하는 과정이다. 이 때 inspector.distribute 부분은 coll_dict에서 필요한 데이터를 불러오는 과정을 의미하는데, 내부적으로 실행 과정을 보면 아래와 같다.

1) func_name = ‘message`
2) arguments = inspector.params[func_name]
3) arguements에 해당하는 데이터를 coll_dict에서 가져옴

이를 통해 생성된 결과물은 아래 예시에서 확인할 수 있다.

print({a:b.shape for a, b in msg_kwargs.items()})
# {'x_j': torch.Size([13264, 32]), 'norm': torch.Size([13264])}

aggregate 메서드를 적용한 후의 결과물의 shape은 (2708, 32)가 되는데, 이는 (target x_i 수, out_channels)와 일치한다. 즉 이 결과물은 node x_i를 기준으로 aggregated 된 feature matrix인 것이다. update 메서드를 적용해서 최종 아웃풋을 얻을 수 있는데, 위 예시에서는 update 메서드를 수정하지 않았으므로 이전 단계의 결과물이 그대로 전달된다.

지금까지가 MessagePassing class에 대한 간략한 설명이었고, 추후에는 이를 응용하여 Custom Graph Convolutional Layer를 만드는 방법에 대해 포스팅하도록 할 계획이다.

Comment  Read more

MMDetection 사용법 1(Quick Run)

|

이 글에서는 MMDetection를 사용하는 방법을 정리한다.


기본 설명

OpenMMLab에서는 매우 많은 최신 모델을 Open Source Projects로 구현하여 공개하고 있다.
2021.08.30 기준 11개의 Officially Endorsed Projects와 6개의 Experimental Projects를 공개하고 있다.

11개 프로젝트의 목록을 아래에 적어 놓았다. 예를 들어 어떤 이미지를 detect하는 모델을 찾고 싶으면 MMDetection에서 찾으면 된다. 대부분 따로 설명하지 않아도 무엇을 하는 모델인지 알 것이다.

  • MMCV: Computer Vision
  • MMDetection
  • MMAction2
  • MMClassification
  • MMSegmentation
  • MMDetection3D
  • MMEditing: Image and Video Editing
  • MMPose: Pose estimation
  • MMTracking
  • MMOCR
  • MMGeneration

각각의 repository는 수십 개의 모델을 포함한다. 예를 들어 MMDetection

Supported backbones:

  • ResNet (CVPR’2016)
  • ResNeXt (CVPR’2017)
  • VGG (ICLR’2015)
  • HRNet (CVPR’2019)
  • RegNet (CVPR’2020)
  • Res2Net (TPAMI’2020)
  • ResNeSt (ArXiv’2020)

Supported methods:

  • RPN (NeurIPS’2015)
  • Fast R-CNN (ICCV’2015)
  • Faster R-CNN (NeurIPS’2015)
  • Mask R-CNN (ICCV’2017)
  • Cascade R-CNN (CVPR’2018)
  • Cascade Mask R-CNN (CVPR’2018)
  • SSD (ECCV’2016)
  • RetinaNet (ICCV’2017)
  • GHM (AAAI’2019)
  • Mask Scoring R-CNN (CVPR’2019)
  • Double-Head R-CNN (CVPR’2020)
  • Hybrid Task Cascade (CVPR’2019)
  • Libra R-CNN (CVPR’2019)
  • Guided Anchoring (CVPR’2019)
  • FCOS (ICCV’2019)
  • RepPoints (ICCV’2019)
  • Foveabox (TIP’2020)
  • FreeAnchor (NeurIPS’2019)
  • NAS-FPN (CVPR’2019)
  • ATSS (CVPR’2020)
  • FSAF (CVPR’2019)
  • PAFPN (CVPR’2018)
  • Dynamic R-CNN (ECCV’2020)
  • PointRend (CVPR’2020)
  • CARAFE (ICCV’2019)
  • DCNv2 (CVPR’2019)
  • Group Normalization (ECCV’2018)
  • Weight Standardization (ArXiv’2019)
  • OHEM (CVPR’2016)
  • Soft-NMS (ICCV’2017)
  • Generalized Attention (ICCV’2019)
  • GCNet (ICCVW’2019)
  • Mixed Precision (FP16) Training (ArXiv’2017)
  • InstaBoost (ICCV’2019)
  • GRoIE (ICPR’2020)
  • DetectoRS (ArXix’2020)
  • Generalized Focal Loss (NeurIPS’2020)
  • CornerNet (ECCV’2018)
  • Side-Aware Boundary Localization (ECCV’2020)
  • YOLOv3 (ArXiv’2018)
  • PAA (ECCV’2020)
  • YOLACT (ICCV’2019)
  • CentripetalNet (CVPR’2020)
  • VFNet (ArXix’2020)
  • DETR (ECCV’2020)
  • Deformable DETR (ICLR’2021)
  • CascadeRPN (NeurIPS’2019)
  • SCNet (AAAI’2021)
  • AutoAssign (ArXix’2020)
  • YOLOF (CVPR’2021)
  • Seasaw Loss (CVPR’2021)
  • CenterNet (CVPR’2019)
  • YOLOX (ArXix’2021)

를 포함한다.(많다)

이 글에서는 MMDetection 중 Faster-RCNN 모델을 다루는 법만 설명한다. 나머지도 비슷한 흐름을 따라갈 듯 하다.


설치

Prerequisites

  • Linux or macOS (Windows is in experimental support)
  • Python 3.6+
  • PyTorch 1.3+
  • CUDA 9.2+ (If you build PyTorch from source, CUDA 9.0 is also compatible)
  • GCC 5+
  • MMCV

공식 문서에서 Docker를 통해 사용하는 방법도 안내하고 있는데, 현재 Docker의 환경은 다음과 같다.

  • Linux
  • Python 3.7.7
  • PyTorch 1.6.0
  • TorchVision 0.7.0
  • CUDA 10.1 V10.1.243
  • mmcv-full 1.3.5

자신이 사용하는 환경이 복잡하다면 얌전히 Docker를 쓰는 편이 낫다..

설치 방법은

에 나와 있으니 참고하자. Docker 쓰면 별다른 에러 없이 바로 구동 가능하다.

Docker 설치방법 안내에 나와 있지만, data/ 디렉토리는 자신이 사용하는 환경에서 데이터를 모아놓는 디렉토리에 연결해놓으면 좋다.

docker run --name openmmlab --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmdetection/data mmdetection

그리고 설치 방법에 나와 있는 것처럼 repository를 다운받아 놓자.(Docker는 이미 되어 있다)

git clone https://github.com/open-mmlab/mmdetection
cd mmdetection

Docker를 쓰기로 했으면 Docker 내에서 다음 명령어를 입력해서 설치를 진행하자.

apt-get update
apt-get install git vim wget

간단 실행

High-level APIs for inference

우선 checkpoints 디렉토리를 만들고 다음 모델 파일을 받자.

현재 worktree는 다음과 같다.

  • 참고: 공식 문서에는 config 파일을 따로 받아야 할 것처럼 써 놨지만 repository에 다 포함되어 있다.
mmdetection
├── checkpoints
|   ├── faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth
├── configs
│   ├── faster_rcnn
│   │   ├── faster_rcnn_r50_fpn_1x_coco.py
│   │   ├── ...
├── data
├── demo
|   ├── demo.jpg
|   ├── demo.mp4
|   ├── ...
├── mmdet
├── tools
│   ├── test.py
│   ├── ...
├── tutorial_1.py
├── ...

tutorial_1.py 파일을 만들고 다음 코드를 붙여넣자.

  • 참고: 공식 문서 코드에서는 파일명이 test.jpg 처럼 자신이 직접 집어넣어야 하는 파일들로 되어 있지만, 이건 어차피 튜토리얼이니까 기본 제공되는 demo 폴더 내의 이미지와 비디오 파일을 쓰자.
from mmdet.apis import init_detector, inference_detector
import mmcv

# Specify the path to model config and checkpoint file
config_file = 'configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py'
checkpoint_file = 'checkpoints/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth'

# build the model from a config file and a checkpoint file
model = init_detector(config_file, checkpoint_file, device='cuda:0')

# test a single image and show the results
img = 'demo/demo.jpg'  # or img = mmcv.imread(img), which will only load it once
result = inference_detector(model, img)
# visualize the results in a new window
model.show_result(img, result)
# or save the visualization results to image files
model.show_result(img, result, out_file='demo/demo_result.jpg')

# test a video and show the results
video = mmcv.VideoReader('demo/demo.mp4')
for frame in video:
    result = inference_detector(model, frame)
    model.show_result(frame, result, wait_time=1)

python tutorial_1.py로 실행해보면 GUI가 지원되는 환경이면 결과가 뜰 것이고, 아니면 demo/demo_result.jpg를 열어보면 된다.

demo_result.jpg

Demos(Image, Webcam, Video)

이미지 한 장에 대해서 테스트하는 경우를 가져왔다. 나머지 경우는 공식 문서에서 보면 된다.

python demo/image_demo.py \
    ${IMAGE_FILE} \
    ${CONFIG_FILE} \
    ${CHECKPOINT_FILE} \
    [--device ${GPU_ID}] \
    [--score-thr ${SCORE_THR}]

예시:

python demo/image_demo.py demo/demo.jpg \
    configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py \
    checkpoints/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth \
    --device cuda:0

Test existing models on standard datasets

COCO, Pascal VOC, CityScapes(, DeepFashion, Ivis, Wider-Face) 등의 표준 데이터셋의 경우 바로 테스트를 수행해 볼 수 있다. 데이터를 다운받고 압축을 풀어 아래와 같은 형태로 두면 된다.

mmdetection
├── mmdet
├── tools
├── configs
├── data
│   ├── coco
│   │   ├── annotations
│   │   ├── train2017
│   │   ├── val2017
│   │   ├── test2017
│   ├── cityscapes
│   │   ├── annotations
│   │   ├── leftImg8bit
│   │   │   ├── train
│   │   │   ├── val
│   │   ├── gtFine
│   │   │   ├── train
│   │   │   ├── val
│   ├── VOCdevkit
│   │   ├── VOC2007
│   │   ├── VOC2012

COCO-stuff 데이터셋 등 다른 일부 데이터셋 혹은 추가 실행 옵션의 경우 공식 문서를 참조하면 된다.

가장 기본이 되는 1개의 GPU로 결과를 확인하는 코드는 아래와 같다. 아무 키나 누르면 다음 이미지를 보여준다.

python tools/test.py \
    configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py \
    checkpoints/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth \
    --show

생성된 이미지를 보여주지 않고 저장하는 코드는 아래와 같다. 그냥 output directory를 지정하기만 하면 된다.

  • 참고: 공식 문서에는 config 파일 이름이 조금 잘못된 것 같다.
python tools/test.py \
    configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py \
    checkpoints/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth \
    --show-dir faster_rcnn_r50_fpn_1x_results

COCO 말고 다른 데이터셋을 쓰거나, Multi-GPU 등을 사용하는 경우는 공식 문서를 참조하면 된다.

저장된 5000개의 이미지(COCO test, faster_rcnn) 중 하나를 가져와 보았다.

faster_rcnn_result.jpg

Test without Ground Truth Annotations

데이터셋 형식 변환

COCO 형식으로 변환하는 것을 기본으로 하는 것 같다.

다른 형식의 데이터셋은 다음 코드를 통해 COCO 형식으로 바꿀 수 있다.

python tools/dataset_converters/images2coco.py \
    ${IMG_PATH} \
    ${CLASSES} \
    ${OUT} \
    [--exclude-extensions]

파일 형식에 따라 다음 파일로 대체하면 된다.

변환을 완료했으면 다음 코드를 통해 GT annotation 없이 테스트를 해볼 수 있다.

# single-gpu testing
python tools/test.py \
    ${CONFIG_FILE} \
    ${CHECKPOINT_FILE} \
    --format-only \
    --options ${JSONFILE_PREFIX} \
    [--show]

1. Train predefined models on standard datasets

데이터셋 등은 위에서 설명한 대로 준비해 놓자.

학습하는 코드는 다음과 같다.

# single GPU
python tools/train.py \
    ${CONFIG_FILE} \
    [optional arguments]
# Multiple GPUs
bash ./tools/dist_train.sh \
    ${CONFIG_FILE} \
    ${GPU_NUM} \
    [optional arguments]

# 예시
python tools/train.py \
    configs/faster_rcnn/faster_rcnn_r50_fpn_2x_coco.py 
    --work-dir work_dir_tutorial_2

bash ./tools/dist_train.sh  
    configs/faster_rcnn/faster_rcnn_r50_fpn_2x_coco.py 
    2

log 파일과 checkpoint는 work_dir/ 또는 --work-dir로 지정한 디렉토리에 생성된다.

config 파일만 지정하면 알아서 학습이 진행된다. 실행 환경 정보, 모델, optimizer, 평가방법 등 config 정보 등이 출력되며 학습이 시작된다.
기본적으로 evaluation을 매 epoch마다 진행하는데, 이는 추가 옵션으로 바꿀 수 있다.

  • 1개의 Titan X로는 5일 7시간, 2개로는 3일 8시간 정도 소요된다고 나온다.

위에서 설명한 페이지 아래쪽에는 이외에도 여러 개의 job을 동시에 돌리는 법, Slurm으로 돌리는 방법 등이 공식 홈페이지에 있으니 쓸 생각이 있으면 참조하면 된다.


2: Train with customized datasets

다른 데이터셋을 가져와서 학습하는 방법을 설명하는데, 다음 단계를 따르면 된다.

  1. 사용할 데이터셋을 준비한다. annotation을 COCO format으로 변환하면 편하다.
  2. Config 파일을 수정한다.
  3. 준비한 데이터셋에서 학습과 추론을 진행한다.

여기서는 balloon dataset을 COCO format으로 변환한 다음 학습하는 방법을 설명한다.

Annotation 파일을 COCO format으로 변환

Balloon dataset의 annotation 파일은 대충 다음과 같이 생겼다.

{'base64_img_data': '',
 'file_attributes': {},
 'filename': '34020010494_e5cb88e1c4_k.jpg',
 'fileref': '',
 'regions': {'0': {'region_attributes': {},
   'shape_attributes': {'all_points_x': [1020,
     1000,
     994,
     ...
     1020],
    'all_points_y': [963,
     899,
     841,
     ...
     963],
    'name': 'polygon'}}},
 'size': 1115004}

COCO format은 다음과 같다.

 {
    "images": [image],
    "annotations": [annotation],
    "categories": [category]
}


image = {
    "id": int,
    "width": int,
    "height": int,
    "file_name": str,
}

annotation = {
    "id": int,
    "image_id": int,
    "category_id": int,
    "segmentation": RLE or [polygon],
    "area": float,
    "bbox": [x,y,width,height],
    "iscrowd": 0 or 1,
}

categories = [{
    "id": int,
    "name": str,
    "supercategory": str,
}]

그러니 Balloon dataset의 annotation 파일(json 파일)을 COCO format으로 변환하는 코드가 필요하다.

  • 참고: 공식 홈페이지 코드에는 어째 import mmcv가 빠져 있다.
import os.path as osp
import mmcv

def convert_balloon_to_coco(ann_file, out_file, image_prefix):
    data_infos = mmcv.load(ann_file)
    
    annotations = []
    images = []
    obj_count = 0
    for idx, v in enumerate(mmcv.track_iter_progress(data_infos.values())):
        filename = v['filename']
        img_path = osp.join(image_prefix, filename)
        height, width = mmcv.imread(img_path).shape[:2]
        
        images.append(dict(
            id=idx,
            file_name=filename,
            height=height,
            width=width))
        
        bboxes = []
        labels = []
        masks = []
        for _, obj in v['regions'].items():
            assert not obj['region_attributes']
            obj = obj['shape_attributes']
            px = obj['all_points_x']
            py = obj['all_points_y']
            poly = [(x + 0.5, y + 0.5) for x, y in zip(px, py)]
            poly = [p for x in poly for p in x]
            
            x_min, y_min, x_max, y_max = (
                min(px), min(py), max(px), max(py))
            
            
            data_anno = dict(
                image_id=idx,
                id=obj_count,
                category_id=0,
                bbox=[x_min, y_min, x_max - x_min, y_max - y_min],
                area=(x_max - x_min) * (y_max - y_min),
                segmentation=[poly],
                iscrowd=0)
            annotations.append(data_anno)
            obj_count += 1
    
    coco_format_json = dict(
        images=images,
        annotations=annotations,
        categories=[{'id':0, 'name': 'balloon'}])
    mmcv.dump(coco_format_json, out_file)


convert_balloon_to_coco('train/via_region_data.json',
                        'train/annotation_coco.json',
                        'train')

convert_balloon_to_coco('val/via_region_data.json',
                        'val/annotation_coco.json',
                        'val')

위의 코드를 다음과 같이 놓고 실행하면 변환이 완료된다.

balloon
├── convert_annotations.py
├── train
│   ├── *.jpg
│   ├── via_region_data.json
│   ├── annotation_coco.json
├── val
│   ├── *.jpg
│   ├── via_region_data.json
│   ├── annotation_coco.json

결과:

root@0d813b2889d8:/mmdetection/data/balloon# python convert_annotation.py 
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 61/61, 49.4 task/s, elapsed: 1s, ETA:     0s
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 13/13, 48.6 task/s, elapsed: 0s, ETA:     0s

Config 파일 준비

mmdetection/configs/balloon/ 디렉토리를 만들고 mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon.py 파일을 생성한다. Mask R-CNN with FPN 모델을 사용하기 때문에 이러한 이름을 가진다.

파일 내용은 다음과 같다.

# The new config inherits a base config to highlight the necessary modification
_base_ = '../mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco.py'

# We also need to change the num_classes in head to match the dataset's annotation
model = dict(
    roi_head=dict(
        bbox_head=dict(num_classes=1),
        mask_head=dict(num_classes=1)))

# Modify dataset related settings
dataset_type = 'COCODataset'
classes = ('balloon',)
data = dict(
    train=dict(
        img_prefix='data/balloon/train/',
        classes=classes,
        ann_file='data/balloon/train/annotation_coco.json'),
    val=dict(
        img_prefix='data/balloon/val/',
        classes=classes,
        ann_file='data/balloon/val/annotation_coco.json'),
    test=dict(
        img_prefix='data/balloon/val/',
        classes=classes,
        ann_file='data/balloon/val/annotation_coco.json'))

# We can use the pre-trained Mask RCNN model to obtain higher performance
load_from = 'checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'

학습 및 추론하기

Checkpoint 파일을 받아서 checkpoints/ 안에 둔다.

현재 디렉토리 구조는 다음과 같다. 위치가 다르다면 경로를 수정해도 된다.

mmdetection
├── mmdet
├── tools
├── configs
│   ├── balloon
│   │   ├── mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon.py
│   ├── mask_rcnn
│   │   ├── mask_rcnn_r50_caffe_fpn_1x_coco.py
│   │   ├── mask_rcnn_r50_fpn_1x_coco.py'
│   │   ├── ...
├── checkpoints
│   ├── faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth
│   ├── mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth
├── data
│   ├── balloon
│   │   ├── convert_annotations.py
│   │   ├── train
│   │   │   ├── *.jpg
│   │   │   ├── annotation_coco.json
│   │   ├── val
│   │   │   ├── *.jpg
│   │   │   ├── annotation_coco.json

이제 학습을 진행하면 된다.

python tools/train.py configs/balloon/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon.py

결과:

...
2021-09-03 06:37:20,209 - mmdet - INFO - Saving checkpoint at 12 epochs
2021-09-03 06:37:20,690 - mmdet - INFO - Exp name: mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon.py
2021-09-03 06:37:20,690 - mmdet - INFO - Epoch(val) [12][13]    bbox_mAP: 0.7080, 
bbox_mAP_50: 0.8280, bbox_mAP_75: 0.7820, bbox_mAP_s: 0.2020, bbox_mAP_m: 0.4750, 
bbox_mAP_l: 0.8110, bbox_mAP_copypaste: 0.708 0.828 0.782 0.202 0.475 0.811, 
segm_mAP: 0.7460, segm_mAP_50: 0.8190, segm_mAP_75: 0.7740, segm_mAP_s: 0.4040, 
segm_mAP_m: 0.4850, segm_mAP_l: 0.8350, segm_mAP_copypaste: 0.746 0.819 0.774 0.404 0.485 0.835

이제 work_dirs에는 다음과 같이 파일들이 생성되어 있다. 명령창에서 --work-dirs 옵션을 주었다면 해당 디렉토리로 들어가면 된다.

mmdetection
├── work_dirs
│   ├── mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon
│   │   ├── 20210903_061911.log  
│   │   ├── ...
│   │   ├── 20210903_062541.log  
│   │   ├── 20210903_063427.log.json  
│   │   ├── epoch_1.pth   
│   │   ├── epoch_2.pth  
│   │   ├── ...
│   │   ├── epoch_12.pth  
│   │   ├── latest.pth
│   │   ├── mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon.py

latest.pth 파일을 이용해서 테스트를 진행하려면 다음과 같이 입력한다.

python tools/test.py \
    configs/balloon/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon.py \
    work_dirs/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon/latest.pth \
    --eval bbox segm \
    --show-dir results/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon
  • 참고: 공식 코드에는 어째서인지 디렉토리 이름을 ...balloon.py\latest.path로 적어 놨다… 대규모 프로젝트의 코드치고 자잘한 오류가 많다.

대략 다음과 같은 결과를 얻을 수 있다.

OrderedDict([
    ('bbox_mAP', 0.708), ('bbox_mAP_50', 0.828), ('bbox_mAP_75', 0.782),
    ('bbox_mAP_s', 0.202), ('bbox_mAP_m', 0.475), ('bbox_mAP_l', 0.811), 
    ('bbox_mAP_copypaste', '0.708 0.828 0.782 0.202 0.475 0.811'), ('segm_mAP', 0.746), 
    ('segm_mAP_50', 0.819), ('segm_mAP_75', 0.774), ('segm_mAP_s', 0.404), 
    ('segm_mAP_m', 0.485), ('segm_mAP_l', 0.835), 
    ('segm_mAP_copypaste', '0.746 0.819 0.774 0.404 0.485 0.835')
])

이제 mmdetection/results/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_balloon 디렉토리에 들어가보면 data/balloon/val 안에 있던 13개의 이미지에 대해 bbos를 친 결과를 확인할 수 있다.

balloon_result.jpg

3: Train with customized models and standard datasets

CityScapes와 같은 표준 데이터셋에 사용자 모델을 학습시키려면 다음 과정을 따른다.

  1. 표준 데이터셋을 준비한다.
  2. 사용자 모델을 준비한다.
  3. Config 파일을 생성한다.
  4. 표준 데이터셋에서 사용자 모델을 학습 및 추론한다.

CityScapes 데이터셋 준비

  • 참고: 이 부분은 미구현된 부분이 있어서 그대로는 동작하지 않는다.

먼저 다운로드를 해야 한다. 학교 이메일 등으로만 회원가입이 된다(gmail 불가).

홈페이지에서 다음을 받으면 된다.

  • leftImg8bit_trainvaltest.zip (11GB)
  • gtFine_trainvaltest.zip (241MB)

참고로 annotations은 각각의 데이터셋 안에 들어 있으니 따로 추가로 받아야 할 것은 없다.

CityScapes는 위에서 설명했던 것과 같이 데이터셋은 다음과 같은 구조로 둔다.

mmdetection
├── mmdet
├── tools
├── configs
├── data
│   ├── coco
│   │   ├── annotations
│   │   ├── train2017
│   │   ├── val2017
│   │   ├── test2017
│   ├── cityscapes
│   │   ├── annotations
│   │   ├── leftImg8bit
│   │   │   ├── train
│   │   │   ├── val
│   │   ├── gtFine
│   │   │   ├── train
│   │   │   ├── val
│   ├── VOCdevkit
│   │   ├── VOC2007
│   │   ├── VOC2012

CityScapes류 데이터셋은 COCO format으로 변환하는 과정이 필요하다.

pip install cityscapesscripts
python tools/dataset_converters/cityscapes.py ./data/cityscapes --nproc 8 --out-dir ./data/cityscapes/annotations

그러면 간단히 변환이 완료된다.

Converting train into instancesonly_filtered_gtFine_train.json
Loaded 2975 images from ./data/cityscapes/leftImg8bit/train
Loading annotation images
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 2975/2975, 30.1 task/s, elapsed: 99s, ETA:     0s
It took 100.40516328811646s to convert Cityscapes annotation

사용자 모델 준비

여기서는 Cascade Mask R-CNN R50 모델을 기반으로 하는 모델을 사용자 모델로 쓴다. 이 모델을 그대로 쓰는 것은 아니고 FPNAugFPN으로, training time auto augmentation으로 RotateTranslate를 추가하는 변형을 가한다.

새 파일 mmdet/models/necks/augfpn.py을 만든다.

from ..builder import NECKS

@NECKS.register_module()
class AugFPN(nn.Module):

    def __init__(self,
                in_channels,
                out_channels,
                num_outs,
                start_level=0,
                end_level=-1,
                add_extra_convs=False):
        pass

    def forward(self, inputs):
        # implementation is ignored
        pass

그리고 mmdet/models/necks/__init__.py 파일에 from .augfpn import AugFPN 코드를 추가하거나,

config 파일에 다음을 추가하면 된다.

custom_imports = dict(
    imports=['mmdet.models.necks.augfpn.py'],
    allow_failed_imports=False)

__init__.py 파일은 다음과 같이 생겼다.

사용자 모델을 설계하는 방법이나 학습 세팅에 대한 더 자세한 정보는 다음 링크를 참고하자.

Config 파일 준비

이제 configs/cityscapes/cascade_mask_rcnn_r50_augfpn_autoaug_10e_cityscapes.py 파일을 생성하자.

config 파일의 코드는 여기를 참조하자.

학습 및 추론

python tools/train.py configs/cityscapes/cascade_mask_rcnn_r50_augfpn_autoaug_10e_cityscapes.py
python tools/test.py configs/cityscapes/cascade_mask_rcnn_r50_augfpn_autoaug_10e_cityscapes.py work_dirs/cascade_mask_rcnn_r50_augfpn_autoaug_10e_cityscapes.py/latest.pth --eval bbox segm

Tutorials에 대한 설명은 다음 글에서..

Comment  Read more

IGMC (Inductive Graph-based Matrix Completion) 설명

|

이번 글에서는 IGMC란 알고리즘에 대해 다뤄보겠다. 상세한 내용을 원하면 논문 원본을 참고하길 바라며, 본 글에서는 핵심적인 부분에 대해 요약 정리하도록 할 것이다.

Github에 관련 코드 또한 정리해서 업데이트할 예정이다.


Inductive Matrix Completion based on Graph Neural Networks 설명

1. Background

행렬 분해 알고리즘의 기본에 대해 알고 싶다면 이 글을 참조하길 바란다. Graph Neural Networks을 이용하여 Matrix Completion 알고리즘을 구축한 대표적인 예는 GC-MC가 될 것이다. 이에 대해 알고 싶다면 이 글을 참고하면 좋다. GC-MC는 Bipartite Graph에 직접적으로 GNN을 적용하여 user와 item의 잠재 벡터를 추출하였다. 이전의 대부분의 연구와 마찬가지로 GC-MC 또한 Transductive한 모델로, 학습 셋에서 사용하지 않은 unseen nodes에 대한 대응이 불가능하다는 단점을 지니고 있었다. GraphSAGE, PinSAGE 등 여러 알고리즘에서 Inductive한 방법론을 제시하기는 했지만 이들 방법론을 적용하기 위해서는 node의 feature가 풍부해야 한다.

node feature에 크게 의존하지 않으면서도 Inductive한 학습/예측 환경으로 앞서 기술한 문제점들을 상당 부분 해결한 모델이 IGMC: Inductive Graph-based Matrix Completion이다.


2. IGMC 알고리즘 설명

일반적으로 통용되는 방식으로 기호를 정의하고 시작하겠다.

기호 설명
$\mathbf{G}$ undirected bipartite graph
$\mathbf{R}$ rating matrix
$ u, v $ 각각 user, item node
$ r = \mathbf{R}_{u, v} $ user $u$ 가 item $v$ 에 부여한 평점
$ \mathcal{N}_r (u)$ user $u$가 평점 $r$ 을 준 $v$ 의 집합, 즉 edge type $r$ 에 대한 $u$ 의 이웃 집합

IGMC의 핵심 아이디어는 user $u$ 와 item $i$ 에 관련이 있는 local subgraph를 추출하여 이를 학습에 활용한다는 점이다.

위 그림을 보면 이해가 될 것이다. 진한 초록색 5점의 예시를 보면, $u_2$ 가 $i_7$ 에게 5점을 부여한 것을 알 수 있다. 그렇다면 이 두 node에 대한 1-hop enclosing subgraph는 $u_2$ 의 1-hop neighbor인 [ $i_5, i_7, i_8$ ], 그리고 $i_7$ 의 1-hop neighbor인 [ $u_2, u_3, u_4$ ]로 구성되는 것이다. 물론 최종적으로 학습/예측을 할 때는 Target Rating인 5점은 masking될 것이다.

subgraph를 추출하는 BFS 과정은 아래 표에 나와있다.

다음으로는 node labeling 과정이 필요하다. 여기에서의 label은 y값이 아니고, 각 node의 임시 ID를 의미한다. subgraph를 추출하였으면 이 node를 구분할 id가 필요한데, IGMC의 경우 global graph를 참조하는 경우는 없고 오직 subgraph만을 이용하여 학습/예측을 수행하기 때문에 기존의 id 방식을 그대로 따를 필요가 없다. IGMC의 구조에 맞게 바꿔보자.

구분 user id item id
target 0 1
1-hop 2 3
2-hop 4 5
h-hop 2h 2h+1

위와 같이 subgraph 내에서의 node id를 다시 붙여주면 (node labeling) 각각의 node들은 역할에 맞게 구분된다. 위 label을 통해 0과 1을 추출하여 target node를 구분할 수 있고, 홀수/짝수 구분을 통해 user/item을 구분할 수 있으며, $h$ 의 값을 통해 어떤 계층(h-hop)에 속하는지도 파악할 수 있다. 이러한 node label을 One-hot 인코딩하여 초기 node feature로 활용할 수 있다.

다음 단계는 GNN을 통해 학습을 수행하는 것이다. IGMC의 특징이라면 GC-MC를 비롯한 여러 알고리즘과 달리 node-level GNN이 아니라 graph-level GNN을 사용한다는 것인데, 논문에서는 이 부분에 대해 장점을 크게 어필하고 단점을 끝에 살짝 언급한 수준에 그쳤는데 상황에 따라 단점이 더 클 수도 있다는 개인적인 의견을 덧붙인다.

GNN의 기본 구조를 message passing과 pooling(or aggregation)이라고 정의할 때, message passing은 Relational Graph Convolution Operator: R-GCN 포맷을 사용하였다.

[x^{l+1} = W_0^l x_i^l + \Sigma_{r \in \mathcal{R}} \Sigma_{j \in \mathcal{N}_r(i)} \frac{1}{\vert \mathcal{N}_r (i) \vert} W_r^l x_j^l]

활성화 함수로는 tanh를 사용하게 된다. 1번째 $\Sigma$ 는 각 Rating 별로 따로 파라미터를 둔다는 것을 의미하며, 그 내부에서는 일반적인 GCN이 적용된다. 다만 이 때 이웃 집합의 크기를 나타내는 $\mathcal{N}_r^i$ 가 global graph가 아닌 local subgraph에서 계산된 것이기 때문에 효율적으로 연산이 가능하다는 점은 기억해둘 필요가 있다. 이렇게 쭉 진행해서 $L$ 번째 Layer까지 값을 얻었으면 아래와 같이 최종 hideen representation을 얻는다.

[\mathbf{h}_i = concat(x_i^1, x_i^2, …, x_i^L)]

위와 같은 방식을 적용하면, jumping network의 효과도 있을 것으로 보인다. 이렇게 user, item에 대해 각각의 hidden 벡터를 구한 뒤 이를 다시 하나의 벡터로 결합하면 (sub) graph representation을 얻을 수 있다. 이렇게 graph 표현 벡터를 얻는 것을 graph-level GNN이라고 한다.

[\mathbf{g} = concat(\mathbf{h}_u, \mathbf{h}_v)]

위와 같은 pooling 과정은 간단하지만 실제로 적용하였을 때 우수한 성과를 내는 것이 실험으로 증명되었다고 한다. MLP를 적용해서 최종적으로 rating 예측 값을 얻을 수 있다.

[\hat{r} = \mathbf{w}^T \sigma (\mathbf{W} \mathbf{g})]

활성화 함수는 ReLU를 사용하였다.


3. Model Training

Mean Squared Error를 Loss Function으로 사용하였다.

[\mathcal{L} = \frac{1}{\vert { (u, v) \vert \Omega_{u, v} = 1 } \vert} \Sigma_{(u, v): \Omega_{u, v} = 1} (R_{u, v} - \hat{R}_{u, v})^2]

$\Omega$ 부분은 관측된 edge에 대해서만 Loss를 계산하겠다는 뜻을 담고 있다.

R-GCN layer에 AAR: Adjacent Ratin Regularization이라는 기법이 적용되었다. 이 부분은 사실 GC-MC에서도 간과하고 있었던 부분으로, 평점의 정도(magnitude)를 고려하기 위해서 도입되었다. R-GCN layer를 보면 사실 평점 4점이 평점 1점에 비해 5점에 더 가깝다를 나타내는 그 어떠한 장치도 마련되어 있지 않다. 이를 위해서 아래와 같은 ARR Regulaizer가 적용되었다.

[\mathcal{L}{ARR} = \Sigma{i=1,2,…, \vert \mathcal{R} \vert -1} \Vert \mathbf{W}{r_i + 1} - \mathbf{W}{r_i} \Vert^2_F]

이 때 $\Vert \Vert_F$ 는 행렬의 frobenius norm을 의미한다. 이 부분에 대해서는 이 글의 가장 마지막 슬라이드를 참고해도 좋다. 결과적으로 이 규제항을 적용하면 $\mathbf{W}_5$ 는 $\mathbf{W}_4$ 와 비슷해지는 효과가 나타날 것이다.

최종 Loss 함수는 아래와 같다.

[\mathcal{L}{final} = \mathcal{L}{MSE} + \lambda \mathcal{L}_{ARR}]

모델 구현은 pytorch_geometric에 기반하여 이루어졌고, 저자의 코드는 이 곳에서 참고할 수 있다. 상세한 세팅은 논문을 직접 참고하길 바란다.

여러 데이터셋에 대한 실험 결과는 아래와 같다. IGMC가 대체적으로 좋은 성과를 보이는 것을 확인할 수 있다. 하나 기억해야 할 부분은 F-EAE 알고리즘을 제외하면 다른 비교 모델들은 각 데이터의 node feature를 활용한 반면, IGMC는 앞서 기술한 것처럼, node의 feature에 의존하지 않았다는 점이 흥미롭다. 즉 그러한 feature 없이도 설정에 따라 충분한 성능을 확보할 수 있다는 의미이다.


4. 인사이트 종합

IGMC의 핵심 인사이트는 아래와 같이 정리할 수 있겠다.

1) node feature와 같은 side information 없이도 충분한 성능을 확보할 수 있음
2) local graph pattern은 user-item 관계를 파악하기에 충분함
3) long-range dependency는 추천 시스템을 구상할 때 크게 중요하지 않은 경우가 많음
4) sparse한 데이터에서도 충분히 성능을 발휘할 수 있음
5) node feature에 의존하지 않기 때문에 transfer learning에도 효과적으로 활용할 수 있음
6) graph-level prediction을 통해 더욱 효과적인 학습/예측을 수행할 수 있음
7) 1-hop neighbors 까지만 추출해도 충분한 성능을 확보할 수 있음

4번에 대해서는 논문의 5.3 section에 설명이 되어있다.

위 그림과 같이 GC-MC에 비해 sparsity가 강화되는 환경에서 RMSE의 증가폭이 완만한 것을 확인할 수 있다. 이는 Transductive한 Matrix Completion 방법론은 밀집도가 높은 user-item interaction에 더욱 의존한다는 것을 의미한다.

5번의 경우 논문의 5.4 section에 설명되어 있다. IGMC는 node feature가 부재한 상황에서도 Inductive한 학습 환경을 구축할 수 있다는 특징을 가지는데, 이를 이용하여 실제로 실험을 수행해본 결과 transfer learning에도 효과적임이 입증되었다.

6번의 경우 아래 그림을 바탕으로 설명하겠다.

좌측이 IGMC의 예시인데, $\mathbf{g}$ 라는 (sub) graph representation을 생성한 뒤 한 번 더 MLP를 거쳐 최종 예측 값을 반환하기 때문에 graph-level prediction의 형태를 띠고 있다. 반면 우측의 경우 user, item 각각의 representation을 형성 한 후 내적 기반의 연산을 통해 예측 값을 반환하게 된다.

논문에서는 이렇게 각 node의 subtree embedding을 독립적으로 구하는 것이 각 tree의 상호작용과 상관성을 포착하기 어렵다는 문제점을 지닌다고 지적한다. 즉, convolution range를 늘린다 하더라도 (h-hop 에서 h를 늘린다 하더라도) target node와 별 상관 없는, 먼 거리에 있는 node들이 subgraph에 포함되어 over-smoothing 문제를 야기할 수 있다는 것이다. 이 부분은 합당한 지적이며 IGMC는 이러한 단점을 보완하여 더욱 높은 성능의 결과를 보여줌으로써 해결 방안을 제시했다고 볼 수 있다.

다만 논문에서도 언급하였듯이 IGMC의 graph-level 학습 세팅은 시간이 더욱 오래 걸린다는 단점을 지닌다. 비록 추출된 subgraph의 최대 edge 수를 특정 값 = $K$ 로 제한하는 방법을 통해 이를 어느 정도 보완할 수는 있겠지만 구조적으로 node-level prediction이 갖는 시간적 이점을 압도하기는 어려운 것이 사실이다.

이 부분에 있어서는 본인이 마주한 task에 따라 장단점을 따져야 할 것으로 보이며, 성능과 속도 사이의 적절한 완급 조절이 필요할 것으로 보인다. 만약 IGMC와 같은 graph-level prediction으로는 충분한 속도를 확보하기 어렵다면 user, item 각각의 representation을 구한 뒤 scoring을 수행하는 node-level prediction의 구조를 일부 차용하여 IGMC를 변형하는 방법 또한 실질적으로 고려해볼 수 있을 것이다.

7번의 경우 필자도 실제 여러 GNN 모델을 적용해보면서 느낀 바인데, 1-hop neighbors로도 괜찮은 성과를 보이는 경우가 많았다.

추가적으로 IGMC의 한계를 짚고 넘어가자면, IGMCInductive한 방법론이기에 unseen nodes에 대해 대응이 가능하지만 다른 수 많은 GNN 모델과 마찬가지로 아예 아무 interaction이 없으면 접근에 있어 어려움이 있다.

Appendix: high-score & low-score subgraph의 다른 패턴

Comment  Read more

APPNP(Predict Then Propagate) 설명

|

이번 글에서는 APPNP란 알고리즘에 대해 다뤄보겠다. 상세한 내용을 원하면 논문 원본을 참고하길 바라며, 본 글에서는 핵심적인 부분에 대해 요약 정리하도록 할 것이다.

torch_geomectric을 이용하여 APPNP를 사용하는 방법에 대해서 간단하게 Github에 올려두었으니 참고해도 좋을 것이다.


PREDICT THEN PROPAGATE: GRAPH NEURAL NETWORKS MEET PERSONALIZED PAGERANK 설명

1. Background

일반적인 GNN에서의 문제점 중 하나는 node에 대해 오직 몇 번의 propagation만 고려되고, 이렇게 커버되는 이웃의 범위를 늘리기가 쉽지 않다는 것이다. 본 논문에서는 GCN과 PageRank의 관계를 이용하여 Personalized PageRank(PPR)에 기반한 개선된 propagation scheme을 구축한다. 결과로 PPNP (Personalized Propagation of Neural Predictions)라는 간단한 모델을 제시하며, 빠르게 근사하는 버전으로 APPNP (Approximate PPNP)를 제시한다.

참고로 PageRank와 본 APPNP 논문과도 관련이 깊은 GDC 논문에 대해서 참고하고자 한다면, 이 글을 확인하길 바란다.

Original PageRank를 변형하여 정의한 Personalized PageRank의 식은 아래와 같은 재귀식으로 표현할 수 있다.

[\mathbf{\pi}{ppr}(i_x) = (1-\alpha) \hat{\tilde{\mathbf{A}}} \mathbf{\pi}{ppr}(i_x) + \alpha i_x]

이 때 Teleport 확률 $\alpha$ 는 0~1 사이로 설정된다. 참고로 위 식은 GDC 글에서 기술된 아래 식과 같은 식이다.

[\mathbf{r} = \beta \mathbf{r} + (1-\beta) a]

위 식을 풀어내면 아래 식을 얻을 수 있다.

[\mathbf{\pi}_{ppr}(i_x) = \alpha( \mathbf{I}_n - (1-\alpha) \hat{\tilde{\mathbf{A}}} )^{-1} i_x]

indicator 벡터 $i_x$ 는 limit 분포에서도 node의 지역 이웃 정보를 보존하는 역할을 수행한다. 이 벡터를 unit 행렬 $\mathbf{I}_n$ 로 대체하면 최종적으로 fully Personalized PageRank 행렬을 얻을 수 있다.

[\mathbf{\Pi}_{ppr} = \alpha(\mathbf{I}_n - (1-\alpha)\hat{\tilde{\mathbf{A}}})^{-1}]

2. PPNP 및 APPNP 도출

최종 예측값을 도출하기 위해서는 각 node의 feature에 기반하여 예측 값을 생성한뒤 이를 앞서 기술한 fully Personalized PageRank scheme을 통해 전파를 시킨다. 모델 식은 아래와 같다.

[\mathbf{Z}_{PPNP} = activation( \alpha(\mathbf{I}_n - (1-\alpha) \hat{\tilde{\mathbf{A}}})^{-1} \mathbf{H} )]

[\mathbf{H}{i, :} = Net(\mathbf{X}{i, :})]

이 때, $\mathbf{H}$ 는 Neural Network를 통과한 예측값으로 형상은 (node의 수, class의 수)이다. 물론 softmax를 통해 여러 class에 대한 예측을 수행하는 것이 아니라면 class의 수는 1이 될 것이다.

그런데 위 식을 직접적으로 계산하면 계산 비효율이 발생한다. 이를 해결하기 위해 위해 위 식을 fully PPR 행렬과 Prediction 행렬의 조합으로 보기 보다는, 각 class가 하나의 topic을 구성하는 topic-sensitive PageRank의 변형으로 바라볼 것이다. 이 관점에서 $\mathbf{H}$ 의 모든 칼럼은 teleport set의 역할을 수행하여 nodes에 대한 정규화되지 않은 분포를 정의하게 된다.

PPNP 식을 Power Iteration을 통해 근사하면 APPNP 식을 얻을 수 있다.

[\mathbf{Z}^0 = \mathbf{H} = Net(\mathbf{X})]

[\mathbf{Z}^{k+1} = (1-\alpha) \hat{\tilde{\mathbf{A}}} \mathbf{Z}^k + \alpha \mathbf{H}]

위 재귀식을 일정 수준 반복하면 수렴된 값을 얻을 수 있을 것이고, 그 값이 APPNP의 최종 예측값이 된다. 위 재귀식의 수렴성의 증명에 관해서는 본 논문의 Appendix B를 참조하면 된다.

3. APPNP의 의미

지금까지 살펴본 내용에 기반하여 정리한 APPNP의 의미와 특징은 아래와 같다.

  • Propgation 부분과 예측값을 생성하는 부분이 분리가 되어있다. 따라서 GNN의 Layer의 수를 늘린다 하더라도 Over-smoothing을 포함한 여러 문제가 나타날 가능성이 낮아진다. 또한 예측값을 생성하는 Neural Network의 구조의 자유도가 높아져 여러 다른 선택지를 고려할 수 있다.
  • 모델은 반드시 end-to-end 구조로 학습되어야 한다. 역전파 과정 속에서 Gradient는 Propagation Scheme을 통과하게 되고, 이를 통해 암시적으로 여러 이웃 통합 과정을 고려하게 되는 것이다. 이를 통해 모델의 정확도를 상당 수준 향상시킬 수 있다.
  • Propagation에 있어 추가적인 파라미터를 활용하지 않는다.
  • Teleport 확률 $\alpha$ 를 통해 이웃 node 끼리 영향을 주는 정도와 범위를 조절하게 된다.

4. 실험 결과와 생각할 부분

본 논문의 실험 결과에는 꽤 흥미로운 부분이 많다. 간단하게만 정리하겠다.

실험에서는 4가지의 text-classification 데이터셋이 사용되었다. (CITESEER, CORA-ML, PUBMED, Microsoft Academic) PPNPAPPNP에서 사용되는 Neural Network는 GCN의 구조와 거의 유사하게 설계되었다. (2개의 Layer와 64 hidden size) 첫 번째 Layer에서 $\lambda=0.005$ 의 L2 규제를 적용하였고, Dropout Rate은 0.5를 적용하였다. APPNP의 경우 $\alpha=0.1$, 그리고 Power Iteration의 횟수는 $K=10$ 으로 설정하였다. 자세한 사항은 논문을 참조하길 바란다.

모든 데이터셋에서 PPNPAPPNP는 대조 모델들을 압도하는 모습을 보였다. 다만 추가적인 행렬 계산의 존재 때문에 속도는 조금 느려졌다는 점은 고려할 필요가 있다. Sparse Label 환경에서 PPNPAPPNP의 개선 효과는 더욱 돋보였다.

추가적인 실햄에서 APPNP의 경우 아래와 같이 Power Iteration이 늘어날 수록 일반적으로 결과는 향상되는 모습을 보였다.

Teleport 확률의 경우 대체적으로 0.05 ~ 0.2 사이에서 좋은 모습을 보였고, 이 값이 증가할수록 수렴 속도는 빨라졌다.

또 하나 재미있는 사실은, 아래 그림에서 확인할 수 있듯이 Training 당시에 Propagation을 생략하고 Inference 과정에서만 Propagation을 진행해도 크게 성능이 떨어지지 않았다는 것이다. 적용되는 데이터에 따라 차이가 있겠지만 이를 통해 APPNP가 Pre-trained된 모델과도 꽤 잘 결합할 수 있을 것이라는 가능성을 엿볼 수 있다.

논문에서는 또한 Training 과정에서만 Propagation을 진행했을 때 Propagation을 아예 수행하지 않았을 때에 비해 성능 향상이 크게 이루어졌기 때문에, feature는 존재하나 이웃 정보가 없는 Inductive Learning 상황에서 유용하게 사용할 수 있을 것이라고 언급하고 있는데 이 부분에 대해서는 그 이유가 정확히 파악되지 않는다는 점을 메모로 남긴다.

마무리하자면, APPNP는 기존의 이웃 통합 (Aggregation) 과정에 대해 또 하나의 유용한 선택지를 제공해주었다고 볼 수 있다. 또한 다른 GNN과 결합하여서 사용할 수 있기 때문에 설계 상의 이점이 있고, Power Iteration을 많이 하더라도 파라미터가 증가하지 않고 Gradient가 소실되거나 Over-smoothing 문제가 발생할 가능성이 낮기 때문에 실제 적용하는 데 있어서도 고려해야 할 조건이 적다는 장점을 지닌다.

Comment  Read more

HowTo100M 설명(HowTo100M - Learning a Text-Video Embedding by Watching Hundred Million Narrated Video Clips, Antoine Miech et al, 7 Jun 2019, 1906.03327)

|

이 글에서는 2019년 ICCV에 발표된 HowTo100M - Learning a Text-Video Embedding by Watching Hundred Million Narrated Video Clips 논문을 살펴보고자 한다.

중요한 부분만 적을 예정이므로 전체가 궁금하면 원 논문을 찾아 읽어보면 된다.


HowTo100M - Learning a Text-Video Embedding by Watching Hundred Million Narrated Video Clips

논문 링크: HowTo100M - Learning a Text-Video Embedding by Watching Hundred Million Narrated Video Clips

데이터셋, 코드 및 모델: Project webpage

초록(Abstract)

Text-video 임베딩을 학습하는 것은 대개 video clip과 수동으로 만든 caption을 필요로 한다. 그러나 이러한 데이터셋은 만드는 것이 매우 비싸며 오래 걸리고 따라서 큰 규모의 데이터셋을 얻기 힘들다. 본 연구에서, 이러한 임베딩을 video에서 학습하는 대신 쉽게 얻을 수 있는 자동생성된 narration을 annotation으로 사용한다. 이 논문이 기여한 바는,

  1. HowTo100M 데이터셋 제안: 23k개의 다른 visual task를 묘사하는 절차적 web video에서 얻은 136M개의 video clip을 포함
  2. 위 데이터로 학습한 Text-video 임베딩이 text-to-video retrieval과 action localization에서 SOTA로 이끔을 보임
  3. 이 임베딩이 Youtube video나 movie 등 다른 domain에서 잘 transfer되는 것을 보임

1. 서론(Introduction)

실세계를 이해하고 상호작용하는 것은 시각적(영상) 정보와 언어(텍스트) 정보를 이해하고 상호작용하는 것과 매우 유사성이 높다. 그러나 text-to-video retrieval, video captioning, VQA 등의 task는 여전히 AI 시스템에게 있어 상당히 어려운 과제이다.

언어를 묘사하는 visual concept을 다루는 일반적인 방법은 text와 video를 공통 임베딩 공간으로 mapping하여 관련된 text와 video clip들이 비슷한 곳에 모여 있게 하는 것이다. 그러나 이러한 방법은 매우x2 큰 데이터셋을 필요로 하지만, 현존하는 데이터셋(MSR-VTT, DiDeMo, EPIC-KITCHENS) 등은 수동 생성한 annotation이 수천~수만 정도의 규모밖에 되지 않으며 그 품질 또한 낮은 경우도 있다.

본 연구에서는 video와 language의 결합표현을 학습할 수 있는 video clip과 text caption 쌍을 얻는 방법을 탐색하였다. YouTube에서 narrated instructional video는 규모가 크고 대량의 visual/language 데이터를 얻을 수 있다. Instructional video는 대개 narration을 포함하며 명시적으로 영상의 내용을 설명하기에 학습용으로 적합하다.
따라서 YouTube에서 23k 종류 이상의 서로 다른 task를 수행하는 것을 묘사하는 1.22M개의 narrated instructional video를 수집하였다. 각 clip은 자동 생성된 narration 형식으로 text annotation와 연결되어 있다.

기여한 바가 적혀 있는데, 이는 초록의 내용과 같다.


2. 관련 연구(Related Work)

Visual/textual cue의 이해에 기반한 여러 CV task가 제안되어 왔다.

Vision, language and speech

Visual/Textual cue가 서로 비슷한 경우에만 공통 공간 내에서 인접하게 하는 방식이 일반적이다. 이들은 대부분 잘 annotated된 데이터셋을 필요로 하기에 상당히 비용이 비싸다.

본 논문에서는 수동으로 annotation을 일절 하지 않고 자동 생성된 narration만을 사용한다. Spoken text를 사용하는 모델이 있었지만 음성 녹음이 안 되어 있거나 그 규모가 매우 작은 편이었다.

HERO

Learning from instructional videos

복잡한 과제를 해결하는 학습 과정으로써 최근 주목받고 있다. Visual-linguistic reference resolution, action segmentation 등의 task에서 여러 모델이 제안되었으나 역시 적은 수의 미리 지정된 label에서 추출한 trasncription만이 존재했다.

이후 WikiHow, COIN, CrossTask 등의 데이터셋이 만들어졌고 이들은 대개 YouTube에서 대량의 영상 정보를 획득하였다. HowTo100M도 비슷하게 YouTube에서 영상을 얻었으나 그 양이 전례없이 매우 방대하다.

Large scale data for model pretraining

Noisy할 수도 있는 web data로부터 얻은 대규모 데이터셋은 language 및 vision 모델에서 유망한 부분이다. BERT, GPT-2 등은 대규모 데이터를 사용하여 많은 task에서 SOTA를 달성하였다. GPT-2와 WebText는 Reddit에서 얻은 40GB의 text를 사용하여 좋은 결과를 얻었다.

이에 영감을 받아 video와 language의 공통 임베딩을 학습하고자 하였다. YouTube에서 얻은 1M 이상의 영상을 사용하여, 미세조정 없이도 instructional video에서 이전 결과를 넘을 뿐 아니라 non-instructinoal video에 대해서도 잘 작동한다.


3. The HowTo100M dataset

요리, 수공예, 개인 생활/관리, 원예 등의 활동에 대한 내용을 포함하는 1.22M개의 영상을 포함한다. 각 영상은 (올린 사람이 만들었을) 자막 혹은 ASR로 자동 생성된 narration을 가진다.

3.1 Data collection

Visual tasks

  • Instructional video는 어떻게 특정 활동을 수행하는지를 묘사하기 때문에 어떤 활동이 있는지를 먼저 WikiHow(“어떻게 무엇을 하는가”라는 12만 개의 article 포함)에서 가져왔다.
  • 많은 영상들 중 추상적인 것(“선물 선택하기”)보다는 “시각적인” 활동(“땅콩버터 만들기”)에 초점을 맞추었다. Task는 12종류로 한정하였고 관계/경제/사업 등 추상적인 task는 제외하였다.
  • “물리적인” 활동이 포함되는 것(make, build, change)을 남기고 그렇지 않은 것(be, accept, feel)은 반자동으로 제거하였다.
  • 최종적으로 23,611개의 visual task가 생성되었다.
HERO

Instructional videos

How to <task name> 형태의 제목을 가지며 영어 자막(사람이 올렸거나 혹은 YouTube API인 ASR로 얻은 것)을 가지는 영상을 찾았다. 이후 다음 과정을 통해 품질과 일관성을 높였다.

  • 검색 결과의 상위 200까지만 사용하고 나머지는 관련성이 별로 없을 가정하에 제외함
  • 조회수 100 미만의 영상은 제외
  • 100 단어 이하의 영상은 배울 것이 별로 없으므로 제외
  • 2,000초 이하의 영상만 사용
  • 중복 영상(동일 ID) 제거

3.2 Paired video clips and captions

자막은 text의 뭉치들로 이루어져 있으며 때때로 완전한 문장의 형태가 아닌 경우도 있다. 각 줄은 영상의 특정 구간과 연관된다(특히 그 자막이 읽히는 부분). 각 자막을 caption으로 사용하여 video clip의 연관된 구간과 쌍을 만든다(그림 2).

MSR-VTT와 같은 clip-caption 쌍으로 구성된 다른 데이터셋과 달리 HowTo100M은 자동으로 만든 narration을 사용한다. 그래서 (아마도) 약하게 짝을 이룬(weakly paired) 것으로 생각된다. 영상에서는 구독자와 소통하는 등 주제와 상관 없는 내용이 있을 수도 있고 문장도 완전하지 않거나 문법적으로 틀릴 수도 있다. 임의로 400개의 clip-caption 쌍을 선택해서 확인한 결과 자막에 포함된 물체나 행동 등이 적어도 한 번 나올 확률은 51%였다.

Statistics

12개의 분류로 나누어져 있으며 예시는 그림 2에서 볼 수 있다. 자세한 내용은 부록 A에 있다.
각 데이터셋의 clip-caption의 개수는 표 1에서 볼 수 있다.

HERO

HowTo100M은,

  • 다른 데이터셋에 비해 훨씬 크다.
  • 자동 생성된 annotation을 사용하여 자막의 품질이 깨끗하지 않다.
  • 평균적으로 하나의 영상은 110개의 clip-caption 쌍을 만들며 clip당 4초, 4단어 정도이다.
  • 100개를 임의로 확인한 결과 71%는 instructional한 영상, 12%는 vlog, 7%는 리뷰나 광고였다.
    • vlog나 리뷰, 광고는 시각적인 내용과 narration 사이의 관련성이 있을 수 있다.
  • non-instructional video를 특별히 제거하지는 않았는데, 공통 임베딩을 학습하는 데 도움을 줄 수 있어서다.

4. Text-video joint embedding model

$n$개의 video clip과 연관된 caption $\lbrace (V_i, C_i) \rbrace^n_{i=1}$이 주어진다.

[\mathbf{v} \in \mathbb{R}^{d_v}, \mathbf{c} \in \mathbb{R}^{d_c}]

목적은 video와 caption feature를 $d$차원의 공통 공간으로 mapping하는 함수를 만드는 것이다.

[f : \mathbb{R}^{d_v} \rightarrow \mathbb{R}^{d}, \quad g : \mathbb{R}^{d_c} \rightarrow \mathbb{R}^{d}]

cosine 유사도는 caption $C$가 video clip $V$를 묘사하면 큰 값을 갖는다.

HERO

비선형 embedding 함수를 사용한다. $W$는 학습가능한 parameter이고 $\circ$는 내적을 의미한다.

HERO

[W_1^v \in \mathbb{R}^{d \times d_v}, W_1^c \in \mathbb{R}^{d \times d_c}, W_2^v, W_2^c \in \mathbb{R}^{d \times d}, b \in \mathbb{R}^d]

실험에서는 $d$는 모두 4096을 사용하였고 총 parameter 개수는 67M개이다.

위 식의 오른쪽 부분은 선형 FC layer로 거기에 gating function을 더해 출력 범위는 $0\sim1$이 된다. 결과적으로 embedding function은 입력 벡터간 비선형 곱연산 상호작용을 모델링한다.

Loss

max-margin ranking loss를 사용한다. 각 반복 동안 mini-batch $\mathcal{B}$의 caption-clip 쌍 $(V_i, C_i)_{i \in \mathcal{B}}$에 대해서 손실함수는

HERO

이다.

[\mathcal{B}=\lbracei_1, …, i_b \rbrace \subset \lbrace1, …, n \rbrace]

  • $s_{i,j}$는 video clip과 caption 간 유사도 점수이다.
  • $\mathcal{N}_i$는 caption-clip $i$에 대한 negative pair이다.
  • $\delta$는 margin이다. 실험에서는 $\delta=0.1$이다.

Sampling strategy

Negative pair $ \lbrace(V_i, C_i) : i \ne j \rbrace$ 의 절반은 같은 원본 YouTube 영상에서 만들어졌고, 나머지 절반은 서로 다른 영상에서 가져온 것이다. 본 논문에서 intra-negative sampling을 적용하여 학습된 embedding이 주제와 관련 없는 배경보다는 상관이 있는 부분에 중점을 두도록 하였다. 부록 C에서 positive에 대한 설명을 볼 수 있다.
또한 학습 데이터 자체가 일부 noisy하기 때문에 더 이상의 sampling 방식은 성능 개선으로 이어지지 않았다.

Clip and caption representation

clip feature $\mathbf{v}$는 temporally max-pooled pre-extracted CNN feature로 구성된다. caption feature $\mathbf{c}$는 미리 계산된 단어 임베딩 위에 있는 얕은 1D-CNN의 출력값이다. 자세한 내용은 5.1절을 참조한다.


5. 실험(Experiments)

어떻게 강력한 video-text 표현을 학습할 수 있는지 설명한다. CrossTask, YouCook2, MSR-VTT, LSMDC 등에서 실험한 결과를 보고한다.

실험 결과는,

  • CrossTask, YouCook2 등 instructional 영상 데이터셋에서는 HowTo100M에서 학습된 off-the-shelf 임베딩이 매우 작고 수동으로 만든 데이터셋에 비해 훨씬 좋다.
  • 일반적인 YouTube 영상을 모아놓은 MSR-VTT 같은 데이터셋에서, HowTo100M 임베딩은 MSR-VTT에서 학습된 모델과 비등한 성능을 보여준다.
  • MSR-VTT의 일부만 갖고 미세조정한 HowTo100M 모델이 SOTA를 능가한다.
  • LSMDC에서 미세조정한 임베딩은 domain의 큰 차이에도 불구하고 video, script에 대한 일반화 성능이 뛰어나다.
  • HowTo100M의 규모의 중요성을 증명한다.

5.1. Implementation details

Video features

사전학습한 2D/3D CNN에서 frame/video 수준 feature를 추출한다.

  • 2D는 1초당 1 frame 비율로 ImageNet으로 사전학습한 Resnet-152를 사용한다.
  • 3D는 1초당 1.5 feature 비율로 Kinetics로 사전학습한 ResNeXt-101 16frames 모델을 사용한다.

Temporal max-pooling으로 더 긴 video clip에 대한 feature를 aggregate하고 2D와 3D feature를 이어 붙여서 각 clip당 4096차원의 벡터를 최종 생성한다.

Text pre-processing

  • 일반적인 영어 stop-word를 제거한다.
  • GoogleNews의 사전학습된 word2vec을 사용한다.

Training time

  • feature 추출 이후 전체 데이터셋에 대해 임베딩 모델을 학습하는 것은 상대적으로 시간이 적게 걸리며 하나의 Tesla P100 GPU에서 3일이 걸리지 않았다.

5.2. Datasets and evaluation setups

Action step localization

CrossTask는 18개의 task, 수동 생성한 action segment annotation이 있는 2.7k개의 instructional video를 포함한다. 또한 각 task당 짧은 자연어 설명으로 된 action step 순서를 제공한다. HowTo100M에서 학습한 모델을 CrossTask의 video의 모든 frame과 action label의 유사도를 계산하여 step localization을 수행한다.
Cross-task weakly supervised learning from instructional videos에서와 같은 평가 방식을 사용한다.

Text-based video retrieval

자연어 query를 사용하여 video clip retrieval task에서도 실험하였다. Textual description이 주어지면, 수많은 video 중에서 이를 표현하는 video clip을 찾는 문제이다. R@1, R@5, R@10 과 median rank(MR)로 평가기준을 사용하였다.

  • YouCook2: YouTube에서 모은 요리 영상 데이터셋으로 89개의 recipe, 14k개의 clip을 포함하며 모두 수동 생성한 annotation을 포함한다. text set clip이 주어지지 않으므로 3.5k개를 validation set으로 사용한다. HowTo100M에 있는 일부 annotation은 제거하였다.
  • MSR-VTT: 음악, 영화, 스포츠 등 20가지 분류를 묘사하는 257개의 video query에서 모든 일반 영상들로 200k개의 clip 및 수동 생성된 annotation을 포함한다.
  • LSMDC: 101k개의 영화 clip-caption으로 이루어진 데이터셋으로 자막 또는 audio description이 연결되어 있다. 1000개의 쌍을 test set으로 사용했다.

5.3. Study of negative pair sampling strategy

임베딩을 학습할 시 negative caption-video 쌍을 샘플링하는 전략을 실험해 보았다.

HERO

같은 영상에서 negative를 찾는 intra-negative 방식이 좋다는 것을 알 수 있다. 이는 MSR-VTT이나 LSMDC보다 더 fine-grained한 데이터셋인 YouCook2와 CrossTask에서 더 두드러진다.

5.4. Scale matters

실제로 HowTo100M과 같은 대규모 데이터셋이 필요한지를 알아본다. 그래서 데이터셋 중 일부분만 사용하여 사전학습을 시킨 다음 다른 데이터셋에 대해 실험한 결과는 다음과 같다.

HERO

학습에 사용한 영상의 수가 많을수록 성능이 좋기 때문에, 대규모 데이터셋의 필요성이 입증되었다. 그리고 수렴하는 것도 관찰되지 않았기 때문에 더 많은 데이터를 모아 성능을 더욱 향상시킬 가능성도 있다.

5.5. Comparison with state-of-the-art

CrossTask

현재 SOTA인 약한 지도학습 방식의 모델과 비교하여 HowTo100M에서 학습한 off-the-shelf 임베딩을 비교한다. 기존 모델은 step localization에 최적화되었던 것임에도 본 논문의 모델이 한 task를 제외하고 모든 task에서 성능이 더 좋다.

HERO

따라서 대용량의 narrated video로 학습하는 방식이 annotation이 있더라도 소규모의 데이터셋으로 학습하는 것보다 더 낫다고 결론내릴 수 있다.

YouCook2

이후 실험에서는

  1. HowTo100M로만 학습한 모델
  2. MSR-VTT로만 학습한 모델
  3. HowTo100M에서 사전학습하고 MSR-VTT에서 미세조정한 모델

위 3가지를 실험에 사용하였다.

공식 benchmark가 없어서 HGLMN FV CCA embedding 모델을 사용하였다.
결과는 YouCook2에서 직접 학습한 모델보다 더 좋으며 R@10에서 13.7%의 향상이 있기도 했다.

HERO

결론은 CrossTask와 비슷하게 HowTo100M 모델이 specific 모델보다 더 성능이 좋다.

MSR-VTT

HERO
  • instructional 영상 데이터셋과는 달리 MSR-VTT에서 직접 학습한 것이 HowTo100M에서 학습한 모델보다 더 좋다. 이는 일반적인 Youtube 영상이 instructional / VLOG 형식의 영상과는 상당히 다르기 때문으로 추측된다.
  • 사전학습한 데이터의 양에 따른 성능 변화도 측정한 결과는 아래와 같다.
    • SOTA 결과는 MST-VTT의 단 20%만 사용한 것과 비등한 수준이다. 이는 훨씬 더 적은 annotation을 사용해도 괜찮다는 뜻이기도 하다.
HERO

LSMDC

HowTo100M과는 상당히 다른 데이터셋이라 어려운 부분이다. 그렇지만 (논문에 실을 정도니) HowTo100M에서 사전학습 후 LSMDC에서 미세조정하는 모델은 역시 LSMDC에서 직접 학습하는 것보다 더 좋은 결과를 가져다준다.

HERO

5.6. Cross-dataset fine-tuning evaluation

HowTo100M에서 사전학습하는 것과 다른 데이터셋에서 사전학습하는 경우와 비교했다.

HERO

모든 경우 중 HowTo100M에서 사전학습 후 목표 데이터셋에서 미세조정하는 것이 가장 좋다.

5.7. Qualitative results

Video Retrieval의 일부 결과 예시를 가져왔다.

HERO

설명에 부합하는 영상을 잘 찾았음을 확인할 수 있다. 데모는 공식 홈페이지에서 볼 수 있다.


6. 결론(Conclusion)

1.2M개 이상의 narrated video에서 얻은 130M개 이상의 clip을 포함하는 HowTo100M 데이터셋을 제시하였다. 데이터 수집 과정은 자동화된 ASR을 사용하여 빠르고 규모를 키우기 쉬우며 수동으로 만들 필요가 없다. 이를 통해 학습한 모델은 다양한 video 관련 task에서 좋은 결과를 얻었으며 데이터, 모델 및 코드를 공개하였다.


참고문헌(References)

논문 참조!


Comment  Read more