543-pdf

GPGPUによる高速画像処理 

~リアルタイム画像処理への挑戦~ 

名古屋大学大学院情報科学研究科 

出口大輔

リアルタイム画像処理 

2

発表の流れ 

GPGPUを始める前に 

GPGPUの基礎知識 

CUDAの使い方 

CUDAを使う前に 

プログラミングの予備知識 

CUDAを使って“Hello World” 

GPGPUにチャレンジ 

行列積の計算 

テンプレートマッチング 

ガウシアンフィルタ 

SIFT特徴量の計算 

3

~GPGPUって何?~ 

4

GPGPUって? 

GPGPUは何の略? 

General-Purpose computation on GPUs 

GPUを汎用計算に利用しようという試み 

現在は「GPUコンピューティング」とも呼ばれる 

どうしてGPGPUが注目されているのか? 

5

ピ 

ー 

ク 

性 

能 

CPUとGPUの性能比較 

1600 

1400 

1200 

1000 

800 

600 

400 

200 

[GFLOP/s] 

Geforece 8800GTX 

Geforece GTX280 

Geforece GTX480 

Core2 Duo 

3.0GHz 

Quad Core 

Xeon 3.2GHz 

NVIDIA GPU 

0 

1900 1900 1900 1900 1900 1900 1900 1900 1900 

2003 2004 2005 2006 2007 2008 2009 2010 

※NVIDIA CUDA Programming Guide 4.0より引用 

6 

Intel 

CPU

GPGPUって? 

GPGPUは何の略? 

General-Purpose computation on GPUs 

GPUを汎用計算に利用しようという試み 

現在は「GPUコンピューティング」とも呼ばれる 

どうしてGPGPUが注目されているのか? 

GPUの計算性能が飛躍的に向上 

最新のGPUは 1.5 TFLOPS 以上の演算性能(CPUの約10倍) 

GPUはCPUと比較して並列計算に優れている 

GeForce GTX580 では 512 コアによる並列計算が可能 

手頃な価格で入手可能 

GeForce GTX580 は約5万円で購入可能 

7

GPGPUの活用例 

動画像処理 

CyberLink PowerDirector 7 

ビデオエフェクトのレンダリングを高速化 

TMPGEnc 4.0 XPress 

フィルター処理・デコード処理の高速化 

画像処理 

Adobe Photoshop CS4 / CS5,Adobe Premire CS5 

各種フィルタ処理の高速化 

OpenCV 

各種画像処理の高速化 

数値計算 

MATLAB 

FFTの高速化 

8

GPUの歴史: 1999年以前 

1970年 ~ 1990年 

初期開発の時代 

ソフトウェアによるグラフィックス処理 

プログラム可能なGPUに関する初期研究 

Ikonas System [1], Pixel Machine [2] 

[1] J. N. England, “A system for interactive modeling of physical curved surface 

objects,” Proceedings of SIGGRAPH 78, pp.336-340. 1978 

[2] M. Potmesil and E. M. Hoffert, “The Pixel Machine: A Parallel Image 

Computer,” Proceedings of SIGGRAPH89, pp.69-78, 1989 

1990年 ~ 1999年 

GPU技術の黎明期 

3Dグラフィックス・アクセラレータの開発 

グラフィックス向けライブラリの開発 

OpenGL(1992年~), DirectX(1995年~) 

9

GPUの歴史: 1999年~ 

“GPU”の誕生 

NVIDIA社の GeForce 256 の登場 

ハードウェア T&L ※ をサポート 

CPU負荷を大幅に削減 

グラフィックスパイプライン 

ハードウェア固定の処理 

自由表現な表現は不可 

※Transform & Lighting 

頂点処理 

(ハードウェア固定) 

ジオメトリ処理 

(クリッピング等) 

ラスタライズ処理 

ピクセル処理 

(ハードウェア固定) 

画面出力 

10


プログラマブルシェーダの登場 

Vertex Shader 

頂点座標の変換処理 

Pixel Shader 

画素の輝度計算処理 

シェーダ言語の進化 

アセンブラから高級言語へ 

Cg, HLSL, GLSL 

柔軟な映像表現が可能に 

グラフィックス以外への応用 

GPGPUへの関心が高まる 

Vertex Shader 

(プログラマブル) 

ジオメトリ処理 

(クリッピング等) 


Pixel Shader 


画面出力 

11


GPGPUの開発環境の整備 

CUDA (NVIDIA) 

ATI Stream (AMD) 

OpenCL 

DirectCompute 

GPGPU時代の到来 

物理シミュレーション 

数値計算 

信号解析 

画像処理・認識 

･･･ 

統合型シェーダ 

Vertex Shader 


Geometry Shader 



Pixel Shader 


画面出力 

12


Fermiアーキテクチャの登場 

汎用計算向けのアーキテクチャ ※ 

L1/L2キャッシュの搭載 

複数カーネルの同時実行のサポート 

倍精度浮動小数点演算の高速化 

ECCメモリのサポート 

アトミックなメモリ操作の高速化 

C++のフルサポート 

GPGPU関連のライブラリ&ツールの充実 

CUBLAS, CUFFT, Thrust, NPP 

Parallel Nsight, Visual Profiler 

13 

※ビデオカードによって 

サポート状況は異なる

~CUDAを使う前に~ 

14

CUDAって何? 

CUDA(Compute Unified Device Architecture) 

発音は「クーダ」もしくは「キューダ」 

NVIDIA社が提供するGPUを利用する 

ための統合開発環境 

GeForce 8以降のハードウェアで利用可能 

グラフィックス処理APIの知識は不要 

CPUでプログラムを実行する感覚 

C/C++を用いてプログラムの開発が可能 

既存のアルゴリズムの移植も比較的容易 

15

CUDAが利用可能な環境 

CUDA対応のグラフィックスカード 

GeForce GTX 580, GTX 480, GTX 260, 8800シリーズ,他 

Quadro Plex 2200 D2, FX 5800, FX 5600, 5000, 6000, 他 

Tesla S2050, C2070, S1070, C1060, S870, D870, C870 

※TeslaはHPCに特化した製品であり映像出力を持たない 

OSの対応状況(CUDA 4.0) 

Windows XP(32bit, 64bit) 

Windows Vista(32bit, 64bit) 

Windows Server 2008(32bit, 64bit) 

Linux(32bit, 64bit) 

Mac OS 

16

CUDAを使うための準備(Windows編) 

「CUDA ZONE」から次をダウンロード 

NVIDIA Driver 

CUDA対応のビデオドライバー 

CUDA Toolkit 4.0 ※ 

コンパイラ(nvcc) 

CUBLASやCUFFT 

ライブラリ 

ドキュメント 

CUDA SDK 4.0 

サンプル 

※ 2011年5月25日にリリース 

17 

http://www.nvidia.com/object/cuda_home.html

CUDAを動かしてみよう!! 

Volumetric Particle Shadows 

Image Denoising 

18 

※「CUDA SDK」内のサンプルの実行結果

~プログラミングの予備知識~ 

19

CUDA対応のGPU(G80, GT200) 

ストリーミング・マルチプロセッサ(SM) 

8 個のスカラープロセッサ(SP) 

16KBの共有メモリ 

スレッド間の同期機構 

マルチプロセッサ内でのみ可能 

マルチプロセッサ間での同期には 

CPU処理が必要 

GeForce GTX280 の場合 

30 基のマルチプロセッサを搭載 

1GByte以上のグローバルメモリ 

マルチプロセッサ #1 

SP SP SP SP 

SP SP SP SP 

マルチプロセッサ #2 

SP SP SP SP 

SP SP SP SP 

20

CUDA対応のGPU(Fermi) 

ストリーミング・マルチプロセッサ(SM) 

32 個のスカラープロセッサ(SP) 

48KBの共有メモリ 

スレッド間の同期機構 

マルチプロセッサ内でのみ可能 

マルチプロセッサ間での同期には 

CPU処理が必要 

GeForce GTX480 の場合 

15 基のマルチプロセッサを搭載 

1GByte以上のグローバルメモリ 

SM #1 

SP SP SP SP SP SP SP SP 




SM #2 





21

CUDAのプログラミングモデル 

GPUの特徴 

多数のスレッドが高い並列性をもって処理を実行 

GPU のみでプログラムを実行できない 

CPUとの連携が不可欠 

CUDAにおける計算の流れ 

GPUを並列演算可能なデバイスとして扱う 

複数のスレッドを同時に実行できる外部CPU 

階層的にスレッドを管理 

スレッドのまとまり = ブロック 

ブロックのまとまり = グリッド 

問題を分割して計算する際に便利 

22

CUDAにおけるスレッド管理 

スレッドを3次元的に配置 

各スレッドの ID を X, Y, Z の3要素で表現 

スレッドのまとまりをブロックとして管理 

グリッド 

ブロック(0,0,0) 

ブロック(0,0,1) 

スレッド 

(0,0,0) 

(0,0,1) 

スレッド 

(0,1,0) (1,0,0) (1,0,1) 

スレッド 

(1,0,0) (0,1,0) (0,1,1) 

スレッド 

(1,1,0) 

(1,1,1) 

スレッド 

(2,0,0) (0,2,0) (0,2,1) 

スレッド 

(2,1,0) 

(1,2,0) (1,2,1) 

ブロック(1,0,0) 

ブロック(1,0,1) 

スレッド 

(0,0,0) 

(0,0,1) 

スレッド 

(0,1,0) (1,0,0) (1,0,1) 

スレッド 

(1,0,0) (0,1,0) (0,1,1) 

スレッド 

(1,1,0) 

(1,1,1) 

ブロック(0,1,0) 

ブロック(0,1,1) 

ブロック(1,1,0) 

ブロック(1,1,1) 

スレッド 

(2,0,0) (0,2,0) (0,2,1) 

スレッド 

(2,1,0) (1,2,0) (1,2,1) 

23

階層的スレッドの利用方法 

一般的な画像処理で利用する場合 

ブロック内のスレッド数を決定 

16×16 = 256 スレッド 

画像内にブロックを配置 

ブロック内のスレッド 

が各画素を処理 

計算範囲の求め方 

ブロックID 

スレッドID 

ブロック内スレッド数 

T 00 T 10 

T 01 

T 0M 

T N0 

T NM 

ブロック#1 

T 00 T 10 T N0 

T 01 

T 0M 

T NM 

24

CUDAにおける計算の流れ 

処理1 

処理2 

グリッド 1 

ブロック(0,0,0) 

スレッド 

(0,0,0) 

スレッド 

(0,1,0) 

スレッド 

(1,0,0) 

スレッド 

(1,1,0) 

スレッド 

(2,0,0) 

スレッド 

(2,1,0) 

ブロック(1,0,0) 

ブロック(0,1,0) ブロック(1,1,0) 

グリッド 2 

スレッド 

(0,0,0) 

スレッド 

(0,1,0) 

スレッド 

(1,0,0) 

スレッド 

(1,1,0) 

ブロック (0,0,0) ブロック (1,0,0) 

スレッド 

(2,0,0) 

スレッド 

(2,1,0) 

25

CUDAのメモリモデル 

ブロック (0,0,0) 

ローカルメモリ 

レジスタ 

スレッド (0,0,0) 

共有メモリ 


レジスタ 

スレッド(1,0,0) 

ブロック(1,0,0) 

コンスタントメモリ 

テクスチャメモリ 

グローバルメモリ 


レジスタ 



レジスタ 

スレッド(0,0,0) スレッド(1,0,0) 

26

CUDAで利用可能なメモリ 

グローバルメモリ 

大量のメモリを利用可能 

低速なメモリアクセス(400~600クロック必要) 

Fermiアーキテクチャではキャッシュ機構(L1/L2)を搭載 


レジスタと同じ速度でアクセス可能 

マルチプロセッサ1基あたり16KB(Fermiは最大48KB) 

Fermiの場合は一部をL1キャッシュとして利用可能 

テクスチャメモリ 

キャッシュ機構による高速なアクセスが可能 

ハードウェア線形補間や正規化テクスチャ座標が利用可能 


キャッシュ機構による高速なアクセスが可能 

マルチプロセッサ1基あたり64KB 

27

各GPUで使用できる機能の違い 

使用できる機能を Compute Capability で区別 

現在 1.0 ~ 2.1 のGPUが存在 

Compute Capability による機能の違い 

1.0:初期リリース 

GeForce 8800GTX, Quadro FX 5600, 他 

1.1:アトミックなメモリ操作のサポート 

GeForce 9800 GTX, Quadro FX 3700, 他 

1.3:倍精度浮動小数点演算のサポート 

GeForce GTX 280, Quadro FX 5800, 他 

2.x :グローバルメモリのキャッシュをサポート 

GeForce GTX480,Quadro 5000,他 

28

Compute Capabilityによる機能の違い 

Compute Capability 

1.0 1.1 1.2 1.3 2.x 

3次元グリッド × ○ 

倍精度浮動小数 × ○ 

32ビット整数の 

アトミック演算 × ○ 

64ビット整数の 


単精度浮動小数の 


29

CUDAにおける制限事項 

1ブロックあたりの 

スレッド数 

1マルチプロセッサ 

あたりのスレッド数 

1マルチプロセッサ 

あたりのレジスタ数 

Compute Capability 

1.0 1.1 1.2 1.3 2.x 

コンスタントメモリ 64KB 

512 1024 

768 1024 1536 

8192 16384 32768 

共有メモリ 16KB 48KB 

2Dテクスチャ 2 16 ×2 15 2 16 ×2 16 

30

~ CUDAを使って“Hello World”~ 

31

CUDAを使って“Hello World!!” 

Hello World!! を表示するサンプル(main.cu) 

__global__ void hello( char *data ) 

{ 

char *text = "Hello World!!¥n"; 

data[ threadIdx.x ] = text[ threadIdx.x ]; 

} 

int main( int argc, char *argv[] ) 

{ 

char *dData, hData[ 15 ]; 

} 

cudaMalloc( ( void ** )&dData, sizeof( char ) * 15 ); 

dim3 nThreads( 15, 1 ); 

dim3 nBlocks( 1, 1 ); 

hello>( dData ); 

cudaMemcpy( hData, dData, sizeof( char ) * 15, cudaMemcpyDeviceToHost ); 

printf( "%s", hData ); 

cudaFree( dData ); 

return( 0 ); 

32




{ 



} 


{ 


} 








return( 0 ); 

_ _global_ _, threadIdx 

CUDAで拡張された部分 

dim3, 

33




{ 



} 


{ 


} 








return( 0 ); 

34

CUDAの言語拡張(1) 

言語拡張により追加された修飾子 

関数に対する修飾子 

_ _global_ _ CPU から呼び出され,GPU で実行される関数 

_ _device_ _ GPU から呼び出され,GPU で実行される関数 

_ _host_ _ CPU から呼び出され,CPU で実行される関数 

変数に対する修飾子 

_ _constant_ _ GPU 上のコンスタントメモリに存在する変数 

_ _shared_ _ GPU 上の共有メモリに存在する変数 

_ _device_ _ GPU 上のメモリに存在する変数 

35




{ 



} 


{ 


} 








return( 0 ); 

36

CUDAの言語拡張(2) 

CUDAで利用可能な組み込み型 

dim3 整数 x, y, z からなる 3 次元ベクトル 

(スレッド数やブロック数の指定に利用) 

uchar2, int2, float2, … x, y からなる 2 次元ベクトル 

uchar3, int3, float3, … x, y, z からなる 3 次元ベクトル 

uchar4, int4, float4, … x, y, z, w からなる 4 次元ベクトル 

GPU内のスレッドを識別する組み込み変数 

gridDim グリッドの次数 

blockIdx スレッドが属するブロックのインデックス 

blockDim スレッドが属するブロックの次数 

threadIdx ブロック内のスレッドのインデックス 

37

gridDim 

= 2×2×2 

スレッドを識別する組み込み変数 

38 

グリッド 

ブロック(0,1,1) 

ブロック(1,0,1) 

スレッド 

(0,0,1) 

スレッド 

(0,1,1) 

スレッド 

(0,2,1) 

スレッド 

(1,0,1) 

スレッド 

(1,1,1) 

スレッド 

(1,2,1) 

ブロック(1,1,1) 

ブロック(0,1,0) ブロック(1,1,0) 

ブロック(1,0,0) 

スレッド 

(0,0,0) 

スレッド 

(0,1,0) 

スレッド 

(0,2,0) 

スレッド 

(1,0,0) 

スレッド 

(1,1,0) 

スレッド 

(1,2,0) 

スレッド 

(0,0,0) 

スレッド 

(1,0,0) 

スレッド 

(2,0,0) 

スレッド 

(0,1,0) 

スレッド 

(1,1,0) 

スレッド 

(2,1,0) 

ブロック(0,0,1) 

スレッド 

(0,0,1) 

スレッド 

(0,1,1) 

スレッド 

(0,2,1) 

スレッド 

(1,0,1) 

スレッド 

(1,1,1) 

スレッド 

(1,2,1) 

ブロック(0,0,0) 

blockIdx 

blockDim 

= 3×2×2 

スレッド 

(0,0,0) 

スレッド 

(0,1,0) 

スレッド 

(0,2,0) 

スレッド 

(1,0,0) 

スレッド 

(1,1,0) 

スレッド 

(1,2,0) 

スレッド 

(1,0,0) 

スレッド 

(2,0,0) 

スレッド 

(0,1,0) 

スレッド 

(1,1,0) 

スレッド 

(2,1,0) 

スレッド 

(0,0,0) 

threadIdx

C/C++プログラミングとの相違点 

CPUとGPUで実行するコードを明確に区別 

CPUで実行する場合は “__host__”(省略可)を付与 

GPUで実行する場合は “__global__” を付与 

CPUとGPUで処理可能なメモリ空間の違い 

CPUとGPU間でメモリ転送が必要 

スレッド数を指定してGPU上の関数を呼び出し 

関数名>( … ); 

ブロック数とスレッド数は実行時に指定可能 

問題サイズに合わせて調整可能 

39




{ 



} 


{ 


} 








return( 0 ); 

GPU上のメモリを解放 

GPU上で実行される関数 

GPU上にメモリを確保 

ブロック内に配置する 

スレッド数 15×1 = 15 

総ブロック数 1×1 = 1 

CPUからGPUへメモリ転送 

40

スレッドのレジスタ数を調査 

Visual Studio 2008 コマンドプロンプトを起動 

コマンドプロンプト上で main.cu をコンパイル 

C:¥Your¥Path>nvcc main.cu --ptxas-options=-v --compile 

main.cu 

ptxas info : Compiling entry function '_Z5helloPc' for 'sm_10' 

ptxas info : Used 2 registers, 8+16 bytes smem, 15 bytes cmem[0] 

レジスタ数 

合計レジスタ数をチェック 

2 × 15 = 30 

レジスタ数生成スレッド数合計 

41

~Thrustライブラリの使い方~ 

42

Thrustライブラリって? 

CUDAで利用できるテンプレートライブラリ 

CUDAとOpenMPに対応したC++ STLの並列版 

URL: http://thrust.googlecode.com/ 

Thrustライブラリの特徴 

コンテナ 

CPUとGPUのデータをコンテナとして管理 

アルゴリズム 

コンテナに対してアルゴリズムを適用可能 

直感的なインターフェース 

CUDAの複雑なAPIに関する知識は不要 

メモリの確保/解放/転送がとても簡単 

43

Thrustライブラリの使い方 

GPU上で「1,2,3,…,100」の総和を計算 

#include 

#include 

#include 

#include 


{ 

// CPU上のメモリを確保 

thrust::host_vector< int > hvec( 100 ); 

} 

// データを初期化 1, 2, 3, ... 

thrust::sequence( hvec.begin( ), hvec.end( ), 1 ); 

// GPU上のメモリを確保 

thrust::device_vector< int > dvec( 100 ); 

// CPU -> GPU のメモリ転送 

dvec = hvec; 

int val = thrust::reduce( dvec.begin( ), dvec.end( ), 0, thrust::plus< int >( ) ); 

printf( "%d¥n", val ); 

return( 0 ); 

44

コンテナの使い方(1) 

メモリの確保 

thrust::host_vector< int > hvec( 20 ); 

CPU上のメモリに要素数20の「int」配列を確保 

thrust::device_vector< float > dvec( 100 ); 

GPU上のメモリに要素数100の「float」配列を確保 

メモリの解放 

コンテナオブジェクトの消滅時に自動解放 

CPUの場合:free( ) 

GPUの場合:cudaFree( ) 

明示的なメモリ解放:dvec.clear( ) 

45

コンテナの使い方(2) 

メモリの転送 

代入操作でメモリ転送が可能 

thrust::host_vector< float > hvec( 20 ); 

thrust::device_vector< float > dvec( 20 ); 

dvec = hvec; 

コンテナの各要素へのアクセス 

配列と同様にアクセス可能 

hvec[ 5 ] = 100.0f; 

dvec[ 1 ] = 23.4f; 内部でcudaMemcpyが呼ばれるので注意 

46

イテレータ(1) 

コンテナの要素を指すポインタ 

STLのイテレータと同じように使用可能 


thrust::device_vector< int >::iterator ite = dvec.begin( ); 

dvec.begin( ) dvec.end( ) 

dvec 

0 1 2 3 

dvec.begin( ) + 3 

47

イテレータ(2) 

コンテナの各要素へのアクセス 


thrust::device_vector< int >::iterator ite = dvec.begin( ); 

*ite = 10; 

++ite; 

*ite = 25; 

dvec[ 0 ] = 10 と等価 

dvec[ 1 ] = 25 と等価 

48

アルゴリズムと使用方法 

CPUとGPUのデータに対して同じ様に適用可能 

GPUの場合はGPUを使用して並列処理される 

アルゴリズムの使用例 

コンテナのデータすべてに1を代入する 

thrust::fill( dvec.begin( ), dvec.end( ), 1 ); 

1 1 1 1 1 1 1 1 

コンテナのデータに 1, 2, 3, … の値で初期化する 

thrust::sequence( dvec.begin( ), dvec.end( ) ); 

1 2 3 4 5 6 7 N 

49

Parallel Reduction(1) 

コンテナ内の要素を1つの値に集約する処理 

GPUのスレッドが並列に処理を実行 

例:総和計算の場合 

GPU上のデータ 

1 2 3 4 5 6 7 8 

3 7 11 15 

10 26 

36 

36 

CUDAスレッドの同期 

CUDAスレッドの同期 

50

Parallel Reduction(2) 

Thrustライブラリを用いた集約処理 

総和の計算 

int val = thrust::reduce( dvec.begin( ), dvec.end( ) ); 

1 2 3 4 5 6 7 10 55 

最大値の計算 

int val = thrust::reduce( dvec.begin( ), dvec.end( ), 

1 10 3 8 5 9 7 2 

6 10 

51 

0, thrust::maximum< int >( ) );

CUDAとThrustを組み合わせる 

Hello World!! を表示するサンプル 

#include 

#include 


{ 



} 


{ 

thrust::host_vector< char > hvec( 15 ); 

thrust::device_vector< char > dvec( 15 ); 

} 



hello>( thrust::raw_pointer_cast( &dvec[ 0 ] ) ); 

hvec = dvec; 

printf( "%s", &hvec[ 0 ] ); 

return( 0 ); 


GPU上のメモリを指す 

ポインタを取得 

52

GPGPUにチャレンジ 

行列積の計算 

CUDAにおける基本的な実装方法 



2次元テクスチャメモリ 

ハードウェア線形補間 

正規化テクスチャ座標 

Parallel Reduction アルゴリズム 


1次元テクスチャメモリ 


SIFT特徴量の計算 

1・2次元テクスチャメモリ 


54

~行列積の計算~ 

55

GPUによる行列積の計算 

行列積計算の特徴 

各要素はすべて独立に計算可能 

GPUによる並列計算が可能 

同じメモリ領域へ頻繁にアクセス 

メモリアクセス速度がボトルネック 

GPU上での実装方法 

1. 行列積の計算式に忠実な実装(GPU#1) 

2. 共有メモリを利用した高速化(GPU#2) 

ブロック単位(部分行列)で行列積を計算 

共有メモリをキャッシュとして利用 

56

行列積C=A×Bの流れ 

1. 行列A, B, CのメモリをGPU上に確保 

2. 行列A, BのデータをGPUに転送 

3. 行列Cの各要素c mnを計算 

N 次正方行列を仮定 

ただし,N は16の倍数 

c 

mn 

 

N 

 

k1 

mk 

b 

4. 計算結果をCPUに転送 

a 

kn 

m行 

amk 

N 

N 

n列 

行列A 行列C 

bkn 

57 

行列B 

cmn

処理の流れ 

CPU側の処理 

行列の初期化 

GPU側の処理 

CPU 

行列Cの各要素を計算 

行 

列 

の 

初 

期 

化 

GPU 

メ 

モ 

リ 

確 

保 

CPU GPU 

デ 

ー 

タ 

転 

送 

GPU 

行 

列 

積 

の 

計 

算 

GPU CPU 

デ 

ー 

タ 

転 

送 

58

行列積計算のCPU処理(ソース) 


{ 

int N = 512; // 行列A, B, Cのサイズ 

float *hA, *hB, *hC; // CPU(host)側で利用するメモリへのポインタ 

float *dA, *dB, *dC; // GPU(device)側で利用するメモリへのポインタ 

} 

/* CPU側のメモリを確保*/ 

/* GPU側のメモリを確保*/ 

/* CPU側のメモリをGPU側へ転送 */ 

/* 実行するGPUのスレッド数,ブロック数を設定 */ 

/* GPUのカーネルを実行し,C=A×B の結果を dC に格納 */ 

/* GPUの計算結果をCPU側へ転送 */ 

/* CPUとGPUそれぞれのメモリを解放 */ 

return( 0 ); 

59

行列積計算のCPU処理(1) 

行列積の計算で使用する変数 




CPUとGPUでメモリを確保 

CPU:malloc, new, cudaMallocHost でメモリを確保 

GPU:cudaMalloc によりグローバルメモリを確保 

/* CPU側のメモリを確保 */ 

hA = ( float * )malloc( N * N * sizeof( float ) ); 

hB = ( float * )malloc( N * N * sizeof( float ) ); 

hC = ( float * )malloc( N * N * sizeof( float ) ); 

/* GPU側のメモリを確保 */ 

cudaMalloc( ( void ** )&dA, N * N * sizeof( float ) ); 

cudaMalloc( ( void ** )&dB, N * N * sizeof( float ) ); 

cudaMalloc( ( void ** )&dC, N * N * sizeof( float ) ); 

60


CPUとGPU間のメモリ転送 

CPU→GPU 

cudaMemcpy( dst, src, size, cudaMemcpyHostToDevice ); 

GPU→CPU 

転送元 

転送先転送バイト数 

cudaMemcpy( dst, src, size, cudaMemcpyDeviceToHost ); 

この部分を変更 

転送方向 

CPUとGPUで確保したメモリの解放 

CPU:free, delete, cudaFreeHost でメモリを解放 

GPU:cudaFree でグローバルメモリを解放 

61


GPU上で処理を実行 

計算範囲の設定 

N 次正方行列を仮定 

ただし N は16の倍数 

行列Cをサイズ16×16のブロックに分割 

ブロック内の各要素を各スレッドが計算 

合計M×M 個のブロックを配置 

各スレッドが c mn を計算 

n = threadIdx.x + blockIdx.x × blockDim.x; 

m = threadIdx.y + blockIdx.y × blockDim.y; 

GPU上で関数を実行 

multiply>( … ); 

16 

16 

(threadIdx.y, threadIdx.x) 

行列C 

62 

(blockIdx.y, blockIdx.x) 

行方向のブロック数 (=16)

行列積計算のCPU処理(まとめ) 


{ 




} 

/* CPU側のメモリを確保*/ 

/* GPU側のメモリを確保*/ 

/* CPU側のメモリをGPU側へ転送 */ 

/* 実行するGPUのスレッド数,ブロック数を設定 */ 


dim3 nBlocks( N / nThreads.x, N / nThreads.y ); 

/* GPUのカーネルを実行し,C=A×B の結果を dC に格納 */ 

multiply>( dA, dB, dC, N ); 

/* GPUの計算結果をCPU側へ転送 */ 

/* CPUとGPUそれぞれのメモリを解放 */ 

return( 0 ); 

GPU上で処理を実行 

GPU上のメモリを指定 

63

実装方法(GPU#1) 

行列積C=A×Bの各要素c mnを計算 

要素c mnをGPU上で並列計算 

__global__ void multiply1( float *dA, float *dB, float *dC, int N ) 

{ 

int n = threadIdx.x + blockIdx.x * blockDim.x; 

int m = threadIdx.y + blockIdx.y * blockDim.y; 

} 

c 

mn 

 

N 

 

k1 

a 

mk 

float sum = 0.0f; 

for( int k = 0 ; k < N ; k++ ) 

{ 

sum += dA[ m + k * N ] * dB[ k + n * N ]; 

} 

dC[ m + n * N ] = sum; 

b 

kn 

m行 

amk 

N 

N 

n列 

行列A 行列C 

bkn 

64 

行列B 

cmn


各要素c mnを部分行列(ブロック)の積で計算 

ブロックサイズが16×16の場合 

c 

mn 

N 

 

16 

t1 

16( 

t1) 

k16t 

ブロック内で同じメモリを参照 

高速な共有メモリを利用 

a 

mk 

グローバルメモリへの 

アクセスを削減 

2×N×16 2 回 

16分の1 

◦ 

2×N×16 回 

b 

kn 

16 

16 

N 

amk 

N 

bkn 

16 

cmn 

16 

65 

行列B 

行列A 行列C


__global__ void multiply2( float *dA, float *dB, float *dC, int N ) 

{ 

int n = threadIdx.x + blockIdx.x * blockDim.x; 

共有メモリの宣言 

int m = threadIdx.y + blockIdx.y * blockDim.y; 

} 

float sum = 0.0f; 

for( int k = 0 ; k < N ; k += 16 ) 

{ 

__shared__ float tA[ 16 ][ 16 ]; 

__shared__ float tB[ 16 ][ 16 ]; 

} 

tA[ threadIdx.y ][ threadIdx.x ] = dA[ m + ( k + threadIdx.x ) * N ]; 

tB[ threadIdx.x ][ threadIdx.y ] = dB[ ( k + threadIdx.y ) + n * N ]; 

__syncthreads( ); 

for( int t = 0 ; t < 16 ; t++ ) 

{ 

sum += tA[ threadIdx.y ][ t ] * tB[ threadIdx.x ][ t ]; 

} 

__syncthreads( ); 

dC[ m + n * N ] = sum; 

ブロック内のスレッドを同期 

ブロック内のスレッドを同期 

各スレッドが独立 

して行列積を計算 

各スレッドが独立して 

メモリアクセス 

16 

16 

N 

amk 

N 

bkn 

16 

cmn 

16 

66 

行列B 

行列A 行列C

計算時間の比較(1) 

CPU, GPU#1, GPU#2 の計算時間を比較 

使用計算機 

CPU: Intel Core i7-X980(3.33GHz) 

OpenMPを使用して6スレッドで並列計算 

GPU: NVIDIA Geforce GTX480 

マルチプロセッサ数: 15(SP数 = 15×32 = 480) 

Memory:1.5 GB 

OS:Windows 7 SP1 

67


500 

450 

400 

350 

300 

250 

200 

150 

100 

50 

0 

[msec.] 

計算時間(N = 560 の場合) 

･CPU#1: 91.7 msec. 

･GPU#1: 18.3 msec. (×5.0) 

･GPU#2: 06.7 msec. (×13.7) 

N = 560 

16 

32 

48 

64 

80 

96 

112 

128 

144 

160 

176 

192 

208 

224 

240 

272 

288 

304 

320 

336 

352 

368 

400 

416 

432 

448 

464 

480 

496 

528 

544 

560 

592 

608 

624 

656 

672 

688 

720 

736 

752 

768 

784 

800 

行列のサイズ (N 次正方行列) 

CPU 

GPU#1 

GPU#2 

68

まとめ(行列積) 

GPU上での実装方法 

1. 行列積の計算式に忠実な実装(GPU#1) 

2. 共有メモリを利用した高速化(GPU#2) 

大きさ16×16の部分行列積に分割 

共有メモリをキャッシュとして利用 

CPUとGPUそれぞれでの計算速度を比較 

CPU < GPU#1 < GPU#2 

×5.0 ×13.7 

メモリアクセスの工夫により約34倍の高速化 

69

~テンプレートマッチング~ 

70

テンプレートマッチング(1) 

画像処理の分野で広く用いられている手法 

基板の品質検査 

画像中の特定物体(人物など)の検出 

入力画像中からテンプレートに類似する部分を探索 

入力画像中に窓を設定 

窓を移動させながら 

類似度を評価 

比較 

テンプレート窓 

71

テンプレートマッチング(2) 

基本的なテンプレートマッチングの戦略 

入力画像中の部分画像とテンプレートの類似度を評価 

窓を移動させながら類似度計算 

位置(X軸方向, Y軸方向) 

拡大/縮小(スケール変化) 

回転 

類似度の例 

SAD(Sum of Absolute Difference) 

SSD(Sum of Squared Difference) 

NCC(Normalized Cross Correlation) 

窓の大きさに比例して計算コストが増加 

膨大な回数の類似度評価が必要 

計算コスト大 

72

デモ(テンプレートマッチング) 

73

テンプレートマッチングの実装方法 

テンプレートマッチングの特徴 

類似度は各位置で独立に計算可能 


頻繁に画像メモリへアクセス 

テクスチャメモリのキャッシュ機能を利用 

複数スケールでテンプレートと入力画像を比較 

正規化テクスチャ座標とハードウェア線形補間の利用 

解像度に依存しないメモリアクセス 

･･･ 

スケール 

74


CPU側の処理 

入力画像とテンプレートの読み込み 

GPUスレッドの同期 

GPU側の処理 

CPU 

類似度計算 

画 

像 

読 

み 

込 

み 

GPU 

メ 

モ 

リ 

確 

保 

CPU GPU 

デ 

ー 

タ 

転 

送 

GPU 

スケールの変更 

類 

似 

度 

計 

算 

CPU 

ス 

レ 

ッ 

ド 

同 

期 

GPU CPU 

デ 

ー 

タ 

転 

送 

75

テクスチャメモリとは? 

GPU上の読み取り専用の特殊なメモリ領域 

キャッシュを利用した高速なアクセスが可能 

2次元アクセスに対して効率的 

ハードウェアを利用した高速な線形補間が可能 

テクスチャメモリの定義 

texture texRef; 

DataType: データの型(int,float 等) 

Type: テクスチャの種類(1次元テクスチャなど) 

cudaTextureType1D,cudaTextureType2D,… 

ReadMode: 値の範囲 

cudaReadModeElementType: 各データ型の値を使用 

cudaReadModeNormalizedFloat: 0 ~ 1に正規化(符号付きは-1~1) 

76

メモリ確保と転送(1) 

入力画像のメモリをGPU上に確保 

テクスチャの定義(画素表現:RGBA) 

texture< uchar4, cudaTextureType2D, cudaReadModeElementType > imgTex; 

cudaArrayを利用して2次元テクスチャを確保 

cudaArray *imgArray; 

cudaChannelFormatDesc c1 = cudaCreateChannelDesc< uchar4 >( ); 

cudaMallocArray( &imgArray, &c1, width, height ); 


テクスチャメモリへの対応付け 

cudaBindTextureToArray( imgTex, imgArray, c1 ); 

転送データ量 

77 

画素表現の指定 

cudaMemcpyToArray( imgArray, 0, 0, pSrc, nBytes, cudaMemcpyHostToDevice ); 

転送元ポインタ 

CPUからGPUへ転送


テンプレートのメモリをGPU上に確保 

テクスチャの定義 

ハードウェア線形補間の有効化 

正規化テクスチャ座標の有効化 

ハードウェア線形補間の利用(1) 

texture< uchar4, cudaTextureType2D, cudaReadModeNormalizedFloat > refTex; 

refTex.filterMode = cudaFilterModeLinear; 

ハードウェア線形補間の利用(2) 

refTex.normalized = 1; 

(0, 0) 

(W-1, 0) 

(0, 0) (1, 0) 

(0, 1) 

(0, H-1) (W-1, H-1) 

(0, 0) 

(0, 0) (1, 0) 

(0, 1) 

78 

(1, 0) 

(0, 1) (1, 1)

GPU上で類似度計算 

__global__ void kernel( float *error, float *scale, int imgW, int imgH, 

int areaW, int areaH, int maskW, int maskH, float s ) 

{ 

int i = threadIdx.x + blockDim.x * blockIdx.x; 

int j = threadIdx.y + blockDim.y * blockIdx.y; 

} 

float err = 0.0f; 

float _1_w = 1.0f / maskW; // テンプレートの幅に対するスケーリング係数 

float _1_h = 1.0f / maskH; // テンプレートの高さに対するスケーリング係数 

for( int n = 0 ; n < maskH ; n++ ) 

{ 

for( int m = 0 ; m < maskW ; m++ ) 

{ 

uchar4 p1 = tex2D( imgTex, i + m, j + n ); 

float4 p2 = tex2D( refTex, _1_w * m, _1_h * n ) * 255.0f; 

} 

} 

err += ( p1.x - p2.x ) * ( p1.x - p2.x ); 

err += ( p1.y - p2.y ) * ( p1.y - p2.y ); 

err += ( p1.z - p2.z ) * ( p1.z - p2.z ); 

err *= _1_w * _1_h; 

if( error[ i + j * imgW ] > err ) 

{ 

error[ i + j * imgW ] = err; 

scale[ i + j * imgW ] = s; 

} 

テクスチャからデータを読み取り 

SSDが最小のも 

のを記録 

SSDを計算 

79

CPUによる類似度計算の制御 

// スケール&誤差を保持するGPU側のメモリ領域 

thrust::device_vector< float > derror( img.size( ), 1.0e10f ); 

thrust::device_vector< float > dscale( img.size( ), 0 ); 

float s = MIN_SCALE; 

while( s ( thrust::raw_pointer_cast( &derror[ 0 ] ), 

thrust::raw_pointer_cast( &dscale[ 0 ] ), 

W, H, W - w, H - h, w, h, s ); 

cudaDeviceSynchronize( ); // 処理が完了するまで待機する 

s *= SCALE_FACTOR; // スケールを変更する 

// GPUの処理結果を転送する 

thrust::host_vector< float > herror = derror; 

thrust::host_vector< float > hscale = dscale; 

スケールを変更して再探索 

GPUを用いて類似度を計算 

80


CPUとGPUで計算時間を評価 




GPU: NVIDIA GeForce GTX480 

マルチプロセッサ数: 15(SP数= 15×32 = 480) 

Memory:1.5 GB 


81


実験パラメータ 

入力画像 :800×600画素 

テンプレート:105×135画素 

スケール :0.3~1.9倍(拡大率1.2) 

実験結果 

CPU: 77.3 sec. 

GPU: 2.2 sec. 

約 35 倍の高速化 

結果画像 

テンプレート 

82

まとめ(テンプレートマッチング) 

テクスチャメモリを利用した高速化 

キャッシュを利用した効率的なメモリアクセス 

解像度に依存しないメモリアクセス 

ハードウェア線形補間 

正規化テクスチャ座標 

CPUとGPUで計算時間を比較 

CPU: 77.3 sec. 

GPU: 2.2 sec. 

約 35 倍の高速化を実現 

83

~テンプレートマッチングを高速化~ 

84


類似度計算の打ち切り処理を導入 

CPU 

各スケールで計算した類似度の最大値をGPUで計算 

画 

像 

読 

み 

込 

み 

Parallel Reduction アルゴリズムを利用 

GPU 

メ 

モ 

リ 

確 

保 

CPU GPU 

デ 

ー 

タ 

転 

送 

GPU 

類 

似 

度 

計 

算 

スケールの変更 

CPU 

ス 

レ 

ッ 

ド 

同 

期 

GPU 

最 

大 

類 

似 

度 

計 

算 

GPU CPU 

デ 

ー 

タ 

転 

送 

85

GPU上で類似度計算 

__global__ void kernel( float *error, float *scale, int imgW, int imgH, 

int areaW, int areaH, int maskW, int maskH, float s, float maxerr ) 

{ 

int i = threadIdx.x + blockDim.x * blockIdx.x; 

int j = threadIdx.y + blockDim.y * blockIdx.y; 

} 

float err = 0.0f; 

float _1_w = 1.0f / maskW; // テンプレートの幅に対するスケーリング係数 

float _1_h = 1.0f / maskH; // テンプレートの高さに対するスケーリング係数 

for( int n = 0 ; n < maskH ; n++ ) 

{ 

for( int m = 0 ; m < maskW ; m++ ) 

{ 

uchar4 p1 = tex2D( imgTex, i + m, j + n ); 

float4 p2 = tex2D( refTex, _1_w * m, _1_h * n ) * 255.0f; 

} 

} 

err += ( p1.x - p2.x ) * ( p1.x - p2.x ); 

err += ( p1.y - p2.y ) * ( p1.y - p2.y ); 

err += ( p1.z - p2.z ) * ( p1.z - p2.z ); 

if( maxerr < err *_1_w * _1_h ) 

{ 

break; 

} 

... 以下同じ ... 

前スケールの探索時における 

SSDが最小値より大きい場合 

は計算を打ち切り 

86

Parallel Reductionによる最小値探索 

GPU上のメモリから最小値を計算 

GPUのスレッドが並列に値の比較処理を実行 


11 4 27 25 5 13 6 9 20 12 14 7 2 19 3 15 

4 25 5 6 12 7 2 3 

4 5 7 2 

4 2 

2 

2 

同期 

同期 

同期 

87

Parallel Reductionによる最小値探索 

GPU上のメモリから最小値を計算 

GPUのスレッドが並列に値の比較処理を実行 

Thrustライブラリの reduce アルゴリズムを利用 

thrust::reduce( 先頭, 末尾, 初期値, thrust::minimum( ) ); 

先頭を指すイテレータ 

末尾を指すイテレータ 


11 4 27 25 5 13 6 9 20 12 14 7 2 19 3 15 

4 25 5 6 12 7 2 3 

4 5 7 2 

4 2 

2 

88 

同期 

同期 

同期 

2

CPUによる類似度計算の制御 

// スケール&誤差を保持するGPU側のメモリ領域 

thrust::device_vector< float > derror( img.size( ), 1.0e10f ); 

thrust::device_vector< float > dscale( img.size( ), 0 ); 

float s = MIN_SCALE, maxerr = 1.0e10f; 

while( s ( thrust::raw_pointer_cast( &derror[ 0 ] ), 

thrust::raw_pointer_cast( &dscale[ 0 ] ), 

W, H, W - w, H - h, w, h, s, maxerr ); 

cudaDeviceSynchronize( ); // 処理が完了するまで待機する 

// 誤差の最大値を取得する 

maxerr = thrust::reduce( derror.begin( ), derror.end( ), 1.0e10f, thrust::minimum< float >( ) ); 

s *= SCALE_FACTOR; // スケールを変更する 

// GPUの処理結果を転送する 

... 

Trustライブラリを用いてGPUを 

活用して誤差の最小値を計算 

89







マルチプロセッサ数: 15(SP数= 15×32 = 480) 

Memory:1.5 GB 


90



入力画像 :800×600画素 

テンプレート:105×135画素 

スケール :0.3~1.9倍(拡大率1.2) 

実験結果 

CPU: 8.700 sec. 

GPU: 0.258 sec. 

約 33.7 倍の高速化 

結果画像 

テンプレート 

91

まとめ(テンプレートマッチング) 

類似度計算の打ち切り処理により高速化 

Parallel Reductionアルゴリズムを利用 


類似度の打ち切り 

なしあり 

CPU 77.3 秒 8.7 秒 

GPU 2.2 秒 0.258 秒 

92

~ガウシアンフィルタ~ 

93

ガウシアンフィルタに挑戦 

94

空間フィルタリング(線形フィルタ) 

線形フィルタとは? 

i, j 

hx, 

y 

f i x j y 

画像処理の基本的な処理 


LoGフィルタ 

ガボールフィルタ 

他 

h 

w 

 

g , 

出力画像 

y 

h x 

w 

フィルタ 

入力画像 

フィルタh(i,j) 

積和 

出力g(i,j) 

周辺領域 

注目画素 f(i,j) 

入力画像 

95


フィルタ係数に2次元ガウス分布を利用 

h 

問題点 

2 

1 x y 

2 

2 

2 

 

x, 

y exp 

フィルタ半径が大きくなるにつれ計算コスト大 

フィルタを1次元ガウス分布の積に分解 

h 

2 

 

 

2 2 

2 

2 

1 x y 1 x y 

 

 

2 

2 

2 

2 

2 

2 

2 

2 

 

x, 

y exp 

exp exp 

 

h 

2 w 

2 

1 y x 

g , 

 

, 

2 

2 

2 

y 

h 2 

x 

w 2 

 

i j 

exp exp f i x j y 

Y軸方向への1次元ガウシアンフィルタ 

 

 

96 

X軸方向への1次元ガウシアンフィルタ

ガウシアンフィルタの特徴 

フィルタ出力は各画素で独立に計算可能 


フィルタ係数の算出 

フィルタ適用前に事前計算が可能 

フィルタ適用中は常に同じ値を参照 

コンスタントメモリを利用 

注目画素の周辺領域(1次元)にアクセス 

1次元テクスチャのキャッシュ機能を利用 

97

コンスタントメモリとは? 

GPU上に実装されている特殊なメモリ領域 

読み取り専用 

マルチプロセッサ1基あたり 64 KB 

キャッシュを利用した高速なアクセスが可能 

レジスタとほぼ同じ速度でアクセス可能 

コンスタントメモリの定義 

__constant__ float coeff[ 512 ]; 

C言語の配列のようにアクセス可能 

98


GPU上に2つの1次元配列を確保 

X,Y軸方向の処理時に入力と出力を入れ替え 

GPU内でのメモリ転送コストを削減 

99 

画 

像 

読 

み 

込 

み 

CPU 

メ 

モ 

リ 

確 

保 

GPU 

( 

X 

軸 

) 

ガ 

ウ 

シ 

ア 

ン 

フ 

ィ 

ル 

タ 

GPU 

ス 

レ 

ッ 

ド 

同 

期 

CPU 

デ 

ー 

タ 

転 

送 

CPU GPU 

デ 

ー 

タ 

転 

送 

GPU CPU 

( 

Y 

軸 

) 

ガ 

ウ 

シ 

ア 

ン 

フ 

ィ 

ル 

タ 

GPU 

メモリ1 

メモリ2 メモリ2 

入力画像


入力画像のメモリをGPU上に確保 

テクスチャの定義 

texture< float4, 1 > imgTexX; 

texture< float4, 1 > imgTexY; 

GPU上に1次元配列を確保 

cudaMalloc( ( void ** )&iData, nBytes ); 

cudaMalloc( ( void ** )&oData, nBytes ); 


cudaMemcpy( oData, pSrc, nBytes, cudaMemcpyHostToDevice ); 

1次元テクスチャにマッピング 

cudaBindTexture( 0, imgTexX, oData ); 

cudaBindTexture( 0, imgTexY, iData ); 

100


フィルタ係数をコンスタントメモリに確保 

コンスタントメモリの定義 

__constant__ float coeff[ 512 ]; 

コンスタントメモリを表す修飾子 


サイズ指定が必要 

cudaMemcpyToSymbol( coeff, pSrc, 512 * sizeof( float ) ); 

101






GPU: NVIDIA Geforce GTX480 

マルチプロセッサ数: 15(SP数 = 15×32 = 480) 

Memory:1.5 GB 



画像サイズ:100 2 ~ 3000 2 画素 

σ:5.0,10.0 

102


400 

350 

300 

250 

200 

150 

100 

50 

[msec.] 

計算時間(N 2 = 2000 2 の場合) 

･CPU(σ=5) : 105.2 msec. 

･GPU(σ=5) : 20.9 msec. (×5.0) 

･CPU(σ=10) : 167.7 msec. 

･GPU(σ=10) : 30.7 msec. (×5.5) 

0 

2002 400 2 600 2 800 2 1000 2 1200 2 1400 2 1600 2 1800 2 2000 2 2200 2 2400 2 2600 2 2800 2 3000 2 

画像サイズ N 2 

103 

CPU(σ=10) 

CPU(σ=5) 

GPU(σ=10) 

GPU(σ=5)

まとめ(ガウシアンフィルタ) 

2次元ガウス分布を1次元ガウス分布の積で表現 

ガウシアンフィルタを1次元フィルタに分解 

コンスタントメモリを利用した高速化 

キャッシュを利用したメモリアクセスの高速化 

同じ値をスレッド間で共有する場合に有効 


画像サイズが 2000 2 の場合(σ=5) 

CPU: 105.2 msec. 

GPU: 20.9 msec. 


104

~SIFT特徴量の計算~ 

105

SIFT(Scale Invariant Feature Transform) 

回転・スケール変化等に頑健な特徴点の検出 

画像間のマッチングや物体認識・検出に利用 

1. David G. Lowe, “Distinctive image features from scale-invariant keypoints,” 

International Journal of Computer Vision, 60, 2, pp. 91-110, 2004. 

2. 藤吉弘亘. "Gradientベースの特徴抽出 - SIFTとHOG - ", 情報処理学会研究報告 

CVIM 160, pp. 211-224, 2007. 

106 

1,2

SIFTのアルゴリズム(1) 

DoG画像の作成 

(Difference-of-Gaussian) 

特徴点の検出 

エッジ上の点を削除 

サブピクセル位置推定 

3 

k 

2 

k 

 

コントラストの 

DoG2 

小さい点を削除 DoG1 

107 

異なるスケールの平滑化画像の差分 

(DoG)を計算 

k 

 

周辺26画素に対して極値をとる位置を 

特徴点として検出 

DoG3 

DoG3 

DoG2 

DoG1


DoG画像の作成 

(Difference-of-Gaussian) 

特徴点の検出 

エッジ上の点を削除 

サブピクセル位置推定 

コントラストの 

小さい点を削除 

108


オリエンテーションの 

算出 

特徴ベクトルを算出 

周辺領域の勾配方向と強度から 

オリエンテーションを算出 

109

デモ( SIFT ) 

110

SIFTの実装方法 

さまざまなスケールにおけるDoG計算 

高速なガウシアンフィルタを利用 

キーポイント検出 

各画素で独立に判定可能 


判定に26近傍の画素値が必要 

3次元テクスチャを利用できるか? 

テクスチャサイズの制限から利用は困難 

2次元テクスチャで代用 

オリエンテーションの算出 

各キーポイントで独立に計算可能 

111


112 

画 

像 

読 

み 

込 

み 

CPU 

D 

o 

G 

計 

算 

GPU 

ス 

レ 

ッ 

ド 

同 

期 

CPU 

デ 

ー 

タ 

転 

送 

CPU GPU 

デ 

ー 

タ 

転 

送 

GPU CPU 

キ 

ー 

ポ 

イ 

ン 

ト 

検 

出 

GPU 

キーポイント 

DoG画像オリエンテーション 

入力画像 

キ 

ー 

ポ 

イ 

ン 

ト 

リ 

ス 

ト 

作 

成 

CPU 

オ 

リ 

エ 

ン 

テ 

ー 

シ 

ョ 

ン 

算 

出 

GPU 

デ 

ー 

タ 

転 

送 

GPU CPU

SIFT計算におけるメモリ配置 

複数スケールのDoG画像をテクスチャ1枚に配置 

ミップマップ ※ を構築 

DoG画像の出力先をソフトウェア的に調整 

1 

1 

1 

2 

1 

4 

1 

8 

･･･ 

･･･ 

113 

※CUDAは未サポート



SIFT特徴量としてオリエンテーションを計算 


CPU: Intel Core2 Quad Q9550(2.83 GHz) 

4スレッドで並列計算 


マルチプロセッサ数: 30(SP数= 30×8 = 240) 

Memory:1.0 GB 

OS:Windows Vista SP1 


画像サイズ:50 2 ~ 1000 2 画素 

σ 0:1.6,分割数:3 

114


2100 

2000 

1900 

1800 

1700 

1600 

1500 

1400 

1300 

1200 

1100 

1000 

900 

800 

700 

600 

500 

400 

300 

200 

100 

[msec.] 

計算時間(N 2 = 600 2 の場合) 

･CPU : 458.0 msec. 

･GPU : 10.2 msec. (×44.9) 

0 

50 2 100 2 150 2 200 2 250 2 300 2 350 2 400 2 450 2 500 2 550 2 600 2 650 2 700 2 750 2 800 2 850 2 900 2 950 2 10002 

画像サイズ N 2 

GPU 

CPU 

115

デモ(SIFT) 

116

まとめ(SIFT) 

テクスチャメモリとコンスタントメモリの利用 

キャッシュを利用したメモリアクセスの高速化 

ミップマップを構築 

複数スケールのDoG画像を1枚のテクスチャに格納 


N 2 = 600 2 の場合 

CPU: 458.0 msec. 

GPU: 10.2 msec. 


117

~GPGPUによる高速画像処理に挑戦して~ 

118

GPGPUへの挑戦を終えて 

CUDAを利用することで容易にGPGPUが可能 

スレッドプログラミングの経験があれば非常に簡単 

既存プログラムの移植も比較的容易 

Thrustライブラリによる簡単なGPGPU 

GPUを意識せずにプログラミングが可能 

GPUを使うと10倍以上の高速化が可能? 

多くの画像処理アルゴリズムは高速化が可能 

空間フィルタリング,局所特徴量計算,他 

逐次型の画像処理アルゴリズムは高速化が困難 

ラベリング,細線化,他 

119

GPGPUの問題点と今後の展望 

複数GPUの利用 

各GPU上で別々に処理を実行 

CUDA 4.0 は単一CPUスレッドから複数GPUを利用可能 

CPUとの連携 

GPUの苦手な処理をCPUで計算 

CPUとGPUの役割分担が重要 

高性能なGPUが登場 

リアルタイム画像処理(大規模計算)への挑戦 

GPGPU開発環境の標準化(OpenCL) 

120

参考文献 

[1] M. J. Harris, G. Coombe, T. Scheuermann, and A. Lastra, “Physically- 

Based Visual Simulation on Graphics Hardware,” Proceedings of 

SIGGRAPH 2002 / Eurographics Workshop on Graphics Hardware 2002, 

pp.1-10, 2002.(GPGPUの起源が書かれている論文) 

[2] J. D. Owens, D. Luebke, N. Govindaraju, M. Harris, J. Krüger, A. E. 

Lefohn, and T. J. Purcell, “A Survey of General-Purpose Computation on 

Graphics Hardware,” Computer Graphics Forum, Vol.26, No.1, pp.80- 

113, 2007.(最近のGPGPUが詳しく述べられている論文) 

[3] “GPGPU,” http://gpgpu.org/ 

[4] “CUDA ZONE,” http://www.nvidia.com/object/cuda_home.html 

[5] “CUDA Programming Guide,” 

http://www.nvidia.com/object/cuda_develop.html 

[6] “OpenCL,” http://www.khronos.org/opencl/ 

121

MIST(Media Integration Standard Toolkit) 

複数メディアを扱うためのライブラリ 

音声・画像処理のアルゴリズムを多数実装 

C/C++を用いた高速な処理を実現 

C++のテンプレートを用いた汎用的な実装 

複数のプラットフォームで動作 

充実した日本語チュートリアルを用意 

オープンソースとして公開中 

BSDスタイルのライセンス 

商用の製品開発でも利用可能 

http://mist.murase.m.is.nagoya-u.ac.jp/ 

122

~Visual Studio 2010 の詳細設定~ 

※CUDA Toolkit 4.0 以降 

123

Visual Studio 2010 の簡易設定(1) 

“.cu” ファイルの簡易コンパイル設定 

プロジェクトメニューのビルドのカスタマイズを表示 

CUDA 4.0を選択 

1.これを表示 

※ .cu ファイルの追加前に行う 

2.これを選択 

124


“.cu” ファイルのコンパイルオプション 

“.cu” ファイルのプロパティを表示 

NVCCのコンパイルオプションをGUIで調整可能 

これを表示 

125


「プロジェクト」「プロパティ」を選択 

「構成プロパティ」「リンカー」を選択 

追加の依存ファイル 

“cudart.lib” を指定 

ここに入力 

126


プログラムのコンパイルと実行 

Visual Studio の「ビルド」を実行 

実行ファイルが作成されることを確認 

「デバッグなしで開始」 

コマンドラインに “Hello World!!” が表示される 

Hello World!! 

続行するには何かキーを押してください . . . 

127 

※本講演のプログラムを実行した場合

~補足資料~ 

128

FLOPS 

FLoating point number Operations Per Second 

FLOPSやFLOP/s と表記される 

1秒あたりに実行可能な浮動小数点演算回数 

スーパーコンピュータ等の性能を表す指標 

代表的なCPU/GPUのFLOPS 

Core i7-965 

51.20 GFLOPS 

GeforceGTX580 

1.58 TFLOPS 

RadeonHD5870 

2.72 TFLOPS 

129 

※ GPUは積和演算の性能

CUDAにおけるエラー処理 

API関数(メモリ確保,他)の場合 

各API関数の戻り値を評価 

cudaSuccess → 実行に成功 

GPUで実行する関数の場合 

cudaThreadSynchronize( )により同期 

cudaGetLastError( ) の戻り値を評価 

cudaSuccess → 実行に成功 

130

~OpenCV + CUDA~ 

131

デモ(特徴点検出&対応付け) 

132

OpenCVをダウンロード 

Subversion経由で最新版を入手 

https://code.ros.org/svn/opencv/trunk/opencv 

Cmakeをダウンロード 

http://www.cmake.org/ 

133

OpenCVライブラリのビルド 

CUDAを有効にする 

Cmakeの設定で「WITH_CUDA」にチェック 

Configureを実行 

ビルド設定を反映 

Generateを実行 

ビルドファイルを生成 

3.ビルドファイルの生成 

2.設定を反映 

1.ここにチェック 

Cmakeの設定画面 

134

CPU/GPUのコードの違い 

SURFを用いた特徴点検出&マッチング(CPU) 

#include 

... 

cv::Mat_< float > desc2; 

cv::SurfFeatureDetector detector2( th2 ); 

// 特徴点を検出 

detector2.detect( frame_gray, keys2 ); 

// 特徴量を計算 

cv::SurfDescriptorExtractor extractor; 

extractor.compute( frame_gray, keys2, desc2 ); 

// 特徴点を対応付け 

cv::BruteForceMatcher< cv::L2< float > > matcher; 

matcher.match( desc1, desc2, matches ); 

135

CPU/GPUのコードの違い 

SURFを用いた特徴点検出&マッチング(GPU) 

#include 

... 

cv::gpu::GpuMat desc_gpu2; 

cv::gpu::SURF_GPU detector2; 

detector2.hessianThreshold = th2; 

// データをGPUへ転送 

cv::gpu::GpuMat frame_gpu; 

frame_gpu.upload( frame_gray ); 

// 特徴点検出&特徴量計算 

detector2( frame_gpu, cv::gpu::GpuMat(), keys2, desc_gpu2 ); 

// 特徴点を対応付け 

cv::gpu::BruteForceMatcher_GPU< cv::L2< float > > matcher; 

matcher.match( desc_gpu1, desc_gpu2, matches ); 

136

OpenCVでGPUを利用できる機能 

行列演算 


歩行者検出(HOG) 

特徴点検出&特徴量(SURF) 

特徴点対応付け 

画像フィルタ 

ラプラシアン,ソーベル,ガウシアン,他 

カメラキャリブレーション 

･･･ 

137

543-pdf

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?