外観検査向け異常検知手法に関する論文紹介: EfficientAD

LeapMindの花元です。
異常検知、してますか？
学習済み深層学習モデルを使って外観検査向け異常検知をしたいけど、良い感じの特徴量が得られなくて困ること、長い人生で、たまにはありますよね。今日はそんなときに使える外観検査向け異常検知の手法である<a href="https://arxiv.org/abs/2111.07677">FastFlow</a>のアルゴリズムを紹介したいと思います。
<h2 id="背景">背景</h2>
<a href="https://techblog.leapmind.io/blog/20220511-hanamoto-survey_on_ad_model/">以前の記事</a>で紹介したとおり、近年、外観検査向け異常検知の手法として、画像の特徴を得るために学習済み深層学習モデルを用いる手法が多く提案されています。これらの手法では、訓練データから学習済み深層学習モデルを用いて特徴量を取得し、推論時に対象となる画像から得られた特徴量が、訓練データにおける特徴量の分布からどの程度離れているかを、何らかの基準に基づいて算出します。例えば、<a href="https://arxiv.org/abs/2011.08785">PaDiM</a>では「何らかの基準」としてマハラノビス距離を用いますが、これは訓練データから得られる特徴量の分布が多変量正規分布に従うことを仮定しています。経験的に、多くのデータセットに対してこの仮定を置いて問題ないことが分かっていますが、訓練データの特徴量の分布が多変量正規分布から大きく外れるようなデータセットの場合、うまく動かない場合があります。
うまく動かない可能性があるデータセットの例として、訓練データに複数種類の画像がある場合が挙げられます。例えば訓練データに「赤りんご」と「洋梨」があり、「和梨」を異常として検知したいケースを考えます。この場合、訓練データに「赤りんご」と「洋梨」の2種類があるため、得られる特徴量の分布に多峰性が生じると考えられます。この場合、マハラノビス距離は訓練データの平均と共分散のみを用いて算出されるため、訓練データにほとんど出現しなかったような特徴量（例えば和梨）であったとしても距離が小さい（＝正常である）と計算されてしまうことがあります（図1）。
<img src="/images/posts/techblog/20230120-introduction_to_fastflow/mahalanobis.png" alt="mahalanobis">
図1: マハラノビス距離を使った異常検知がうまくいく例（左図）とうまくいかない例（右図）。左図では、トレーニング画像にりんごのみを用いているとする。左図のように訓練データから得られた特徴量の分布が正規分布に近い場合、推定された確率密度関数が訓練データの分布に近い形になるため、高い異常検知性能が得られることが期待できる。一方で、右図のように、訓練データから得られた特徴量の分布に多峰性があるなど、正規分布から離れている場合、推定された確率密度関数が訓練データの分布と離れた形になり、高い異常検知性能が得られない場合がある。
<a href="https://arxiv.org/abs/2111.07677">FastFlow</a>では、この問題に対処するために、Normalizing Flowと呼ばれる技術を用いて、訓練時に訓練データから得られた特徴量の分布を、扱いやすい分布（正規分布）に変換できるようなニューラルネットワークを作っていきます。
<h2 id="アルゴリズム">アルゴリズム</h2>
<a href="https://arxiv.org/abs/2111.07677">FastFlow</a>は
<ul>
<li>画像の特徴抽出</li>
<li>2D Flow Model</li>
</ul>
の2点から構成されます。これらを順に説明していきます。
<h3 id="画像の特徴抽出">画像の特徴抽出</h3>
<a href="https://arxiv.org/abs/2111.07677">FastFlow</a>では、他の学習済み深層学習モデルを用いる手法と同様に、様々な種類のバックボーンを特徴抽出器として用いることができます。論文中ではViTやResNetを用いて実験を行っています。
<h3 id="2d-flow-model">2D Flow Model</h3>
2D Flowでは画像を特徴抽出器に入力して得られる特徴量の空間から、その分布が扱いやすくなる分布（FastFlowでは正規分布）へ変換する写像<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>f</mi></mrow><annotation encoding="application/x-tex">f</annotation></semantics></math>を学習します。ここで、画像を特徴抽出器に入力して得られる特徴量の空間<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>X</mi></mrow><annotation encoding="application/x-tex">X</annotation></semantics></math>、変換後の空間を<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>Z</mi></mrow><annotation encoding="application/x-tex">Z</annotation></semantics></math>とすると、これらの確率密度関数には以下の等式が成り立ちます。
<div class="math math-display"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mtable rowspacing="0.16em" columnspacing="1em"><mtr><mtd class="mtr-glue"></mtd><mtd><mstyle scriptlevel="0" displaystyle="true"><mrow><msub><mi>p</mi><mi>X</mi></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><msub><mi>p</mi><mi>Z</mi></msub><mo stretchy="false">(</mo><mi>z</mi><mo stretchy="false">)</mo><mi mathvariant="normal">∣</mi><mi>det</mi><mo>⁡</mo><mo stretchy="false">(</mo><mfrac><mrow><mi mathvariant="normal">∂</mi><mi>z</mi></mrow><mrow><mi mathvariant="normal">∂</mi><mi>x</mi></mrow></mfrac><mo stretchy="false">)</mo><mi mathvariant="normal">∣</mi></mrow></mstyle></mtd><mtd class="mtr-glue"></mtd><mtd class="mml-eqn-num"></mtd></mtr></mtable><annotation encoding="application/x-tex">\begin{equation}
 p_X(x) = p_Z(z)|\det(\frac{\partial z}{\partial x} )|
\end{equation}</annotation></semantics></math></div>
上式の対数は以下の通り計算されます。
<div class="math math-display"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mtable rowspacing="0.16em" columnspacing="1em"><mtr><mtd class="mtr-glue"></mtd><mtd><mstyle scriptlevel="0" displaystyle="true"><mtable rowspacing="0.25em" columnalign="right left" columnspacing="0em"><mtr><mtd><mstyle scriptlevel="0" displaystyle="true"><mrow><mi>log</mi><mo>⁡</mo><msub><mi>p</mi><mi>X</mi></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle></mtd><mtd><mstyle scriptlevel="0" displaystyle="true"><mrow><mrow></mrow><mo>=</mo><mi>log</mi><mo>⁡</mo><msub><mi>p</mi><mi>Z</mi></msub><mo stretchy="false">(</mo><mi>z</mi><mo stretchy="false">)</mo><mo>+</mo><mi>log</mi><mo>⁡</mo><mi mathvariant="normal">∣</mi><mi>det</mi><mo>⁡</mo><mo stretchy="false">(</mo><mfrac><mrow><mi mathvariant="normal">∂</mi><mi>z</mi></mrow><mrow><mi mathvariant="normal">∂</mi><mi>x</mi></mrow></mfrac><mo stretchy="false">)</mo><mi mathvariant="normal">∣</mi></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="true"><mrow></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="true"><mrow></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="true"><mrow></mrow></mstyle></mtd><mtd><mstyle scriptlevel="0" displaystyle="true"><mrow><mrow></mrow><mo>=</mo><mi>log</mi><mo>⁡</mo><msub><mi>p</mi><mi>Z</mi></msub><mo stretchy="false">(</mo><msub><mi>f</mi><mi>θ</mi></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo stretchy="false">)</mo><mo>+</mo><mi>log</mi><mo>⁡</mo><mi mathvariant="normal">∣</mi><mi>det</mi><mo>⁡</mo><mo stretchy="false">(</mo><mfrac><mrow><mi mathvariant="normal">∂</mi><msub><mi>f</mi><mi>θ</mi></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><mrow><mi mathvariant="normal">∂</mi><mi>x</mi></mrow></mfrac><mo stretchy="false">)</mo><mi mathvariant="normal">∣</mi></mrow></mstyle></mtd></mtr></mtable></mstyle></mtd><mtd class="mtr-glue"></mtd><mtd class="mml-eqn-num"></mtd></mtr></mtable><annotation encoding="application/x-tex">\begin{equation}
\begin{split}
\log p_X(x) &#x26;= \log p_Z(z) + \log |\det(\frac{\partial z}{\partial x} )| \\\\\\
&#x26;= \log p_Z(f_\theta(x)) + \log |\det(\frac{\partial f_\theta(x)}{\partial x} )|
\end{split}
\end{equation}</annotation></semantics></math></div>
ここで、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>θ</mi></mrow><annotation encoding="application/x-tex">\theta</annotation></semantics></math>は2D Flow Modelのパラメータとします。学習時には、写像<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>f</mi><mi>θ</mi></msub></mrow><annotation encoding="application/x-tex">f_\theta</annotation></semantics></math>を用いて得られた分布と目標とする分布（FastFlowでは正規分布）の距離（KL Divergence）を最小化するように学習します。この際、写像<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>f</mi><mi>θ</mi></msub></mrow><annotation encoding="application/x-tex">f_\theta</annotation></semantics></math>の<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>θ</mi></mrow><annotation encoding="application/x-tex">\theta</annotation></semantics></math>に関する微分とヤコビアン（<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>det</mi><mo>⁡</mo><mo stretchy="false">(</mo><mfrac><mrow><mi mathvariant="normal">∂</mi><msub><mi>f</mi><mi>θ</mi></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><mrow><mi mathvariant="normal">∂</mi><mi>x</mi></mrow></mfrac><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\det(\frac{\partial f_\theta(x)}{\partial x})</annotation></semantics></math>）を計算する必要が生じます。写像<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>f</mi><mi>θ</mi></msub></mrow><annotation encoding="application/x-tex">f_\theta</annotation></semantics></math>の<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>θ</mi></mrow><annotation encoding="application/x-tex">\theta</annotation></semantics></math>に関する微分は、写像<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>f</mi><mi>θ</mi></msub></mrow><annotation encoding="application/x-tex">f_\theta</annotation></semantics></math>をニューラルネットワークで構築すれば、自動微分により計算することが可能です。一方で、ヤコビアンを愚直に計算しようとすると、行列の大きさを<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mo>×</mo><mi>n</mi></mrow><annotation encoding="application/x-tex">n \times n</annotation></semantics></math>とした際に<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>O</mi><mo stretchy="false">(</mo><msup><mi>n</mi><mn>3</mn></msup><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">O(n^3)</annotation></semantics></math>の計算量を要してしまいます。これは計算効率が悪くなってしまうため、ヤコビアンが自明になるように<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>f</mi><mi>θ</mi></msub></mrow><annotation encoding="application/x-tex">f_\theta</annotation></semantics></math>の構造を設定したものに<a href="https://arxiv.org/pdf/1410.8516.pdf">NICE</a>と呼ばれるネットワークがあり、FastFlowではこのネットワークを2D Flow Modelに採用しています。ネットワークの構造を以下に示します。
<img src="/images/posts/techblog/20230120-introduction_to_fastflow/fastflow.png" alt="2D Flow Model">
図2: 2D Flow Modelの構造（論文より引用）
<h2 id="性能比較">性能比較</h2>
論文中では、MVTec ADを対象とした実験で、バックボーンにWide-ResNet50-2を用いた際の平均AUROCが99.3であり、これまでのSoTAである<a href="https://techblog.leapmind.io/blog/20220701-introduction_to_patchcore/">PatchCore</a>を、バックボーンにWide-ResNet50-2を用いて動作させた際のAUROCの99.1を上回っていると主張されています。<a href="https://github.com/openvinotoolkit/anomalib">ANOMALiB</a>による再実装に基づく実験では、FastFlowの平均AUROCが96.3、PatchCoreの平均AUROCが98.0となっており性能が逆転していますが、SoTAに近い異常検知性能が得られているとは言えそうです。
現在のSoTAとされるPatchCoreと性能の点で大きく異なる点は、トレーニング時間と推論時間です。FastFlowでは、トレーニング時にニューラルネットワークのパラメータを学習させる必要があります。一方で、PatchCoreでは特徴ベクトルを抽出し、貪欲法に基づき特徴ベクトルのサブセットを抽出するだけでトレーニングが終了するため、一般にトレーニング時間はPatchCoreの方が速いと言えます。一方で、推論時においては、FastFlowはニューラルネットワークの計算をすることになるため、実行環境にこの計算を速く行う仕組みがあれば（例えばGPUを搭載している）速く推論することが可能です。一方で、PatchCoreでは推論時に、推論ごとに膨大な特徴ベクトルの中からk個の最近傍を得る必要があり、比較的遅くなります。実際、論文中では、FastFlowは、GPUが搭載されている環境において、特徴抽出後の処理時間が画像1枚あたり100ms程度、PatchCoreより速いと主張されています。従って、トレーニング時間と推論時間のどちらを重視するのか、また、推論する際の実行環境に応じて使い分けるのが良いと考えられます。
<h2 id="まとめ">まとめ</h2>
この記事では、学習済み深層学習モデルを用いた外観検査向け異常検知手法であるFastFlowを紹介しました。この手法では、Normalizing Flowと呼ばれる、解析的に表現することが難しい特徴量の分布を解析的に表現することが容易な分布（FastFlowにおいては正規分布）へと変換するニューラルネットワークを用いることで、正常画像における特徴量の分布が複雑な場合においても異常検知の精度を高めることを図っています。
ところで、LeapMindでは異常検知モデルだったり、異常検知とは全く関係ないモデルだったりを開発する機械学習エンジニアを絶賛募集中です！興味のある方は以下からぜひご応募ください！
<a href="https://leapmind.io/careers/">https://leapmind.io/careers/</a>

外観検査向け異常検知手法に関する論文紹介: FastFlow

<h2 id="概要">概要</h2>
LeapMindの高橋です。現在Efficieraで提供する極小量子化された物体検出(Object Detection)モデルを開発しています。
物体検出モデルはComputer Visionの中でもメジャーな応用で注目度が高い一方、少し調べてみると「アンカーボックス」や「特徴マップピラミッド」など物体検出タスクに特有の概念がいくつも登場するため、とっつきにくい印象を持つかもしれません。
今回取り上げるAnchor Matchingはそんな物体検出モデルに特有な概念の一つで、ここ3年程で研究が特に発展してきたものです。Anchor Matchingについてそれほど日本語の記事はヒットしないのですが、これが分かれば物体検出モデルの全体像も把握しやすいのではないかと思い取り上げます。
<h2 id="物体検出モデルの概略">物体検出モデルの概略</h2>
Anchor Matchingを導入するために、物体検出モデルについて簡単におさらいしましょう。
物体検出タスクは入力画像に含まれる物体の座標(localization)と種類(classification)を同時に推定し、後処理を行い検出結果としてバウンディングボックス:(center_x, center_y, width, height, score, class_id)のリストを出力します。
CNNによる典型的なODモデルのネットワーク構造は以下の3つのサブモジュールから構成されています。
<ol>
<li>Backbone: ResNet50などで入力画像から特徴量を抽出する。</li>
<li>Neck: Backboneから複数スケールの特徴マップを得て変換する。</li>
<li>Head: Neckで得た各特徴マップごとに最終的なバウンディングボックスの出力に合わせて変換する。</li>
</ol>
図示すると次のようになります。
<img src="/images/posts/techblog/20220824-shtakahashi-anchor_matching/fpn.png" alt="FPN">
(図1. 文献2より加工して引用。Feature Pyramid Networks (FPNs)を採用した典型的なODモデルの例。)
図1の左下オレンジに囲われた入力画像から上方向への処理がBackboneに相当します。上に行くことにダウンサンプリングされ空間スケールが粗い特徴量が得られます。次にNeckモジュールでは、Feature Pyramid Networks (FPNs)や類似したNeck構造を採用した場合、Backboneの各空間解像度の特徴量とNeckモジュールから得られた特徴量を組み合わせて、複数スケールからなる特徴マップピラミッドを構成します。最後にHeadモジュールでNeckから得られた特徴マップごとに最終的な出力をします。
Headから得られる最終的なネットワークの出力は、(batch_size, num_predictors, head_dim)となります。
ここでは、1つのバウンディングボックスに対応する出力のことをpredictorと呼び、その数をnum_predictorsとします。また、head_dimはclassificationとlocalizationに必要な情報、つまりCOCO datasetであればクラス数の80次元に加えてboxを表現する4次元が必要になります。
加えて、例えば以下で紹介するYOLOv2/v3の場合には、ネットワークの予測と正解間のIoUを推定するobjectivenessと呼ばれるパラメータが導入されているためhead_dim=85となります。
今回はAnchor Matchingを取り上げるため、以下Anchor-basedのモデルの場合のみを考えます。
Anchor-basedモデルでは各Predictorには対応するanchor boxが事前に定義されています。
図示したものが以下の図2になります。
<img src="/images/posts/techblog/20220824-shtakahashi-anchor_matching/anchor.png" alt="Anchor">
(図2.) 2x2のcell(特徴マップの一領域)に設定されたanchor boxesの例。
図2は簡単のために2x2のcell(特徴マップの一領域)があり、左上のcellに3つの縦長/横長/正方形のanchorを描画しました。実際にはすべてのcellに同様のanchorが設定されています。
実際のモデル、例えば以下のように、512x512の入力画像が与えられたとき、cellの数はP3:12288 P4:3072, P5: 768で合計16128個、それぞれに3つのanchor boxを割り当てるとnum_predictorsは16128*3=48384個になります。
<pre><code class="hljs language-python">image_width, image_height = 512, 512
num_anchors_per_cell = 3
p3_stride, p4_stride, p5_stride = 8, 16, 32
p3_num_predictor =
 (image_width // p3_stride)
 * (image_height // p3_stride)
 * num_anchors_per_cell # 36864
p4_num_predictor = 
 (image_width // p4_stride)
 * (image_height // p4_stride)
 * num_anchors_per_cell # 9216
p5_num_predictor =
 (image_width // p5_stride)
 * (image_height // p5_stride)
 * num_anchors_per_cell # 2304
num_predictors = 
 p3_num_predictor
 + p4_num_predictor
 + p5_num_predictor # 48384
</code></pre>
どの物体とどのpredictorを対応させるかは自明ではありません。この問題をAnchor Matching、あるいはAnchor AssignmentやLabel Assignmentと呼びます。
<h2 id="anchor-matching">Anchor Matching</h2>
Anchor Matchingのアルゴリズムは、与えられたバウンディングボックスのリストをモデルのpredictorに割り当てます。
各predictorは次の3つの状態のいずれかになります。
<ul>
<li>positive: predictorに特定の物体が割り当てられている</li>
<li>negative: predictorにいずれの物体も割り当てられていない</li>
<li>ignore: predictorにいずれの物体も割り当てられないがnegativeとして学習しない</li>
</ul>
では具体的にどのようなアルゴリズムでマッチングを行うかみていきましょう。
<h3 id="yolov2yolov3">YOLOv2/YOLOv3</h3>
YOLOv2/YOLOv3では、それぞれの物体に対して各feature mapごとにpredictorを最も適した1つだけ割り当てます。このアルゴリズムを我々はMax Matching / Max Matcherと呼んでいます。
具体的には次の2つの条件から最適な1つを選びます。
<ol>
<li>cellに対応するピクセルに物体のcx, cyが含まれる</li>
<li>1で該当したcell内のanchorのうち物体とのIoUが最も高い</li>
</ol>
擬似コードに書き直すと次のようになります。
<pre><code>Max Matcherによる単一の物体に対する割り当て
class MaxMatcher(torch.nn.Module):
 def __init__(self):
 super().__init__()
 self.strides = torch.Tensor(
 [8, 16, 32], dtype=torch.long
 )
 self.anchors = torch.Tensor(
 [[4.0, 4.0], [6.0, 3.0], [3.0, 6.0]],
 dtype=torch.float,
 )
 self.num_anchors = 3
 self.image_width, self.image_height = 512, 512

 def forward(self, gt_label):
 positive_predictors = []
 cx, cy, width, height, class_id = gt_label
 for stride in strides:
 cell_in_row = (image_width // stride)
 cell_index_x = cx // stride
 cell_index_y = cy // stride
 cell_index =
 cell_index_x
 + cell_index_y * cell_in_row
 anchor_gt_ious = compute_ious(
 self.anchors, gt_label[:4]
 )
 anchor_index = torch.argmax(anchor_gt_ious)
 predictor_index = 
 cell_index * self.num_anchors + anchor_index
 positive_predictors.append(predictor_index)
 return positive_predictors
</code></pre>
cell_indexが条件1に対応し、 anchor_indexが条件2に対応します。
上の擬似コードでは省かれていますが、もしpositive_predictors以外が推論したバウンディングボックスと物体のIoUが設定した閾値以上だった場合は、そのpredictorはnegativeからignoreに割り当てなおします。
<h4 id="max-matchingの欠点">Max Matchingの欠点</h4>
YOLOv2/YOLOv3は偉大なモデルですが、Anchor Matchingの観点からみるといくつか欠点があります。
<ol>
<li>同じpredictorに複数のgt_boxが該当する場合に、学習時に1つのgt_boxしかないものとして学習される</li>
<li>各特徴マップごとに1つしか、正例/負例の不均衡(Imbalance Problems)が生じ学習が非効率的になる</li>
</ol>
ところで、YOLOv2/YOLOv3でなぜ暗黙のうちにMax Matchingが採用されているかというと、出力のcenter_x, center_yにsigmoid nonlinearityを適用しているため、表現できるboxの中心座標がcellの内部に限られているためです。以下で紹介するRetinaNetにはこのような制約がありません。
<h3 id="retinanet">RetinaNet</h3>
RetinaNetは最も有名な物体検出モデルの一つです。論文の題が"Focal Loss for Dense Object Detection"とあるように、Classification部分にCross Entropy Lossから新規に提案したFocal Lossに変更して、YOLOv3などにあったobjectivenessパラメータを導入せずlocalization+classificationのみのlossで高精度のモデルを学習できることを明らかにしました。Focal Lossの詳細には立ち入りませんが、Cross Entropyと比べて正例/負例の不均衡を損失関数の重み付けを自動的に適切に行うことで、不均衡問題を緩和しています。
Anchor Matching部分はRetinaNet論文の主題ではないのですが、RetinaNetではYOLOv2/v3とは異なりanchor boxと物体間のIoUがそれぞれの閾値を基準にpredictorをpositive/ignore/negativeに割り当てるアルゴリズムを採用しています。閾値に基づいた割り当て方法なので、我々はこれをThresholdMatcherと呼んでいます。
Pythonの疑似コードで書いてみると次のようになります。
<pre><code>Threshold Matcherによる単一の物体に対する割り当て
class ThresholdMatcher(torch.nn.Module):
 def __init__(
 self,
 positive_threshold=0.5,
 negative_threshold=0.4
 ):
 super().__init__()
 self.positive_threshold=0.5
 self.negative_threshold=0.4
 self.strides = torch.Tensor(
 [8, 16, 32], dtype=torch.long
 )
 self.anchors = torch.Tensor(
 [[4.0, 4.0], [6.0, 3.0], [3.0, 6.0]],
 dtype=torch.float
 )
 self.image_width, self.image_height = 512, 512
 self.anchor_boxes = generate_anchor_boxes(
 self.strides,
 self.anchors,
 self.image_width,
 self.image_height
 )

 def forward(self, gt_label):
 anchor_gt_ious = compute_ious(
 self.anchor_boxes, gt_label
 )
 positive_predictors = torch.nonzero(
 anchor_gt_ious >= self.positive_threshold
 )
 negative_predictors = torch.nonzero(
 anchor_gt_ious &#x3C;= self.negative_threshold
 )
 ignore_predictors = torch.nonzero(
 torch.logical_and(
 anchor_gt_ious &#x3C; self.positive_threshold,
 anchor_gt_ious > self.negative_threshold,
 )
 )
 return positive_predictors, negative_predictors, ignore_predictors
</code></pre>
実装は比較的簡単で、predictorのanchorをあらかじめ用意し、それとgtとの間のIoUを計算し条件式で分類します。
論文中ではこの点に対する言及はないのですが、1つの物体に対して各特徴マップごとに1つしか正例がないYOLOv3のMaxMatcherに比べて、正例/負例の不均衡がAnchor Matchingの面からみて緩和されている、という点は指摘できるでしょう。
<h4 id="threshold-matcherの欠点">Threshold Matcherの欠点</h4>
Threshold MatcherはMax Matcherと比較して、1つの物体に複数のpredictorを割り当てるため、不均衡問題は緩和されました。しかし、次の問題を指摘することができます。
<ol>
<li>大きい物体に対してはpositive predictorが多くなるが、小さい物体に対しては少なくなる。</li>
<li>閾値の設定が恣意的で精度への影響が大きい。</li>
</ol>
こうした問題をAnchor Matchingのアルゴリズムから解決したものがこれから紹介するATSSになります。
<h3 id="adaptive-training-sample-selection-atss">Adaptive Training Sample Selection (ATSS)</h3>
RetinaNetが公開されて以降、YOLO系とは異なった1段階モデルが数多く提案されるようになりました。そのうちの一つがFCOS: Fully Convolutional One-Stage Object Detectionというもので、1段階モデルとして既存のモデルから大幅な精度向上を達成しました。
今回取り上げる、Adaptive Training Sample Selection (適応的学習サンプル選択)論文ではRetinaNetとFCOSの精度の差異がどの要素によって生じているか実験から明らかにし、これがAnchor Matchingによって生じていると議論しました。
<blockquote>
After applying those universal improvements, these are only two differences between the anchor-based RetinaNet (#A=1) and the anchor-free FCOS. One is about the classification sub-task in detection, i.e., the way to define positive and negative samples. Another one is about the regression sub-task, i.e., the regression starting from an anchor box or an anchor point.
意訳) これらの普遍的な改善手法を適用した結果、anchor-basedなRetinaNetとanchor-freeなFCOSには2つのみ違いがあります。1つが分類のサブタスクについてで、すなわちpositive sampleとnegative sampleをどのように定義するかです。もう1つが回帰のサブタスクで、回帰をanchor boxから行うかanchor pointから行うかという違いです。
...
According to these experiments conducted in a fair way, we indicate that the essential difference between one-stage anchor-based detectors and center-based anchorfree detectors is actually how to define positive and negative training samples, which is important for current object detection and deserves further study.
意訳) 公正に行われたこれらの実験によれば、1段階anchor-based検出器とcenter-based anchor-free検出器の違いはpositiiveとnegativeな学習サンプルをどのように適用するかで、これは現在の物体検出モデルにとって重要でさらなる研究が求められています。
</blockquote>
論文ではここからアルゴリズムの導入に入ります。ATSSのアルゴリズムは必ずしも直感的に導かれたものではないですが、論文にも書かれている次の5つの条件を満たすという観点から天下り式に設計されたものです。
<ol>
<li>anchor boxとgt boxの中央座標の距離を用いること</li>
<li>anchor-gt間のIoUを用いること</li>
<li>anchorの中央座標が物体の内側に含まれていること</li>
<li>物体の大きさによってpositive predictorの数が大きく影響されないこと</li>
<li>ハイパーパラメタが少ないこと</li>
</ol>
実際のアルゴリズムは擬似コードでは簡潔に書きにくかったので、ここではアルゴリズムの手続きを書きました。
ATSSのアルゴリズム
<ol>
<li><code>すべてのanchor-gt間のIoUを計算する</code></li>
<li><code>1と同様にanchor-gt間の中心座標の距離を計算する</code></li>
<li><code>L個の特徴マップについて、それぞれのgtについて中心座標が最も近いK個のanchor boxを取得する</code></li>
<li><code>3で得たK*L個のanchor boxのIoUを計算し、その平均+標準偏差を閾値とする</code></li>
<li><code>IoUが閾値以上のanchor-gtペアについて、predictorに物体を割り当てる</code></li>
<li><code>5でpositiveに割り当てられたもののうちanchor boxの中央が物体の内側に含まれていないものを省く</code></li>
<li><code>predictorに複数の物体が割り当てられた場合、IoUが最も高い物体を割り当てる。</code></li>
</ol>
登場するハイパーパラメタはKのみで論文中で最適値はK=9とされているもののK>=5であればモデルの精度に与える影響は軽微だと報告されています。
ResNet-101をbackboneとしたモデルでは、RetinaNetにATSSを導入することでMS COCO test-devでAPが39.1->43.6と4.5ptの大幅な上昇を達成したと記述されています。
推論時の計算量を増加させずに学習時のコストのみでこれだけ向上でき、これはモデル開発に大きなインパクトがあります。
<h2 id="終わりに">終わりに</h2>
物体検出は非常にモデル設計の自由度が高いタスクです。Anchor Matchingはそのうちの一要素で、効率的にモデルを学習させるために重要な要素だとの認識が近年高まってきました。
直近ではProbabilistic Anchor Assignment (PAA)、YOLO-Fで導入されたUniform Matching、最適輸送問題として定式化したOptimal Transport Assignment (OTA)などが提案されており刺激的な領域です。また機会があれば、これらを紹介します。
ところでLeapMindでは物体検出モデルを始めとした、Computer Vision分野のモデル開発する機械学習エンジニアを絶賛募集中です！興味のある方は以下からぜひご応募ください！
<a href="https://leapmind.io/careers/">https://leapmind.io/careers/</a>
<h2 id="文献">文献</h2>
<ol>
<li>Qiang Chen, Yingming Wang, Tong Yang, Xiangyu Zhang, Jian Cheng and Jian Sun. You Only Look One-level Feature. CVPR 2021.</li>
<li>Tsung-Yi Lin, Piotr Dollár, Ross Girshick, Kaiming He, Bharath Hariharan, Serge Belongie. Feature Pyramid Networks for Object Detection. CVPR 2017.</li>
<li>Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollár. Focal Loss for Dense Object Detection. ICCV 2017.</li>
<li>Joseph Redmon and Ali Farhadi. YOLO9000: Better, Faster, Stronger. CVPR 2017.</li>
<li>Joseph Redmon and Ali Farhadi. YOLOv3: An Incremental Improvement. arXiv:1804.02767 2018.</li>
<li>Zhi Tian, Chunhua Shen, Hao Chen, and Tong He. FCOS: Fully Convolutional One-Stage Object Detection. ICCV 2019.</li>
<li>Shifeng Zhang, Cheng Chi, Yongqiang Yao, Zhen Lei, and Stan Z. Li. Bridging the Gap Between Anchor-based and Anchor-free Detection via Adaptive Training Sample Selection. CVPR 2020.</li>
</ol>

Object DetectionにおけるAnchor Matchingについて - YOLOv2からATSSまで

LeapMindの花元です。
異常検知、してますか？
学習済み深層学習モデルと近傍法を使って外観検査向け異常検知をしたくなること、長い人生で、たまにはありますよね。今日は外観検査向け異常検知の手法であり、CVPR 2022に採択されている<a href="https://arxiv.org/abs/2106.08265">PatchCore</a>のアルゴリズムを紹介したいと思います。PatchCoreの概要については<a href="../20220511-hanamoto-survey_on_ad_model/">前回の記事</a>を参照してください。
<h1 id="アルゴリズム">アルゴリズム</h1>
PatchCoreは
<ul>
<li>位置情報を保持した画像パッチの特徴抽出 (Locally aware patch features)</li>
<li>貪欲法を用いた、近傍法に用いる画像パッチの特徴数削減 (Coreset-reduced patch-feature memory bank)</li>
<li>近傍法を用いた異常検知 (Anomaly Detection with PatchCore)</li>
</ul>
の3点から構成されます。これらを順に説明していきます。
<h2 id="位置情報を保持した画像パッチの特徴抽出-locally-aware-patch-features">位置情報を保持した画像パッチの特徴抽出 (Locally aware patch features)</h2>
本手法では、まずはじめに、正常画像のみから構成されるトレーニングデータセットから、位置情報を保持した画像パッチの特徴抽出を行います。特徴抽出では、あらかじめImageNetを用いて学習したBackbone (ResNet)に正常画像を入力します。その後、中間層の出力（ResNetを用いる場合、4つあるブロックのうち、2つ目のブロックと3つ目のブロックの出力）を取り出し、Average Poolingを用いて、それぞれの出力の縦横の大きさを揃えます。最後に、それらをチャネル方向に結合することで、1枚の正常画像から、（画像の縦の分割数）×（画像の横の分割数）分の特徴ベクトルを作ります。図1に、画像のパッチに対応する特徴ベクトルのイメージを示しています。
<img src="/images/posts/techblog/20220701-introduction_to_patchcore/overview.png" alt="Overview">
図1: 正常画像からの特徴抽出のイメージ
学習済みモデルを用いて入力画像の特徴を抽出するという手法は、外観検査向け異常検知手法でよく見られる手法ですが、本手法は①位置情報を保持する、②複数のレイヤーの出力を、チャネル方向に連結する、③浅い層と深い層の出力は用いない、の3点において特徴的です。
①位置情報を保持するについて、同じく学習済みモデルを用いた異常検知手法である<a href="https://arxiv.org/abs/2005.02357">SPADE</a>や<a href="https://arxiv.org/abs/2005.14140">MahalanobisAD</a>では、Global Average Poolingを用いて、得られた特徴を1つの特徴ベクトルにします。Global Average Poolingを用いることで、その後の処理で扱わなければならない特徴ベクトルの数を減らし、処理時間を減らせるというメリットがある一方で、局所的な異常（小さな傷など）に関する特徴が潰れてしまう、画像のどこに異常が存在するのかの判定ができなくなる、といったデメリットも発生します。本手法では、Average Poolingを用いる一方で、（画像の縦の分割数）×（画像の横の分割数）分の特徴ベクトルを保持することで、局所的な異常を見つけやすくする、画像のどこに異常が存在するのかを判定できるようにする、ということを図っています。
②複数のレイヤーの出力を、チャネル方向に連結するについて、例えば<a href="https://arxiv.org/abs/2005.14140">MahalanobisAD</a>では、得られた特徴ベクトルをレイヤーごとに分けてその後の処理を行います。これによりその後の計算量が削減される一方で、複数のレイヤーから抽出された特徴同士の関係性を踏まえた異常検知ができなくなるというデメリットも発生します。本手法では得られた特徴をチャネル方向に連結することで、特徴同士の関係性を踏まえた異常検知ができるようにすることを図っています。
③浅い層と深い層の出力は用いないについて、例えば<a href="https://arxiv.org/abs/2005.02357">SPADE</a>では最後の畳み込み層の出力を、<a href="https://arxiv.org/abs/2011.08785">PaDiM</a>では最初から3つの畳み込み層の出力を特徴として用いますが、本手法では浅い層と深い層の出力は用いません。これは、浅い層の出力から得られる特徴は異常検知タスクに用いるには一般的な特徴過ぎる、反対に深い層の出力はImageNetの分類タスクを解くためのbiasがかかりすぎていて異常検知タスクに用いるには不適切であると考えられるからです。
<h2 id="貪欲法を用いた近傍法に用いる画像パッチの特徴数削減-coreset-reduced-patch-feature-memory-bank">貪欲法を用いた、近傍法に用いる画像パッチの特徴数削減 (Coreset-reduced patch-feature memory bank)</h2>
画像から特徴ベクトルを抽出した後は、異常検知手法として一般的な近傍法を適用します。異常検知手法として、他には<a href="https://arxiv.org/abs/2005.14140">MahalanobisAD</a>や<a href="https://arxiv.org/abs/2011.08785">PaDiM</a>で用いられているような、マハラノビス距離と呼ばれる、トレーニングデータセットの平均と共分散を基に算出する距離を用いる手法があります。しかし、これらの手法は得られた特徴ベクトルの分布が多変量正規分布に従うことが仮定されているため、図2のように、特徴ベクトルの分布が多変量正規分布に従わない場合に性能が落ちることがあると考えられます。近傍法は、このような仮定を必要としないため、より幅広い対象に対して手法を適用可能であると考えられます。
<img src="/images/posts/techblog/20220701-introduction_to_patchcore/mahalanobis.png" alt="Mahalanobis">
図2: マハラノビス距離を用いた際に性能が落ちる例。灰色の点がトレーニングデータセットに含まれる特徴ベクトルの分布、青色の点が推論時に得られた特徴ベクトル、星をトレーニングデータセットに含まれる特徴ベクトルの平均とすると、青色の点はトレーニングデータセットに含まれる特徴ベクトルのクラスタから外れているが、全体の平均には近いため、トレーニングデータセットとの距離が近い（＝正常である）と判定されてしまう。近傍法を適用した場合にはこの問題は発生しない。
一方で、単純に近傍法を適用すると、（特徴ベクトルの平均と共分散のみを保持すれば良いマハラノビス距離を用いた手法と異なり）推論時にトレーニングデータセットに含まれる特徴ベクトルを全て保持しなければならず、時間的、空間的な計算量の増加が無視できなくなります。特に、本手法では特徴ベクトルの抽出にあたってGlobal Average Poolingを用いないことで、1枚トレーニングデータを増やすごとに（画像の縦の分割数）×（画像の横の分割数）分という大量の特徴ベクトルが増えてしまうことから、このデメリットがより大きくなります。このままでも近傍法を適用するのが非現実的というわけではありませんが、実用上の速度の問題があるため、得られた特徴ベクトルの集合から、異常検出性能の低減を抑えつつ速度を向上させるような部分集合を得るためのアルゴリズムが提案されています。
ここで、近傍法を適用した際に、特徴ベクトルを"間引いた"後も計算結果に大きな差異が生じないように、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>M</mi></mrow><annotation encoding="application/x-tex">M</annotation></semantics></math>をもとの特徴ベクトルの集合、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>を間引いた特徴ベクトルの集合としたときに、式1により<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>を求めるのが良さそうです（間引かれた特徴ベクトルと残された特徴ベクトルの中の最小距離の最大値ができるだけ小さくなるようにする）。ただし、これを求めるのはNP-Hardであるため、貪欲法により近似解を求める手法が提案されており、また、それがランダムサンプリングのような別の手法と比較して有効であることが実験的に示されています。
<img src="/images/posts/techblog/20220701-introduction_to_patchcore/eq1.png" alt="Eq1"> (1)（論文より引用）
<img src="/images/posts/techblog/20220701-introduction_to_patchcore/algorithm1.png" alt="Algorithm1">
図3: 貪欲法によるアルゴリズムのイメージ。灰色の点が<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>M</mi></mrow><annotation encoding="application/x-tex">M</annotation></semantics></math>に含まれる特徴ベクトル、オレンジ色の点が<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>に含まれる特徴ベクトルを示す。
図3に貪欲法によるアルゴリズムのイメージを示します。アルゴリズムは非常にシンプルです。まず、特徴ベクトルの中の任意の1点を選び、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>に加えます（図2-①）。次に、その特徴ベクトルから最も遠い特徴ベクトルを選び、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>に加えます（図2-②）。その後、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>に含まれる特徴ベクトルとの距離のうち、最も短い距離が最も遠い特徴ベクトルを選び、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>に加えます（図2-③）。最後に、③を<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>に含めたい特徴ベクトルの数を満たすまで繰り返します（図2-④）。
なお、このアルゴリズムを適用するにあたっては、Random Projectionを適用することでチャネル方向の次元数の削減も行っています。
<h2 id="近傍法を用いた異常検知-anomaly-detection-with-patchcore">近傍法を用いた異常検知 (Anomaly Detection with PatchCore)</h2>
上記のプロセスにより、トレーニングが終わり、トレーニングデータセットから得られた特徴ベクトル群の部分集合である<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>が得られます。推論時には、異常/正常を判定したい画像を入力として、トレーニング時と同様に画像パッチの特徴抽出を行います。得られたそれぞれの特徴ベクトルについて、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>に含まれる特徴ベクトルとの距離の最小値を求め、その最大値を異常スコアのベースとします。このスコアを<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi>s</mi><mstyle mathcolor="#cc0000"><mtext>\*</mtext></mstyle></msup></mrow><annotation encoding="application/x-tex">s^\*</annotation></semantics></math>、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi>m</mi><mrow><mi>t</mi><mi>e</mi><mi>s</mi><mi>t</mi><mo separator="true">,</mo><mstyle mathcolor="#cc0000"><mtext>\*</mtext></mstyle></mrow></msup></mrow><annotation encoding="application/x-tex">m^{test, \*}</annotation></semantics></math>を入力画像で最も異常スコアのベースが高かったパッチの特徴ベクトル、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi>m</mi><mstyle mathcolor="#cc0000"><mtext>\*</mtext></mstyle></msup></mrow><annotation encoding="application/x-tex">m^\*</annotation></semantics></math>をそれに対応する<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>に含まれる特徴ベクトルとしたときに、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi>m</mi><mstyle mathcolor="#cc0000"><mtext>\*</mtext></mstyle></msup></mrow><annotation encoding="application/x-tex">m^\*</annotation></semantics></math>の近傍にある<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>M</mi><mi>c</mi></msub></mrow><annotation encoding="application/x-tex">M_c</annotation></semantics></math>の特徴ベクトルを<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi></mrow><annotation encoding="application/x-tex">b</annotation></semantics></math>個抽出し、以下の式により最終的な異常スコアを算出します。直感的には、<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi>m</mi><mstyle mathcolor="#cc0000"><mtext>\*</mtext></mstyle></msup></mrow><annotation encoding="application/x-tex">m^\*</annotation></semantics></math>の近くに他の特徴ベクトルが存在しない場合（＝トレーニングデータセットの中でも珍しい特徴である）に最終的な異常スコアを相対的に大きくする効果があり、論文ではこの計算により異常検出のロバスト性が高まると主張されています。
<img src="/images/posts/techblog/20220701-introduction_to_patchcore/eq2.png" alt="Eq2"> (2)（論文より引用）
<h1 id="まとめ">まとめ</h1>
この記事では、学習済み深層学習モデルを用いた外観検査向け異常検知手法であるPatchCoreを紹介しました。この手法では、位置情報を保持した画像パッチの特徴抽出をする一方で、貪欲法を用いた、近傍法に用いる特徴数の削減を行うことで、異常検知に要する時間の増大を抑えつつ異常検知の精度を高めることを図っています。
ところで、LeapMindでは異常検知モデルだったり、異常検知とは全く関係ないモデルだったりを開発する機械学習エンジニアを絶賛募集中です！興味のある方は以下からぜひご応募ください！
<a href="https://leapmind.io/careers/">https://leapmind.io/careers/</a>

外観検査向け異常検知手法に関する論文紹介: PatchCore

Hi, I'm Joel from LeapMind.
For this blog, I'll write a little about pixel embedding, which enables fast inference of the first layer of a quantized neural network. This has been very useful for me recently. If you work with quantized neural networks, maybe it can be useful for you too.
<h1 id="background">Background</h1>
Neural networks can perform various computer vision tasks, which receive images as input. For example, the noise reduction task. However, neural networks are typically heavy algorithms, which prohibit their use on small devices. Therefore, it is necessary to develop lightweight neural networks.
One way to achieve this is using extreme low bitwidth quantization. For example, 1, 2, or 4 bits are used for weights and activations of the neural network. By repeatedly chaining quantized convolution layers with quantization operators, inference of deep neural networks is greatly accelerated, and can even be run on small devices.
<h1 id="problem-setting">Problem setting</h1>
The quantized chain is cut at the first layer because the inputs are high bitwidth pixel values. Using the quantization operator on inputs doesn’t work well because it is not a featuremap. For example, when the input data is a black and white image, there is only one input channel (a single value per pixel). Quantizing single pixel values causes too much loss of information. Using non-quantized convolution for just the first layer is also not a good solution because it is slow relative to the other layers and will take up a significant fraction of the total inference time.
<h1 id="pixel-embedding-concept">Pixel embedding concept</h1>
How to get a quantized featuremap from a high bitwidth input? The solution is pixel embedding, which was developed by our CTO Tokunaga-san. The inspiration is from word embedding of NLP. The fundamental idea is to use a lookup table that maps from a single high bitwidth pixel value to an array of quantized values, which is applied pixel-wise to the input image, resulting in a quantized featuremap.
<img src="/images/posts/techblog/20220620-joel-pixelembedding/embedding.png" alt="embedding">
Figure 1: Pixel embedding maps the input image pixel-wise to a quantized featuremap, which can be used in quantized convolution. The butterfly photo is the test image “Monarch” from <a href="https://scholar.google.com/citations?view_op=view_citation&#x26;hl=en&#x26;user=nLMQ1AEAAAAJ&#x26;cstart=20&#x26;pagesize=80&#x26;sortby=pubdate&#x26;citation_for_view=nLMQ1AEAAAAJ:L8Ckcad2t8MC">A color preserving image segmentation method</a>.
Using this pixel embedding layer, the pixels of the image can be encoded in low bitwidth, allowing quantized convolution to be used in the first layer.
<h1 id="pixel-embedding-initialization">Pixel embedding initialization</h1>
The pixel embedding can be learned during the neural network training. However, in addition to learning, it is generally understood that having a good initialization of all layers is important for neural networks to get the best results.
<h1 id="thermometer-encoding">Thermometer encoding</h1>
Thermometer encoding has been used in <a href="https://dl.acm.org/doi/10.1145/3431920.3439296">FracBNN</a> and several other works as an effective way of encoding high bitwidth values into a binary array. The main idea is that a larger input value results in a binary array with a larger number of 1's.
This encoding can be imagined like a thermometer, the boundary between 0's and 1's is analogous to the height of the mercury in the tube. Input pixel value is analogous to temperature.
For quantized networks with bitwidths higher than 1, it's also possible to use a kind of thermometer encoding. When increasing the input pixel value, the array first becomes filled up with 1's. Then after that, the array starts to fill with 2's, then 3's and so on.
Using thermometer encoding as the initialization for learned pixel embedding allows us to improve the results of the neural network.
<img src="/images/posts/techblog/20220620-joel-pixelembedding/embedding2.png" alt="embedding2">
Figure 2: An example of pixel embedding using thermometer encoding with greater than 1bit quantization. The red line shows the boundary between values, illustrating the thermometer level. As the input value increases from 25 to 45, the red line moves to the right. As the input value further increases to 80, the red line begins again from the left side, with even higher values.
<h1 id="why-might-this-initialization-work-well">Why might this initialization work well?</h1>
The first thing I notice about the thermometer encoding is that input pixels with similar values result in similar quantized arrays. If the input pixel value is increased slowly, the boundary between ones and zeros in the quantized array will only move across by one element at a time.
This seems reasonable. If we imagine the extreme opposite, where similar input pixel values are mapped to very different quantized arrays, the neural network will have a more difficult task in learning how to process the image. If the input image pixels change by only 1 bit, we expect the neural network output to be very similar, but the embedded featuremap would be totally different!
Lets hypothesise a principle for high quality initialization of the embedding: “similar input pixel values map to similar quantized arrays”. Of course, we also need to avoid degenerate cases such as mapping all possible input pixel values to the same quantized array, because that would eliminate information.
<h1 id="distance-preserving-mappings">Distance preserving mappings</h1>
If we were dealing with only real (floating precision) numbers, the ideal solution of “similar input pixel values map to similar real-valued arrays” is straightforward, so let’s start from there. Within the real numbers, the transforms that adhere to this principle exactly are called isometries, meaning the distances between inputs are equal to the distances between outputs. Further, due to <a href="https://en.wikipedia.org/wiki/Mazur%E2%80%93Ulam_theorem">Mazur-Ulam theorem</a>, to be an isometry, the output array of real numbers would have to be an affine transform of the input pixel value. This theorem holds for quite a general definition of distance.
Let’s think of something similar for an output array of quantized values. Define the embedding like this: first do an affine transform on the input pixel, then apply a quantization operator. The resulting pixel embedding acts as something that roughly follows the principle “similar input pixels map to similar quantized arrays”.
Coming back to thermometer encoding, it can be formulated as a specific case of affine transform + quantizer. So it can be said to roughly follow the principle “similar input pixels map to similar quantized arrays”. Viewing thermometer encoding as an instance of affine transform + quantizer, I think the other important aspect is that the scale of inputs, scale of affine transformation, and scale of quantization operator must be well matched.

Pixel Embedding for Quantized Neural Networks

LeapMindの花元です。
異常検知、してますか？
学習済み深層学習モデルを使って外観検査向け異常検知をしたくなること、長い人生で、たまにはありますよね。今日はそんなときに使える手法を紹介したいと思います。
<h1 id="はじめに">はじめに</h1>
異常検知とは、データの中から、通常のデータとは振る舞いの異なるデータ（異常なデータ）を検出するタスクを指します。例えば、画像を入力とした異常検知では、製品の画像から、傷が付いていたり、必要な部品が欠けていたりする画像を検出することを目指します。一般に、異常検知モデルの訓練時には、異常なデータが全くないか、あったとしてもごく少数であることが仮定されます。これは、異常なデータ（例えば傷が付いている製品の画像）は通常とても得られにくいことに起因しています。今回紹介する手法は全て、訓練時に異常なデータは不要です。
近年、外観検査向け異常検知の手法として、画像の特徴を得るために学習済み深層学習モデルを用いる手法が多く提案されています。このアプローチの利点としては、①異常画像がなく、正常画像も数十枚〜数百枚しかない場合においても、異常検知モデルの学習が可能、②深層学習モデルを1から学習させる手法と比較して、短時間（例えば数十秒）で学習が可能、という点があります。今回は、このアプローチを採用している手法をいくつか紹介したいと思います。
<h1 id="学習済みモデルから得られた特徴量の復元誤差を求める手法">学習済みモデルから得られた特徴量の復元誤差を求める手法</h1>
このアプローチでは、学習済みモデルから得られた訓練画像（正常データのみで構成される）の特徴量を、何らかの手段で圧縮/復元するモデルを構築します。この圧縮/復元するモデルは、訓練画像に似たデータ（＝正常画像から得られた特徴）に対しては精度高く圧縮/復元できる傾向がある一方で、訓練画像から大きく異なるデータ（＝異常画像から得られた特徴）に対しては精度高く圧縮/復元できず、復元誤差が大きくなる傾向があります。このアプローチでは、この特性を異常検知に用います。
例えば、LeapMindが開発した<a href="https://arxiv.org/abs/2104.04289">MLF-SC</a>では、画像をパッチに分割し、学習済みのVGG16を用いて特徴を抽出した上で、スパースコーディングと呼ばれる手法を用いて特徴を圧縮/復元します（図1）。復元した結果、もとの特徴との差分が基準値より大きいものを異常とみなします。また、VGG16から特徴を抽出する際は、最終層の出力のみを用いるのではなく、中間層の出力も用いることで、局所的な異常（小さな傷など）と大域的な異常（広範囲に渡るシミなど）の両方を検出することを目指しています。結果として、MVTec ADデータセットのテクスチャ（カーペットなど、物体の表面を撮影したもの）カテゴリの平均AUROCで97を達成しています。
<img src="/images/posts/techblog/20220511-hanamoto-survey_on_ad_model/mlf-sc.png" alt="MLF-SC">
図1: MLF-SCの概略図（論文より引用）。VGG16の中間層の出力もスパースコーディングの入力として用いられる。
<h1 id="学習済みモデルから得られた特徴量を用いて近傍法を適用する手法">学習済みモデルから得られた特徴量を用いて近傍法を適用する手法</h1>
近傍法とは、正常データはその近傍に訓練データに含まれるデータ点が多くあり、逆に、異常データの近傍には訓練データに含まれるデータ点がないという仮定に基づき、近傍点との距離を基に異常を判定する手法です。例えば、最近傍法では、訓練データに含まれるデータ点の中から最も距離が短いデータとの距離が基準値より大きなデータを異常とみなします。
例えば、<a href="https://arxiv.org/abs/2005.02357v3">SPADE</a>では、ResNetの最終畳み込み層から得られた特徴量をGlobal Average Poolingし、訓練データに含まれるデータ点の中から最も距離の短いデータをk点抽出します。その結果、その距離の平均が基準値より大きなデータを異常とみなします。
<a href="https://arxiv.org/abs/2106.08265">PatchCore</a>では、①画像全体でなく、画像のパッチごとに特徴を抽出する、②最終層だけでなく、中間層の出力も特徴量として用いて近傍法を適用することでさらなる異常検知性能の向上を図っています（図2）。ここで、単純にこれらの方策を適用してしまうとデータ量が多くなり速度が遅くなることから、距離を計算する対象となる正常データの特徴量の数を貪欲法により大幅に削減する手法を提案しています。また、特徴量の次元もランダムプロジェクションと呼ばれる手法を用いて削減しています。なお、PatchCoreのアルゴリズムの詳細については<a href="../20220701-introduction_to_patchcore/">こちらの記事</a>で紹介しています。
<img src="/images/posts/techblog/20220511-hanamoto-survey_on_ad_model/patchcore.png" alt="PatchCore">
図2: PatchCoreの概略図（論文より引用）。訓練時には正常データからパッチごとに特徴を抽出し、貪欲法で少数の特徴をサブサンプリングする。推論時には対象から特徴を抽出し、近傍法で異常判定に用いるスコアを算出する。
MVTec ADデータセットを用いたベンチマークでは、平均AUROCでSPADEが85.5、PatchCoreが99.1を達成しています。
<h1 id="学習済みモデルから得られた特徴量を用いてマハラノビス距離を求める手法">学習済みモデルから得られた特徴量を用いてマハラノビス距離を求める手法</h1>
マハラノビス距離とは、変数間の相関関係を考慮した距離の一種です。我々が通常「距離」と呼ぶユークリッド距離とは異なり、マハラノビス距離ではばらつきが大きな方向の距離を相対的に小さく評価し、反対にばらつきが小さな方向の距離を相対的に大きく評価します。学習済みモデルから得られた特徴量を用いてマハラノビス距離を求める手法では、訓練データを入力として、学習済みモデルから得られた特徴量とのマハラノビス距離を求め、その距離が基準値より大きいものを異常とみなします。
<a href="https://arxiv.org/abs/2005.14140">Modeling the Distribution of Normal Data in Pre-Trained Deep Features for Anomaly Detection</a>では、EfficientNetの各層の出力をGlobal Average Poolingしたものについて、層別にマハラノビス距離を計算し、その合計値が基準を超えるデータを異常とみなすアルゴリズムを提案しています（図3）。
<img src="/images/posts/techblog/20220511-hanamoto-survey_on_ad_model/mahaad.png" alt="Mahalanobis AD">
図3: Modeling the Distribution of Normal Data in Pre-Trained Deep Features for Anomaly Detectionの概略図（論文より引用）。各層の出力それぞれでマハラノビス距離を求め、その合計を用いて異常判定を行う。
<a href="https://arxiv.org/abs/2011.08785">PaDiM</a>では、①画像全体でなく、画像のパッチごとに特徴を抽出する、②層別にマハラノビス距離を計算するのではなく、各層から出力した特徴を結合してマハラノビス距離を計算する、というアルゴリズムを採用することでさらなる異常検知精度の向上を図っています（図4）。また、各層から出力した特徴を結合してマハラノビス距離を計算すると次元が大きくなる分計算量が大きくなりますが、ランダムに次元を削減して計算量を大きく削減しても異常検知性能を維持できることが示されています。
<img src="/images/posts/techblog/20220511-hanamoto-survey_on_ad_model/padim.png" alt="PaDiM">
図4: PaDiMの概略図（論文より引用）。各層から得られた特徴量をパッチに分割し、結合した上でマハラノビス距離を求める。
MVTec ADデータセットを用いたベンチマークでは、平均AUROCでModeling the Distribution of Normal Data in Pre-Trained Deep Features for Anomaly Detectionが95.8、PaDiMが97.9を達成しています。
<h1 id="まとめ">まとめ</h1>
この記事では、学習済み深層学習モデルを用いた外観検査向け異常検知手法を紹介しました。このアプローチを適用することで、訓練データとして異常画像が使えない場合でも、短時間で異常検知モデルを構築することが可能になります。
ところで、LeapMindでは異常検知モデルだったり、異常検知とは全く関係ないモデルだったりを開発する機械学習エンジニアを絶賛募集中です！興味のある方は以下からぜひご応募ください！
<a href="https://leapmind.io/careers/">https://leapmind.io/careers/</a>

学習済み深層学習モデルを用いた外観検査向け異常検知手法についてのサーベイ

Hello, this is Patrick. I am an engineering manager at Leapmind.
Recently, in our hackdays in January 2022, I thought up some fun ideas to experiment. This was done over 2-3 days. (About our past hackdays activity, please see <a href="https://leapmind.io/blog/2019/04/15/hackdays-2019-2q/">this article</a>)
<h1 id="the-idea">The Idea</h1>
Most people are afraid of speaking foreign languages (eg. English). From what I understand, they lack the confidence and are afraid of making grammatical mistakes, or thinking that they have a funny accent.
But what if we can "simulate" what we would have sounded like, if we have perfect English capability? One solution is using voice cloning.
<h1 id="the-method">The Method</h1>
Recently, an impressive advance in voice cloning domain has been made -- it is called <a href="https://coqui.ai/blog/tts/yourtts-zero-shot-text-synthesis-low-resource-languages">YourTTS</a>. This model enables us to easily embed a new speaker's voice without training and with minimal data required. An example colab code is <a href="https://colab.research.google.com/drive/1ftI0x16iqKgiQFgTjTDgRpOM1wC1U-yS?usp=sharing">here</a>.
Figure: TTS model architecture (source from coqui.ai)
<img src="https://coqui.ai/static/aeec1cf73c251540bf76af923d1737af/39a40/blog-tts-yourtts-zero-shot-text-synthesis-low-resource-languages-inference.png" alt="TTS model architecture">
<h1 id="the-data">The Data</h1>
One of the challenges with most machine learning projects is how to find relevant, high quality data. In this case, I asked a few leapmind employees' (including our CEO!) permission to use their voice sample as input data. Fortunately, we have a few video recordings of our internal presentations. These are mostly 05-30 min uninterrupted speeches of each presenter, which I can extract with the following steps below.
Additionally, for the text-to-speech part to work, a short speech (say -- a few sentences) should be prepared. Note that for custom names (company products, human names), the normal wording might fail so we have to "craft" a natural-sounding text with trial and error.
<ol>
<li>find source reference data from old company presentation videos</li>
<li>download as mp3/wav, then put into <a href="https://www.audacityteam.org/">Audacity</a> (audio editor)</li>
<li>clean out other noises (other people’s voice, coughing, etc.)</li>
<li>export as wav file</li>
<li>normalize and sample with <a href="https://ffmpeg.org/">ffmpeg</a></li>
<li>prepare “English text” file for AI to read</li>
<li>run the prepared input data through YourTTS model to generate output .wav file.</li>
</ol>
<h1 id="the-result">The Result</h1>
I found that at the minimum, a 5-min sample speech can enable the TTS model to somewhat mimic the speaker's voice. However, to product high-quality output, a more varied and high-quality sample speech data is needed (more varied topics, vocabularies, and quiet background noises). Additionally, certain speakers can have a more pronouced speaking personality and tone that is more easily emulated.
Here is one example of the output... the speaker is our CEO!
<ul>
<li><a href="/images/posts/techblog/20220301-voice-cloning-hackdays-2022q1/matsuda-san_input_excerpt.mp3">input speaker data (excerpt) mp3</a></li>
<li><a href="/images/posts/techblog/20220301-voice-cloning-hackdays-2022q1/matsuda-san_output.mp3">output TTS result mp3</a></li>
</ul>
English text used:
<pre><code>Since its inception in 2012, LeapMind has engaged in 
research and development of software frameworks, algorithms, and hardware, 
with a focus on embedded technologies, to solve business problems 
with leading-edge machine learning technologies.
</code></pre>
<h1 id="conclusion">Conclusion</h1>
Since this is "a little fun mini-project" that took little time, I didn't expect the result to be good. However, the quality does surprise me since I only prepared minimum amount of data (less than 25 min speech) where usually a much larger set is required for speech projects.
Finally, I want to thank my colleagues who allow me to use their voice data for this experiment and the open-source community for allowing people like me to try out and tinker with the latest technologies.

Voice Cloning experiment at Leapmind Hackdays (2022Q1)

Infrastructure Divisionの<a href="https://github.com/tfujiwar">藤原</a>です。普段は社内の継続的インテグレーション(CI)環境の構築や、ビルドツール(Bazel)の整備などを担当しています。
今回はLeapMindのCI環境のオートスケーリングの仕組みを紹介します。低コストで並列度の高いCI環境を実現したい方、Kubernetes(k8s)を活用したCI環境に興味がある方にとって、何かの参考になれば幸いです。
<h1 id="buildkiteによるci">BuildkiteによるCI</h1>
LeapMindでは<a href="https://buildkite.com/">Buildkite</a>というCIサービスを<a href="https://techblog.leapmind.io/blog/leapmind-ci-introduction/">利用しています</a>。一般的なCIサービスでは、ジョブの実行環境はサービス側で用意されていて、料金プランによってスペックや並列数を選択できる、というものが多いです。またJenkinsのような完全セルフホスト型のCIツールでは、WebUIやAPIのホスティングと、ジョブの実行環境の用意の両方を自分で行う必要があります。
Buildkiteは半セルフホスト型のCIサービスで、これらの中間的なCIサービスであるといえます。WebUIやAPIのホスティングはサービス側に任せて楽をしつつ、実行環境を自由に選択できるという利点があります。任意のクラウドサービス(またはオンプレミス)環境で、任意のスペック・台数の実行環境を、コストと相談しつつ選択することができます。
<img src="/images/posts/techblog/20220209-fujiwara-autoscaling-ci/how-buildkite-works.png" alt="Buildkiteの仕組み">
さて、一般にCI環境の負荷は曜日や時間帯によって大きく変動します。GitHubへのソースコードのプッシュをトリガとしてCIを実行する構成の場合、勤務時間帯には多くのジョブがリクエストされますが、夜間や休日はほとんどリクエストされません。参考までに、ある1週間(月~日曜日)にCIがトリガされた回数をグラフにしてみました(夜間帯や休日中の実行は、事前にスケジュールされた定期実行を含みます)。
<img src="/images/posts/techblog/20220209-fujiwara-autoscaling-ci/number-of-ci-jobs.png" alt="ある1週間のCIジョブ数の推移">
Buildkiteではこのような負荷の増減に対して、エージェントの数を増減させることによって対応できます。
<h1 id="オートスケーリングの仕組み">オートスケーリングの仕組み</h1>
Buildkiteエージェントの実体は、ジョブの割り当てを待機するデーモンプロセスです。そのコンテナイメージはBuildkiteが公式に用意しているので、それをベースに必要なツールをインストールしたイメージを作成しておきます。
コンテナ化されたアプリケーションをオートスケールするためには、k8sや各クラウドサービスのコンテナオーケストレーション機能を活用するのが良いでしょう。LeapMindではGoogle Cloud Platform(GCP)のGoogle Kubernetes Engine(GKE)を利用しています。
GKEにはクラスタオートスケーリング機能があるので、ノード(クラスタを構成するインスタンス)のオートスケーリングはこれに任せることができます。以下では、クラスタ上に起動するエージェントプロセス数のオートスケーリングの方法を考えます。
<img src="/images/posts/techblog/20220209-fujiwara-autoscaling-ci/autoscaling-on-k8s.png" alt="Kubernetesクラスタ上でエージェントをオートスケールする">
<h2 id="k8sのhorizontalpodautoscalerを使う案不採用">k8sのHorizontalPodAutoscalerを使う案(不採用)</h2>
k8sにはHorizontalPodAutoscaler(HPA)というオートスケーリングの機能があります。DeploymentやStatefulSetなどの複数のPodを生成するリソースと併せて使用し、PodのCPU使用率をもとにレプリカ数を自動的に調節してくれるものです。
BuildkiteエージェントのCPU使用率は、待機中はほぼ0%、ジョブ実行中はある程度大きな値になると予想できます。エージェントをk8sのDeploymentとしてデプロイし、HPAでCPU使用率の目標値を適切に設定しておくことで、うまくスケーリングしてくれそうです。
実際LeapMindでもこの方法を試していました。スケールアウトの挙動は想定通りだったのですが、スケールインの挙動に問題がありました(v1.19時点)。Deploymentのレプリカ数が下げられると、停止するPodはCPU使用率に関係なく無作為に選択されます。したがってジョブが実行中であろうと、エージェントが停止されてしまうのです。ジョブの中断・再実行が頻発してしまったため、この方法は断念しました。
<h2 id="待機中のジョブ数に応じてスケーリングする案採用">待機中のジョブ数に応じてスケーリングする案(採用)</h2>
CPU使用率のような間接的なメトリクスを使わずに、待機中のジョブ数に応じてエージェントを起動する方法を考えます。この方法では、BuildkiteのWebAPIを利用して待機中のジョブ数を取得し、必要な数のエージェントを起動する、自前のアプリケーション(下図のAgentScaler)を実装します。
<img src="/images/posts/techblog/20220209-fujiwara-autoscaling-ci/how-agent-scaler-works.png" alt="AgentScalerの仕組み">
Buildkiteエージェントはデーモンとして常時起動しておくのが通常の使い方ですが、起動時に<code>disconnect-after-job</code>オプションを指定することで、ジョブ終了後、次のジョブを待たずに安全に終了させることができます(この場合、エージェントプロセスはDeploymentではなくk8sのJobリソースとして起動することになります)。こうすることで、HPAのスケールイン時のようにジョブが中断される問題を回避できました。
ある時間帯のエージェント数の推移をグラフにしました。リクエスト数に追随してエージェント数が調節されていることが確認できます。めでたしめでたし。
<img src="/images/posts/techblog/20220209-fujiwara-autoscaling-ci/number-of-agents.png" alt="エージェント数の推移">
<h1 id="実行環境のコスト">実行環境のコスト</h1>
一般的なクラウドサービスのインスタンスは、延べ実行時間に対して課金されます。オートスケーリングの導入によって、必要なときに必要なだけインスタンスを起動できるようになったため、無駄なコストを削減することができました。
また並列数をN倍にして実行時間が1/Nになれば、同一ジョブを実行するコストは並列数に依存しません。もちろん実際にはスケーリングのタイムラグがあったり、インスタンス以外のコストが増加したりと、厳密にコスト据え置きとはなりません。しかしCI結果が早く得られるようになることで、コスト増加に見合う開発効率の向上が期待できると思います。
クラウドサービスベンダによっては、余剰の計算リソースを安価なインスタンスとして提供していることがあります。GCPであればSpotVMがそれに該当します。たとえばn2-standard-2マシンタイプ(us-west1)であれば、通常\<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0.097</mn><mi mathvariant="normal">/</mi><mi>h</mi><mi>o</mi><mi>u</mi><mi>r</mi><mtext>のところ、</mtext><mi>S</mi><mi>p</mi><mi>o</mi><mi>t</mi><mi>V</mi><mi>M</mi><mtext>であれば</mtext><mspace linebreak="newline"></mspace></mrow><annotation encoding="application/x-tex">0.097/hourのところ、SpotVMであれば\\</annotation></semantics></math>0.024/hourと、約1/4のコストで利用できます。このような安価なインスタンスを活用することで、さらにコストを削減することができます。
<h1 id="まとめ">まとめ</h1>
拡張性の高いCIサービスBuildkiteと、k8sクラスタを利用したオートスケーリングの仕組みにより、低コストな高並列CI環境を実現した例を紹介しました。
LeapMindにはCIシステムを構築するエンジニア以外にも、機械学習やハードウェア開発を専門とするエンジニアが多数在籍しています。興味を持った方はぜひ一度<a href="https://leapmind.io/careers/">採用ページ</a>をご覧ください。

BuildkiteによるオートスケーリングCI環境

<a href="https://arxiv.org/abs/2003.08934">NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis</a>は2020年を代表する深層学習関連の論文の一本であることは間違いないでしょう。もう2022年も2月に差し掛かっていますが、いまさらながら、NeRFの論文を読んだので、初見の際にわかりづらかったところを解説してみます。
<h1 id="nerfでできること">NeRFでできること</h1>
NeRFは、100枚程度の画像データから、そのシーンの三次元形状を復元し、新しい視点からの画像を生成します。以下の動画を再生していただければわかるように、かなり自然な新視点画像生成が行えます。学習に使うのは画像だけなので、写真を撮るだけで現実のシーンにも適用できます。

<iframe width="560" height="315" src="https://www.youtube.com/embed/JuH79E8rdKc" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
NeRFには以下のような制約があります。
<ul>
<li>シーンは静的でなければならない</li>
<li>何らかの手法を使って各画像の外部カメラパラメーターを求めておかなければならない</li>
<li>複数のシーンを同じネットワークに学習させることはできない</li>
</ul>
これらの制約は、原理的なものではありません。例えば、外部カメラパラメーターを推定しながら学習を進める、みたいな後続研究もあります。
学習時にシーンの三次元形状を復元しているので、（学習に時間がかかるという問題はありますが）、単なる新視点画像生成だけでなく、対象となるオブジェクトの三次元形状をコンピューター上に再現することもできます。応用範囲が広そうな技術ですね。
<h1 id="nerfにおける問題の定式化">NeRFにおける問題の定式化</h1>
シーンを三次元オブジェクトと読み替えたほうがわかりやすい気がするので、以下では一旦、そのように読み替えてみます。
多くの3Dゲームでは、三次元オブジェクトは複数のポリゴンと、その上に貼られたテクスチャとして表現されます。しかし、三次元オブジェクトの表現方法はポリゴンだけではありませんよね。NeRFでは、三次元オブジェクトをニューラルネットワークのモデルパラメーター（本記事ではニューラルネットワークの学習対象となるパラメーターをモデルパラメーターと表現して、ニューラルネットワークへの入力パラメーターと区別することにします）として表現します。
<h2 id="座標が入力である">座標が入力である</h2>
ここが一番のつまづきポイントだと思われますので、もう少し具体的な話に触れましょう。3次元空間上における関心座標を<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo separator="true">,</mo><mi>y</mi><mo separator="true">,</mo><mi>z</mi></mrow><annotation encoding="application/x-tex">x,y,z</annotation></semantics></math>とし、その座標におけるカメラ方向を<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>θ</mi><mo separator="true">,</mo><mi>ϕ</mi></mrow><annotation encoding="application/x-tex">\theta, \phi</annotation></semantics></math>と書くことにします。これらのパラメーターはすべて実数です。この5次元ベクトルを入力とし、密度と色の4次元を出力するMLP（Multi Layer Perceptron）を学習する、というのがNeRFにおける基本コンセプトです。
つまり、ある座標の色が知りたいなーと思ったら、学習後のNeRFのモデルに座標（とカメラ方向）を入力すると、色（と密度）が返ってきます。
これは、2回書きたくなるくらい大事なところです。
<h2 id="ボリュームレンダリングによる画像化">ボリュームレンダリングによる画像化</h2>
NeRFでは、ある座標が物体表面なのかどうかはわかりません。代わりに、その座標での物体の密度を返します。原論文の表現（volume density）に倣って密度と表記はしますが、単位面積当たりの質量のことではなく、不透明度と考えたほうが、わかりやすいかもしれません。返ってきた色と密度の情報を使ってボリュームレンダリングを行い、画像を生成します。
ボリュームレンダリングは論文中では積分を用いたちょっとごちゃごちゃした式で表現されていますが、実装上は、カメラから対象空間に飛ばした線分に沿って、各座標での色を、密度に応じて足し合わせていきます。その際、各座標までの不透明度の和によって重み付けを行います。具体的には、各座標とカメラを結ぶ線分の間に、密度が大きな点が存在すると、その後ろの座標のレンダリング結果に対する寄与率が減衰されます。例えば、線分上に密度が大きな点が2つ存在した場合、カメラに近い方の点の色が大きな寄与率を持ちますが、カメラから遠い方の点の色も、レンダリング結果に多少は寄与することになります。
レンダリングを微分可能な操作だけで行うために、あえてこのような手法が取られています。
<h2 id="なぜボリュームレンダリングが必要になるのか">なぜボリュームレンダリングが必要になるのか</h2>
ボリュームレンダリングが必要になる理由は、NeRFの問題設定と関係しています。NeRFでは学習データは画像なので、座標を入力してその座標の色を返すようなニューラルネットワークを、直接は学習できません。そこで、ボリュームレンダリングを使って三次元オブジェクトを画像としてレンダリングし、得られた画像と、学習データ中の画像とを比較して損失関数を計算します。上述の通り、このボリュームレンダリングの操作は微分可能ですので、論文中ではニューラルレンダリングとも呼ばれています。
NeRFを学習して得られたニューラルネットワークのモデルパラメーターの中には、対象となる三次元オブジェクトの情報が入っているし、取り出すことができます。学習に使うデータは画像だけで、三次元オブジェクトの情報は直接は与えていませんので、NeRFの学習を進めるうちにニューラルネットワーク自体が三次元オブジェクトの形状の情報を自然に復元した、ということになります。定式化としては納得できるのですが、これが実際に学習できるとは、ニューラルネットワークはすごいなぁ、と小学生みたいな感想を述べたくなります。
<h1 id="その他の工夫">その他の工夫</h1>
疲れてきたのでアイデアだけ雑に紹介しておきます。
<ul>
<li>Positional Encoding: 入力座標の情報を高次元に散らばらせる。これがないと高周波情報をなかなか学習してくれないそうです。</li>
<li>階層的ボリュームサンプリング: 品質を保ったまま計算量を削減するために、Coarse NetworkとFine Networkの2種類を使います。Coarse Networkを使って、重点的に光線をサンプリングする領域を選択します。</li>
</ul>
<h1 id="感想">感想</h1>
一旦問題設定を理解してしまうと、とても自然に見えてきて、私も、段々と、なにがわからなかったのかがよくわからなくなってきてしまっていますが、初見の際には
<ol>
<li>DNNへの入力は画像ではなく三次元座標である</li>
<li>シーン情報を学習し、DNNのパラメーターに埋め込む</li>
</ol>
の2つの部分が理解が難しかったように記憶しています。
これらのアイデアは、他にも色々と面白い応用が考えられそうな気がします。例えば、<a href="https://arxiv.org/abs/2109.14406">[2109.14406] Neural Knitworks: Patched Neural Implicit Representation Networks</a> は、二次元画像のblind super resolution、denoising等にこれらのアイデアを応用し、denoisingにおいてdeep image priorをおおむね上回る性能を達成したと報告しています。（ノイズレベルが低い場合はdeep image priorの方が良い結果であったようです。）
<h1 id="self-q-and-a">Self Q and A</h1>
<blockquote>
Q: 陰関数とNeRFにはどう関係があるの？
</blockquote>
A: DNNへの入力を座標にするというアイデアは陰関数表現から来ていそうだけれども、その程度の薄い関係しかなさそうです。陰関数のことは一旦忘れましょう。
<blockquote>
Q: 入力が三次元空間の座標になるということは、一度に一つのシーンしか学習させられないの？
</blockquote>
A: そうです。別のシーンを表現したい場合はゼロから学習させ直しです。いくつか改善の方向性が考えられると思いますが、個人的には、学習を高速化するためにパラメーター初期化に工夫を行う手法が興味深いです: <a href="https://openaccess.thecvf.com/content/CVPR2021/papers/Tancik_Learned_Initializations_for_Optimizing_Coordinate-Based_Neural_Representations_CVPR_2021_paper.pdf">Learned Initializations for Optimizing Coordinate-Based Neural Representations</a>
<h1 id="further-readings">Further Readings</h1>
<a href="https://video-nerf.github.io/">動画への応用</a>、<a href="https://nerf-w.github.io/">撮影条件が異なる様々な画像を用いたreconstruction</a>など、様々な後続研究が出てきています。興味が湧いた人は後続研究も調べてみてください。
<ul>
<li><a href="https://arxiv.org/abs/2111.11426">[2111.11426] Neural Fields in Visual Computing and Beyond</a> 入力が座標で出力がベクトルであるようなニューラルネットワークをニューラル場と呼ぶことを提唱しているサーベイ論文です。著者の一人による日本語での解説 <a href="https://yongyuanxi.medium.com/%E3%83%8B%E3%83%A5%E3%83%BC%E3%83%A9%E3%83%AB%E5%A0%B4%E3%81%A3%E3%81%A6%EF%BD%8E-59ba56b14854">ニューラル場ってなに？ - Towaki Takikawa - Medium</a> はNeRFを理解するにあたって助けになりました。</li>
<li><a href="https://xpaperchallenge.org/cv/survey/cvpr2021_summaries/tag/3d-reconstruction/">CVPR2021論文サマリ tag: 3d-reconstruction</a> 数が多すぎて全然読めてませんが、大半の論文はNeRFを参照していそうです。英語の論文の海に飛び込む前に準備運動をさせてもらうのによいでしょう。</li>
</ul>
<h1 id="さいごに">さいごに</h1>
LeapMindでは、NeRFに興味がある方もそうでない方も、様々な職種で採用活動を実施しております。特に機械学習、深層学習が得意なエンジニアを強く募集しておりますので、興味がある方はぜひ一度<a href="https://leapmind.io/careers/">LeapMindの採用ページから応募</a>してみてください。いきなり採用面接は怖い、という人はカジュアル面談から始めることもできます（もちろん、カジュアル面談の後に、実際に選考プロセスを進めない、という選択も可能です。そのためのカジュアル面談ですので。）

Tech Blog