cudaGPU

最新の20件

私的AI研究会 > cudaGPU

NVIDIA cuda GPU †

「PyTorch ではじめる AI開発」CPU でのモデル学習にあまりに時間がかかるので、手元にあるGPUを試してみる。

事前準備 †

　VertualBox 環境下では残念ながら GPU のサポートは受けられないようなので、Windows10 環境で環境構築を行うことにする。

使用するハードウェア †

• HP EliteDesk 800 G2 SFF
  
• CPU Intel® Core™ i7-6700 CPU @ 3.40GHz
  
• GPU NVIDIA GeForce GTX 1050 TI
  
• OS Windows10 Pro
  

• NVIDIAのGPUアーキテクチャ
  

  アーキテクチャ (読み方)	プロセスルール	採用シリーズ
  Kepler (ケプラー)	28nm	GeForce GTX/GT 600シリーズ
  		GeForce GTX/GT 700シリーズ
  		GeForce GTX TITANシリーズ
  Maxwell (マクスウェル)	28nm	GeForce GTX 700シリーズ
  		GeForce GTX 900シリーズ
  Pascal (パスカル)	16nm/14nm	GeForce GTX 10シリーズ
  Turing (チューリング)	12nm	GeForce RTX 20シリーズ
  		GeForce GTX 16シリーズ
  Ampere (アンペア)	8nm	GeForce RTX 30シリーズ
  Ada Lovelace (エイダラブレス)	5nm	GeForce RTX 40シリーズ

NVIDIA ドライバーのインストール（バージョンアップ） †

• 公式サイトGEFORCE® ドライバーから最新バージョンのドライバーをダウンロードしてインストールする。
  
• CUDA 公式サイトCUDA Zoneから「Download」→「Archive of Previous CUDA Releases」とたどり「CUDA Toolkit 11.1.1」をインストールする。
  
  
  
  
  ● インストール後の GameReadyドライバーバージョン v472.12
  ● インストール後の CUDA Toolkit バージョン v11.1.1
  

Anaconda のインストール †

1. 公式サイトAnaconda Individual Editionから「64-Bit Graphical Installer」をダウンロードする。
   
2. インストーラを起動し手順に従って進めて Anaconda をインストールする。
   
   
   
   
   
   
3. 「Microsoft VisualC++ Redistributable」をサイトhttps://docs.microsoft.com/ja-jp/cpp/windows/latest-supported-vc-redist?view=msvc-170からダウンロードし、インストールする。
   
   
   
   

Anaconda の起動とパッケージのインストール †

1. Windows10 のスタートメニューから「Anaconda Prompt」を選択する。
   ・以降の作業は「Anaconda Prompt」内で行う。
   ・表示ウインドウなサイズや文字の大きさなどは、ウインドウ上部のタイトルバーを右クリック「プロパティ」で設定する。
   
   
   
   ・主要なコマンド
   

   コマンド	パラメータ	用途
   cd (chdir)		現在のカレンディレクトリを表示
   	パス	カレンディレクトリの変更
   dir		カレンディレクトリのファイルやフォルダ一覧
   	パス	指定したパスのファイル表示
   tree		カレンディレクトリのツリー表示
   	パス	指定したパスのツリー表示
   ren	対象ファイル名 新しいファイル名	ファイル名を変更
   move	移動するファイル名 移動先パス	ファイルを移動
   	変更前ディレクトリ 変更後ディレクトリ	ディレクトリ名を変更
   copy	コピー元 コピー先	ファイルをコピー
   del	ファイル	ファイルやフォルダを削除
   help	コマンド名	コマンドのヘルプ表示
   cls		コンソールのクリア
   md (mkdir)	(パス)ディレクトリ名	ディレクトリの作成
   rm (rmdir)	(パス)ディレクトリ名	ディレクトリの削除
   type	(パス)ファイル名	テキストファイルの中身表示
   more	(パス)ファイル名	テキストファイルの1画面表示
   ipconfig		ネットワークの設定確認
   exit		コマンドプロンプトを終了

1. Anacondaの仮想環境を作成する。
   

   (base) C:\Users\izuts>conda create -n py37 python=3.7
       :
   done
   #
   # To activate this environment, use
   #
   #     $ conda activate py_37
   #
   # To deactivate an active environment, use
   #
   #     $ conda deactivate
   (base) C:\Users\izuts>conda activate py37
   (py37) C:\Users\izuts>
   (py37) C:\Users\izuts>conda info -e
   # conda environments:
   #
   base                     C:\Users\izuts\anaconda3
   py37                  *  C:\Users\izuts\anaconda3\envs\py37

   ・以降の操作は「Anaconda Prompt」から「py37」仮想環境を起動した状態で行う。
   
   
2. PyTorch をインストールする。
   ・オフィシャルサイトからインストールコマンドを得る。
   　※ 最新版ではなく今回は書籍指定の版をインストールする。
   

   (py37) > pip install torch==1.8.0+cu111 torchvision==0.9.0+cu111 torchaudio===0.8.0 -f https://download.pytorch.org/whl/torch_stable.html
   Looking in links: https://download.pytorch.org/whl/torch_stable.html
   Collecting torch==1.8.0+cu111
       :
   Successfully installed numpy-1.21.2 pillow-8.3.2 torch-1.8.0+cu111 torchaudio-0.8.0 torchvision-0.9.0+cu111 typing-extensions-3.10.0.2

3. 必要なパッケージのインストール
   

   (py37) > conda install opencv
       :
   (py37) > conda install pandas
       :
   (py37) > conda install tqdm
       :
   (py37) > conda install matplotlib
       :
   (py37) > conda install PyYAML
       :

   (py37) > pip install scikit-learn
       :
   (py37) > pip install pycocotools
       :
   (py37) > pip install facenet-pytorch
       :

環境の確認 †

• 「PyTorch」のインストール確認（エラーが出なければ OK）
  

  (py37) > python -c "import torch"

  ※「python3」ではエラーとなるので「python」コマンドを使用する。
  
  
• 「tkinter」パッケージのインストール確認
  

  (py37) > python -c "import tkinter"

• 「PyTorch」から GPU を使用できているかの確認。
  

  (py37) > python -c "import torch;print(torch.zeros(1).cuda())"
  tensor([0.], device='cuda:0')
  (py37) > python -c "import torch;print(torch.cuda.is_available())"
  True
  (py37) > python -c "import torch;print(torch.cuda.get_device_name(torch.device('cuda:0')))"
  NVIDIA GeForce GTX 1050 Ti

• カメラデバイスの確認
  
  

  (py37) cd \workspace_py37\chapter01
  (py37) > python chapt01_1.py
  Traceback (most recent call last):
    File "chapt01_1.py", line 12, in <module>
      ret, frame = cap.read() # 1フレーム読み込み
  KeyboardInterrupt

GPU 動作確認プログラム †

• プログラムを作成するディレクトリ「workspace_py37」を作成しテストプログラム「cuda_test.py」を作成する。
  

  「cuda_test.py」
  
  import torch
  
  print(torch.__version__)
  print(f"cuda, {torch.cuda.is_available()}")
  print(f"compute_{''.join(map(str,(torch.cuda.get_device_capability())))}")
  device_num:int = torch.cuda.device_count()
  print(f"find gpu devices, {device_num}")
  for idx in range(device_num):
      print(f"cuda:{idx}, {torch.cuda.get_device_name(idx)}")
  
  print("end")

• テストプログラムの実行
  

  (py37) cd \workspace_py37
  (py37) > python cuda_test.py
  1.8.0+cu111
  cuda, True
  compute_61
  find gpu devices, 1
  cuda:0, NVIDIA GeForce GTX 1050 Ti
  end

　モデル学習プログラムの実行 †

　「PyTorch ではじめる AI開発」の演習で作成したプログラム一式を Windows環境下のワークスペース「workspace_py37」にコピーして実行する。

Windows 環境下で発生するエラー対応 †

• Ubuntu 20.04 LTS 環境下で作成したプログラムを Windows10 上で実行すると次のようなエラーが発生する。
  

  RuntimeError:
          An attempt has been made to start a new process before the
          current process has finished its bootstrapping phase.
  
          This probably means that you are not using fork to start your
          child processes and you have forgotten to use the proper idiom
          in the main module:
  
              if __name__ == '__main__':
                  freeze_support()
                  ...
  
          The "freeze_support()" line can be omitted if the program
          is not going to be frozen to produce an executable.

• 実行するコードを関数化して if __name__ == '__main__': から呼び出すことで回避できるようだ。
  
• 実行プログラム「XXXXXX_Xa.py」プログラムを「XXXXXX_Xw.py」という名前でコピーして編集する。
  ※「PyTorch ではじめる AI開発」著者は、Windows10 環境をデフォールトに挙げているが実際の実行・確認は Linux 環境で行っているようだ。
  

CHAPTER 02 定点カメラの映像を認識する / SECTION-005 PyTorch による学習 †

• 実行結果

  (py37) cd \workspace_py37\chapter02
  (py37) > python chapt02_1w.py
  test #0 lr=0.001 weight=0.1
  epoch #0: train_loss:0.2363738864660263 valid_loss:0.671642541885376 score:{'daytime': 0.8198986642100414, 'twilight': 0.6198243412797992, 'midnight': 0.8382004735595896, 'total': 0.8051609539945263, 'average': 0.6876712328767123}
  epoch #1: train_loss:0.11925811320543289 valid_loss:0.7707163691520691 score:{'daytime': 0.8119376782971253, 'twilight': 0.6402966625463535, 'midnight': 0.9232995658465991, 'total': 0.8327183271832719, 'average': 0.7711415525114155}
  epoch #2: train_loss:0.09785430878400803 valid_loss:1.1248260736465454 score:{'daytime': 0.8047670639219935, 'twilight': 0.6153846153846154, 'midnight': 0.9255242227042662, 'total': 0.8252544837615123, 'average': 0.7934246575342466}
      :
  test #14 lr=5e-05 weight=0.5
  epoch #0: train_loss:0.5843794941902161 valid_loss:0.5459811091423035 score:{'daytime': 0.8226044226044227, 'twilight': 0.7152103559870548, 'midnight': 0.888248479026577, 'total': 0.8311780756910665, 'average': 0.8257534246575342}
  epoch #1: train_loss:0.42763030529022217 valid_loss:0.38860195875167847 score:{'daytime': 0.8707763734846531, 'twilight': 0.5974955277280858, 'midnight': 0.9057025717480431, 'total': 0.8431883302943476, 'average': 0.6885844748858447}
  epoch #2: train_loss:0.3030227720737457 valid_loss:0.31260067224502563 score:{'daytime': 0.9316497392259128, 'twilight': 0.6093928980526918, 'midnight': 0.9251551661190215, 'total': 0.890420399724328, 'average': 0.611324200913242}

• 学習にかかった時間

  機種	開始日時	終了日時	処理時間 (h:m)
  GeForce GTX 1050 Ti Intel® Core™ i7-6700	10/12 19:01	10/13 00:09	05:08
  DELL Latitude 7520 Intel® Core™ i7-1185G7 CPU	09/05 14:35	09/07 02:02	35:27
  HP EliteDesk 800 Intel® Core™ i7-6700 CPU	09/05 11:00	09/07 05:15	41:55

• ソースファイル
  
  ▼「chapt02_1w.py」
  ▲「chapt02_1w.py」

  # -*- coding: utf-8 -*-
  ##------------------------------------------
  ## 「PyTorch で始める AI開発」
  ##   Chapter 02 / Section 005
  ##       PyTorch による学習
  ##
  ##               2021.09.05 Masahiro Izutsu
  ##------------------------------------------
  ## chapt02_1w.py  (original: chapt02_1.py)
  ## for Windows10 anaconda
  
  import numpy as np
  import pandas as pd
  import itertools
  import shutil
  from PIL import Image
  import os
  
  import torch
  from torch import nn, utils, optim
  from torchvision import transforms, models
  from sklearn.metrics import f1_score, accuracy_score
  from sklearn.model_selection import train_test_split
  
  # GPUを使うかどうか
  USE_DEVICE = 'cuda:0' if torch.cuda.is_available() else 'cpu'
  
  # データがあるディレクトリ
  #INPUT_DIR = 'forest-path-movie-dataset/'
  INPUT_DIR = '../forest-path-movie-dataset/'     ## 2021.09.05
  
  # PyTorchの内部を決定論的に設定する
  torch.backends.cudnn.deterministic = True
  torch.backends.cudnn.benchmark = False
  
  # 乱数を初期化する関数
  def init_seed():
      np.random.seed(0)
      torch.manual_seed(0)
  
  # 一時ディレクトリを作成
  if not os.path.isdir('tmp'):
      os.mkdir('tmp')
  
  # データセットの定義ファイルを読み込む
  df = pd.read_csv(INPUT_DIR+'all_file.csv')
  
  # シーン毎に分割するので、groupbyして取り出す
  file, person = [], []
  for g in df.groupby(df.scene):
      file.append(g[1].file.values.tolist())
      person.append(g[1].person.values.tolist())
  
  # シーン毎に学習用と評価用データに分ける
  train_X, test_X, train_y, test_y = train_test_split(file, person, test_size=0.3, random_state=0)
  
  # 全てのシーン内のデータを繋げた配列にする
  train_X = sum(train_X, [])
  train_y = sum(train_y, [])
  test_X = sum(test_X, [])
  test_y = sum(test_y, [])
  
  # PyTorchの流儀でデータセットをクラスで定義する
  class MyDataset:
      def __init__(self, X, y, valid=False):
          # 初期化 Xはファイル名のリスト、yは人物が写っているかどうかのリスト
          self.X = X
          self.y = y
          if not valid: # 学習用ならDAを含んだtransoformを作る
              trans = [
                  transforms.Resize((224,224)),
                  transforms.ColorJitter(brightness=1.0),
                  transforms.RandomGrayscale(0.1),
                  transforms.ToTensor(),
                  transforms.RandomErasing(),
                  transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                   std=[0.229, 0.224, 0.225])
              ]
          else: # 評価時にはDAを含まないtransoformを作る
              trans = [
                  transforms.Resize((224,224)),
                  transforms.ToTensor(),
                  transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                       std=[0.229, 0.224, 0.225])
              ]
          self.trans = transforms.Compose(trans)
  
      def __len__(self):
          # データセットの長さを返す
          return len(self.X)
  
      def __getitem__(self, pos):
          # posの場所にあるデータを返す
          f = INPUT_DIR + self.X[pos] # ファイルパス
          X = Image.open(f) # ファイルを読み込む
          X = self.trans(X) # DAしてtensorにする
          y = self.y[pos]
          return X, y
  
  def get_model(): # ニューラルネットワークのモデルを返す関数
      # ModelZOOからモデルをダウンロードして最後の層だけを入れ替える
      model = models.resnet50(pretrained=True)
      model.fc = nn.Linear(2048, 2) # 出力の数＝2にする
      model = model.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
      return model
  
  def get_optim(model, lr): # 勾配降下法のアルゴリズムを返す関数
      params = model.parameters() # 学習させるパラメーター
      optimizer = optim.SGD(params, lr=lr,  momentum=0.9) # 学習率を設定
      return optimizer
  
  def get_loss(weight): # 損失関数を返す関数
      # 不均衡なデータを学習させるために、クラス毎のウェイトを設定する
      weight = torch.tensor([1.0-weight,weight], dtype=torch.float)
      weight = weight.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
      loss = nn.CrossEntropyLoss(weight=weight) # ウェイト付きのCrossEntropy
      return loss
  
  def get_score(true_valid, pred_valid): # 評価スコアを返す関数
      # 評価スコアは、全体の他に時間帯毎にも作成するのでディクショナリを用意する
      timezone = {'daytime':([],[]),'twilight':([],[]),'midnight':([],[])}
      # 認識結果を時間帯毎に仕分けする
      for i, filename in enumerate(test_X):
          w = df[df.file==filename].when.values[0]
          timezone[w][0].append(true_valid[i])
          timezone[w][1].append(pred_valid[i])
      # 時間帯毎のF1スコアをディクショナリに入れる
      score = {k:f1_score(v[0], v[1]) for k,v in timezone.items()}
      # 全体のF1スコアをディクショナリに入れる
      score['total'] = f1_score(true_valid, pred_valid)
      # 認識が極端に偏ってないか見るために、認識値の平均も求める
      score['average'] = np.mean(pred_valid)
      return score
  
  def main():
      # 学習時と評価時のバッチサイズ
      BATCH_SIZE = 16
      BATCH_SIZE_VALID = 4
      # データの読み込みスレッドの数
      NUM_WORKERS = 2
      # 試行時の学習エポック数
      NUM_EPOCHS = 3
      # 評価で試す学習率
      LR_TESTS = [1e-3,2e-4,5e-5]
      # 試すウェイトは、人物の方が分散が大きいので、クラス1側を0.5より少なくする
      WEIGHT_TESTS = [0.1,0.2,0.3,0.4,0.5]
  
      # 学習用と評価用にデータセットを作る
      train_ds = MyDataset(train_X, train_y)
      test_ds = MyDataset(test_X, test_y, True)
  
      # 複数スレッドでファイルを読み込みつつデータを取り出すDataLoaderを作る
      data_loader = utils.data.DataLoader(
          train_ds, batch_size=BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS)
      data_loader_v = utils.data.DataLoader(
          test_ds, batch_size=BATCH_SIZE_VALID, shuffle=False, num_workers=NUM_WORKERS)
  
      # 試行時の最も評価が良かったスコアのリスト
      best_scores = []
      # 学習率とウェイトを変えながら試行する
      for t, (lr, weight) in enumerate(itertools.product(LR_TESTS, WEIGHT_TESTS)):
          # 試行毎に乱数を初期化してからニューラルネットワークを作成する
          init_seed()
          model = get_model() # ニューラルネットワークを作成
          # 学習のためのアルゴリズムを取得
          optimizer = get_optim(model, lr)
          loss = get_loss(weight)
  
          # 現在の学習率とウェイトで試行する
          print(f'test #{t} lr={lr} weight={weight}')
          scores = [] # 各エポック終了時のスコア
  
          # 学習ループ
          for epoch in range(NUM_EPOCHS):
              total_loss = [] # 各バッチ実行時の損失値
              model.train() # モデルを学習用に設定する
              for X, y in data_loader: # 画像を読み込んでtensorにする
                  X = X.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
                  y = y.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
  
                  # ニューラルネットワークを実行して損失値を求める
                  losses = loss(model(X), y)
  
                  # 新しいバッチ分の学習を行う
                  optimizer.zero_grad() # 一つ前の勾配をクリア
                  losses.backward() # 損失値を逆伝播させる
                  optimizer.step() # 新しい勾配からパラメーターを更新する
  
                  # 損失値を保存しておく
                  total_loss.append(losses.detach().cpu().numpy())
  
              # 評価
              with torch.no_grad():
                  # 評価時の損失値と正解/認識結果を入れるリスト
                  total_loss_v = []
                  true_valid = []
                  pred_valid = []
  
                  model.eval() # モデルを推論用に設定する
                  for i, (X, y) in enumerate(data_loader_v):
                      X = X.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
                      y = y.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
  
                      res = model(X) # ニューラルネットワークの実行
                      losses = loss(res, y) # 評価データの損失値
  
                      # 正解データを保存
                      y = y.detach().cpu().numpy() # CPUメモリに入れてnumpy化
                      true_valid.extend(y.tolist())
                      # 認識結果を保存
                      res = res.detach().cpu().numpy() # CPUメモリに入れてnumpy化
                      pred_valid.extend(res.argmax(axis=1).tolist())
  
                      # 損失値を保存しておく
                      total_loss_v.append(losses.detach().cpu().numpy())
  
              # エポック終了時のスコアを求める
              total_loss = np.mean(total_loss) # 各バッチの損失の平均
              total_loss_v = np.mean(total_loss_v) # 各バッチの損失の平均
              score = get_score(true_valid, pred_valid) # 評価スコア
              scores.append(score['total']) # スコアを保存しておく
              # エポック終了時のスコアを表示する
              print(f'epoch #{epoch}: train_loss:{total_loss} valid_loss:{total_loss_v} score:{score}')
              # エポック終了時のモデルを保存しておく
              torch.save(model.state_dict(), f'tmp/checkpoint{epoch}.pth')
  
          # 現在の学習率とウェイトで最も良かったモデルをコピーして保存しておく
          best_epoch = np.argmax(scores)
          shutil.copyfile(f'tmp/checkpoint{best_epoch}.pth',f'tmp/test{t}_best.pth')
          # 現在の学習率とウェイトで最も良かったモデルを損失値しておく
          best_scores.append(scores[best_epoch])
  
          # GPUメモリをGCする
          del model, optimizer, loss, X, y, res, losses
          torch.cuda.empty_cache()
  
      # 最も良かった学習率とウェイトでのモデルをコピーする
      best_of_best = np.argmax(best_scores)
      shutil.copyfile(f'tmp/test{best_of_best}_best.pth', 'chapt02-model1.pth')
  
      # 一時ディレクトリを削除
      shutil.rmtree('tmp')
  
  if __name__ == '__main__':
      main()

CHAPTER 05 動画の背景を入れ替える / SECTION 014 転移学習によるモデルの作成 †

• 実行結果

  (py37) cd \workspace_py37\chapter05
  (py37) >　date /t
  2021/10/14
  (py37) > time /t
  05:05
  (py37) > python chapt05_2w.py
  Using cache found in C:\Users\izuts/.cache\torch\hub\pytorch_vision_v0.6.0
  100%|██████████████████████████████████| 11294/11294 [5:56:55<00:00,  1.90s/it]
  epoch #0: train_loss:0.14030972123146057
  100%|██████████████████████████████████| 11294/11294 [5:56:12<00:00,  1.89s/it]
  epoch #1: train_loss:0.1263476312160492
  100%|██████████████████████████████████| 11294/11294 [5:52:53<00:00,  1.87s/it]
  epoch #2: train_loss:0.12263970822095871
  100%|██████████████████████████████████| 11294/11294 [5:52:45<00:00,  1.87s/it]
  epoch #3: train_loss:0.12062573432922363
  100%|██████████████████████████████████| 11294/11294 [5:53:30<00:00,  1.88s/it]
  epoch #4: train_loss:0.11797807365655899
  100%|██████████████████████████████████| 11294/11294 [5:54:05<00:00,  1.88s/it]
  epoch #5: train_loss:0.11718424409627914
  100%|██████████████████████████████████| 11294/11294 [5:53:51<00:00,  1.88s/it]
  epoch #6: train_loss:0.11532850563526154
  100%|██████████████████████████████████| 11294/11294 [5:52:37<00:00,  1.87s/it]
  epoch #7: train_loss:0.11388455331325531
  
  (py37) > dir
   ドライブ N のボリューム ラベルは WORK1 です
   ボリューム シリアル番号は 8008-71B6 です
  
   \workspace_py37\chapter05 のディレクトリ
  
  2021/10/12  18:58    <DIR>          .
  2021/10/12  18:58    <DIR>          ..
  2021/10/12  15:51    <DIR>          annotations
  2021/10/16  04:18       244,646,735 chapt05-model1.pth
  2021/09/22  04:50             1,889 chapt05_1a.py
  2021/09/22  05:38             4,015 chapt05_2a.py
  2021/10/12  19:01             4,277 chapt05_2w.py
  2021/10/03  16:47             5,070 chapt05_3a.py
  2021/10/04  10:11        10,806,542 chapt05_output.avi
  2021/10/12  16:04    <DIR>          imgs
  2021/10/12  16:11    <DIR>          mask
  2021/10/12  16:44    <DIR>          train2014
                 6 個のファイル         255,468,528 バイト
                 6 個のディレクトリ  1,438,868,893,696 バイトの空き領域

• 学習にかかった時間

  機種	開始日時	終了日時	処理時間 (h:m)
  GeForce GTX 1050 Ti Intel® Core™ i7-6700	10/14 05:05	10/16 04:18	46:47
  Intel® NUC BXNUC10I5FNH Core™ i5-10210U CPU	09/27 19:40	10/04 09:12	157:30
  DELL Latitude 7520 Intel® Core™ i7-1185G7 CPU	09/26 10:36	10/05 07:20	212:36

• ソースファイル
  
  ▼「chapt05_2w.py」
  ▲「chapt05_2w.py」

  # -*- coding: utf-8 -*-
  ##------------------------------------------
  ## 「PyTorch で始める AI開発」
  ##   Chapter 05 / Section 014
  ##   動画の背景を入れ替える/モデルの作成
  ##
  ##               2021.09.23 Masahiro Izutsu
  ##------------------------------------------
  ## chapt05_2w.py  (original: chapt05_2.py)
  ## for Windows10 anaconda
  
  import numpy as np
  import os
  from PIL import Image
  from tqdm import tqdm
  import glob
  import torch
  import torch.nn as nn
  import torch.nn.functional as F
  from torchvision import transforms
  from torchvision.models.segmentation import deeplabv3
  
  # GPUを使うかどうか
  USE_DEVICE = 'cuda:0' if torch.cuda.is_available() else 'cpu'
  
  # PyTorchの内部を決定論的に設定する
  torch.backends.cudnn.deterministic = True
  torch.backends.cudnn.benchmark = False
  
  # 乱数を初期化する
  np.random.seed(0)
  torch.manual_seed(0)
  
  # PyTorchの流儀でデータセットをクラスで定義する
  class MyDataset(object):
      def __init__(self):
          # ファイルの一覧
          self.filelist = os.listdir('imgs/')
          # 画像用のtransform
          self.trans1 = transforms.Compose([
              transforms.ToTensor(),
              transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                   std=[0.229, 0.224, 0.225])
          ])
          # マスク画像用のtransform
          self.trans2 = transforms.ToTensor()
  
      def __getitem__(self, idx):
          # 画像とマスク画像を読み込む
          img = Image.open('imgs/' + self.filelist[idx])
          msk = Image.open('mask/' + self.filelist[idx])
          # 画像をTensorにする
          img = self.trans1(img)
          msk = self.trans2(msk) # ToTensorは0〜1の範囲にする
          # 画像をマスク画像を返す
          return img, msk
  
      def __len__(self):
          return len(self.filelist)
  
  def main():
      # 学習で使用するニューラルネットワーク
      model = torch.hub.load('pytorch/vision:v0.6.0',
                  'deeplabv3_resnet101', pretrained=True)
      # 出力層のチャンネル数を1にする
      model.classifier = deeplabv3.DeepLabHead(2048, 1)
      # GPUを使う場合はGPUメモリに乗せる
      model.to(USE_DEVICE)
  
      # 出力層のみ学習する
      params = model.classifier.parameters()
      optimizer = torch.optim.SGD(params, lr=0.001,  momentum=0.9)
  
      # 損失関数を用意する
      loss = nn.BCELoss() # バイナリクロスエントロピー
  
      # 学習時のバッチサイズ
      BATCH_SIZE = 4
      # データの読み込みスレッドの数
      NUM_WORKERS = 2
      # 学習エポック数
      NUM_EPOCHS = 8
  
      # データセットの読み込みクラス
      dataset = MyDataset()
      # 別スレッドでデータを読み込む
      data_loader = torch.utils.data.DataLoader(
          dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS)
  
      # 学習ループ
      for epoch in range(NUM_EPOCHS):
          total_loss = [] # 各バッチ実行時の損失値
          model.train() # モデルを学習用に設定する
          for X, y in tqdm(data_loader): # 画像を読み込んでtensorにする
              X = X.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
              y = y.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
  
              # ニューラルネットワークを実行して損失値を求める
              out = model(X)
              out = torch.sigmoid(out['out'])
              losses = loss(out, y)
  
              # 新しいバッチ分の学習を行う
              optimizer.zero_grad() # 一つ前の勾配をクリア
              losses.backward() # 損失値を逆伝播させる
              optimizer.step() # 新しい勾配からパラメーターを更新する
  
              # 損失値を保存しておく
              total_loss.append(losses.detach().cpu().numpy())
  
          # エポック終了時のスコアを求める
          total_loss = np.mean(total_loss) # 各バッチの損失の平均
          # エポック終了時のスコアを表示する
          print(f'epoch #{epoch}: train_loss:{total_loss}')
  
      # 最終的なモデルを保存する
      torch.save(model.state_dict(), 'chapt05-model1.pth')
  
  if __name__ == '__main__':
      main()

CHAPTER 07 線画をイラストに変換する / SECTION-020 Pix2Pix のトレーニング †

• 実行結果
  ・CPU (Intel® Core™ i7-1185G7)
  

  (py37) > cd ~/workspace_py37/chapter07
  (py37) $ date
  2021年 10月 24日 日曜日 09:57:43 JST
  (py37) $ python3 chapt07_1a.py
      :
  100%|█████████████████████████████████████| 1590/1590 [4:57:35<00:00, 11.23s/it]
  epoch #0: train_loss:4.0809502601623535
  100%|█████████████████████████████████████| 1590/1590 [4:58:51<00:00, 11.28s/it]
  epoch #1: train_loss:4.114153861999512
      :
  100%|█████████████████████████████████████| 1590/1590 [5:03:13<00:00, 11.44s/it]
  epoch #48: train_loss:3.2765839099884033
  100%|█████████████████████████████████████| 1590/1590 [5:03:24<00:00, 11.45s/it]
  epoch #49: train_loss:3.271886110305786
  Model saved with cpu 'chapt07-model.pth' at 'checkpoints/line2illust/'

  ※ 時間がかかるので、バッチサイズ 4 → 40 に変更。エポック数 50 で実行。
  
  ・GPU (GeForce GTX 1050 Ti)
  

  (py37) > cd \workspace_py37\chapter07
  (py37) > python chapt07_1b.py
      :
  100%|██████████████████████████████████| 31785/31785 [3:05:38<00:00,  2.85it/s]
  epoch #9: train_loss:3.872145175933838
  Model saved with GPU 'chapt07-model.pth' at 'checkpoints/line2illust/'

  ※ 時間がかかりそうなので、エポック回数10で実行。GPUボードのメモリー(4GB)のためバッチサイズは 2とする。
  
  
• 学習にかかった時間

  機種	開始日時	終了日時	処理時間 (h:m)
  Intel® NUC BXNUC10I5FNH Core™ i5-10210U CPU	10/24 09:57	11/03 21:36	251:21
  ※GeForce GTX 1050 Ti Intel® Core™ i7-6700	11/07 17:57	11/09 01:47	30:50

• ソースファイル
  ※ ループ処理を main() 関数内で処理するようにしたため修正不要。
  
  ▼「chapt07_1a.py」
  ▲「chapt07_1a.py」

  # -*- coding: utf-8 -*-
  ##------------------------------------------
  ## 「PyTorch で始める AI開発」
  ##   Chapter 07 / Section 020
  ##   線画をイラストに変換する/Pix2Pixのトレーニング
  ##
  ##               2021.09.27 Masahiro Izutsu
  ##------------------------------------------
  ## chapt07_1a.py  (original: chapt07_1.py)
  ## 2021/10/20 cpu/gpu対応
  
  import numpy as np
  import os
  import sys
  import cv2
  from PIL import Image
  from tqdm import tqdm
  import glob
  import torch
  import torch.nn as nn
  import torch.nn.functional as F
  from torchvision import transforms
  
  # Pix2PixHDのコードのものを使う
  from options.train_options import TrainOptions
  from models.models import create_model
  
  # GPUを使うかどうか
  USE_DEVICE = 'cuda:0' if torch.cuda.is_available() else 'cpu'
  
  # PyTorchの内部を決定論的に設定する
  torch.backends.cudnn.deterministic = True
  torch.backends.cudnn.benchmark = False
  
  # 乱数を初期化する
  np.random.seed(0)
  torch.manual_seed(0)
  
  if not torch.cuda.is_available(): # Pix2PixHDのオプションを上書き
      sys.argv.append('--gpu_ids')
      sys.argv.append('-1')
  
  # 画像のサイズ
  IMG_SIZE = 64
  
  # PyTorchの流儀でデータセットをクラスで定義する
  class MyDataset(object):
      def __init__(self):
          # ファイルの一覧
          self.filelist = [f for f in os.listdir('cropped/')
                              if os.path.getsize('cropped/'+f) > 0]
          # イラストのtransform
          self.trans = transforms.Compose([
                  transforms.RandomApply([
                      transforms.ColorJitter(brightness=0.5,
                          contrast=0.5, saturation=0.5),
                  ], 0.5),
                  transforms.RandomGrayscale(0.1),
                  transforms.ToTensor(),
              ])
  
      def __getitem__(self, idx):
          # イラスト画像を読み込む
          img = Image.open('cropped/' + self.filelist[idx])
          img = img.resize((IMG_SIZE, IMG_SIZE))
          # 線画を作成する
          threshold = np.random.randint(300)+400 # 閾値をランダムに選択する
          glimg = img.convert('L') # 白黒画像へ
          cvimg = np.array(glimg, dtype=np.uint8) # OpenCVの画像へ
          cvimg = cv2.Canny(cvimg, threshold, threshold) # 線画へ
          cvimg = (cvimg > 0).astype(np.int32) # 0か1かにする
          cvimg = cvimg.reshape((1, IMG_SIZE, IMG_SIZE))
          # 線画とイラストのペアを返す
          return torch.tensor(cvimg), self.trans(img)
  
      def __len__(self):
          return len(self.filelist)
  
  # Pix2PixHDのデフォルトオプションを上書きする
  opt = TrainOptions().parse()
  opt.name = 'line2illust' # 保存するモデルのディレクトリ名
  opt.label_nc = 2 # 入力は2値のラベル
  opt.no_instance = True # featmapは使わない
  
  # モデルの保存場所を作る
  if not os.path.isdir('checkpoints/line2illust'):
      os.mkdir('checkpoints/line2illust')
  
  # Pix2PixHDのモデルを作る
  model = create_model(opt)
  model = model.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
  model.train() # モデルを学習用に設定する
  
  def main():
      # 学習時のバッチサイズ
      BATCH_SIZE = 2  # 大きい方が良いがGPUメモリに依存
      # データの読み込みスレッドの数
      NUM_WORKERS = 2
      # 学習エポック数
      NUM_EPOCHS = 10
  
      # データセットの読み込みクラス
      dataset = MyDataset()
      # 別スレッドでデータを読み込む
      data_loader = torch.utils.data.DataLoader(
          dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS)
  
      # OptimizerはPix2PixHDが用意してくれるものを使う
      if USE_DEVICE == 'cpu':
          optimizer_G, optimizer_D = model.optimizer_G, model.optimizer_D
      else:
          optimizer_G, optimizer_D = model.module.optimizer_G, model.module.optimizer_D
  
      # 学習ループ
      for epoch in range(NUM_EPOCHS):
          total_loss = [] # 各バッチ実行時の損失値
          for X, y in tqdm(data_loader): # 画像を読み込んでtensorにする
              X = X.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
              y = y.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
  
              # モデルを実行する
              losses, generated = model(X, 0, y, 0)
  
              # GANの損失を求める
              losses = [ torch.mean(x) if not isinstance(x, int) else x for x in losses ]
              if USE_DEVICE == 'cpu':
                  loss_dict = dict(zip(model.loss_names, losses))
              else:
                  loss_dict = dict(zip(model.module.loss_names, losses))
              loss_D = (loss_dict['D_fake'] + loss_dict['D_real']) * 0.5
              loss_G = loss_dict['G_GAN'] + loss_dict.get('G_GAN_Feat',0) + loss_dict.get('G_VGG',0)
  
              # G-Netを逆伝播する
              optimizer_G.zero_grad()
              loss_G.backward()
              optimizer_G.step()
  
              # D-Netを逆伝播する
              optimizer_D.zero_grad()
              loss_D.backward()
              optimizer_D.step()
  
              # 全ての損失の平均値を求める
              loss = sum(losses) / len(losses)
              # 損失値を保存しておく
              total_loss.append(loss.detach().cpu().numpy())
  
          # エポック終了時のスコアを求める
          total_loss = np.mean(total_loss) # 各バッチの損失の平均
          # エポック終了時のスコアを表示する
          print(f'epoch #{epoch}: train_loss:{total_loss}')
  
      # 最終的なモデルを保存する
      if USE_DEVICE == 'cpu':
          model.save('chapt07-model.pth')
          print("Model saved with cpu 'chapt07-model.pth' at 'checkpoints/line2illust/'")
      else:
          model.module.save('chapt07-model.pth')
          print("Model saved with GPU 'chapt07-model.pth' at 'checkpoints/line2illust/'")
  
  if __name__ == '__main__':
      main()

CHAPTER 08 OCR における文字認識 / SECTION-024 モデルを学習させる †

• 実行結果
  ・GPU (GeForce GTX 1050 Ti)
  

  (py37) > cd \workspace_py37\chapter08
  (py37) > python chapt08_1w.py
  100%|█████████████████████████████████████████| 20/20 [33:30<00:00, 100.54s/it]

  ・CPU (Intel® Core™ i7-1185G7)
  

  (py37) $ cd \workspace_py37\chapter08
  (py37) $ python3 chapt08_1a.py 
  100%|██████████████████████████████████████| 20/20 [49:23:56<00:00, 8891.84s/it]

• 学習にかかった時間

  機種	開始日時	終了日時	処理時間 (h:m)
  GeForce GTX 1050 Ti Intel® Core™ i7-6700	10/13 04:31	10/13 05:05	00:34
  DELL Latitude 7520 Intel® Core™ i7-1185G7 CPU	10/13 12:50	10/15 15:14	49:24

• ソースファイル
  
  ▼「chapt08_1w.py」
  ▲「chapt08_1w.py」

  # -*- coding: utf-8 -*-
  ##------------------------------------------
  ## 「PyTorch で始める AI開発」
  ##   Chapter 08 / Section 024
  ##   OCRにおける文字認識/モデルを学習させる
  ##
  ##               2021.10.11 Masahiro Izutsu
  ##------------------------------------------
  ## chapt08_1w.py  (original: chapt08_1.py)
  ## for Windows10 anaconda
  
  import os
  import numpy as np
  from tqdm import tqdm
  from PIL import Image, ImageFont, ImageDraw
  import torch
  import torch.nn as nn
  from torchvision import transforms
  
  from nets.classifiernet import get_classifiernet
  from misc.nihongo import nihongo_class
  
  # GPUを使うかどうか
  USE_DEVICE = 'cuda:0' if torch.cuda.is_available() else 'cpu'
  IMAGE_SIZE = 56 # 文字画像のサイズ
  BATCH_SIZE = 16 # 学習時のバッチサイズ
  NUM_WORKERS = 4 # 読み込みスレッド数
  NUM_EPOCHS = 20 # 学習エポック数
  
  # PyTorchの内部を決定論的に設定する
  torch.backends.cudnn.deterministic = True
  torch.backends.cudnn.benchmark = False
  
  # 乱数を初期化する
  np.random.seed(0)
  torch.manual_seed(0)
  
  # フォントを読み込む
  font_path = os.listdir('fonts/') # フォントファイルのリスト
  ttf_fonts = [ImageFont.truetype('fonts/'+fp, 56) for fp in font_path]
  
  # 文字部分のみを切り出すtransform
  class CharactorCrop(nn.Module):
      def __init__(self):
          super().__init__()
      def forward(self, img):
          # Numpyにする
          aimg = np.array(img)
          where = np.where(aimg < 128) # 文字が書かれているピクセルの場所
          # 文字が書かれた部分を切り出す
          if len(where[0]) > 0 and len(where[1]) > 1:
              _x1,_x2 = min(where[1]),max(where[1])
              _y1,_y2 = min(where[0]),max(where[0])
              x1 = max(0,_x1-1)
              y1 = max(0,_y1-1)
              x2 = min(_x2+1,aimg.shape[1])
              y2 = min(_y2+1,aimg.shape[0])
              aimg = aimg[y1:y2,x1:x2]
          # ０から１の値にする
          aimg = np.clip(aimg, 0, 255).astype(np.float32) / 255.
          # 1チャンネルの画像Tensorにする
          aimg = aimg.reshape((1,aimg.shape[0],aimg.shape[1]))
          return torch.tensor(aimg, dtype=torch.float32)
  
  # 文字画像を生成して返すクラス
  class MyDataset(object):
      def __init__(self):
          # DAを行うtransforms
          self.trans = transforms.Compose([
              transforms.RandomRotation(degrees=15, fill=255),
              transforms.RandomPerspective(p=1.0, fill=255),
              CharactorCrop(), # 文字の場所だけ切り出す
              transforms.Resize((IMAGE_SIZE,IMAGE_SIZE)),
          ])
  
      def __getitem__(self, idx):
          # 文字画像を生成して返す
          word_class = idx // len(ttf_fonts)
          ttf_font = ttf_fonts[idx % len(ttf_fonts)]
          if word_class == 0:  # not a word
              message = '■' # 「文字ではない」クラスで使用する文字
          else:
              message = nihongo_class[word_class] # 文字
          # 画像に文字を書く
          bgcolor = np.random.randint(128) + 127 # 背景色
          fgcolor = np.random.randint(128) # 文字色
          img = Image.new(size=(128,128), mode='L', color=bgcolor)
          draw = ImageDraw.Draw(img)
          draw.text((30,30), message, font=ttf_font, fill=fgcolor)
          # 画像とクラスを返す
          return self.trans(img), torch.tensor(word_class, dtype=torch.int64)
  
      def __len__(self):
          # フォントファイル数×文字数
          return len(nihongo_class) * len(ttf_fonts)
  
  def main():
      # OCRプログラムに合わせたクラス数でモデルを作る
      model = get_classifiernet(len(nihongo_class) + 2)
      # 学習済みモデルをファインチューニングする
      model.load_state_dict(torch.load('classifiernet_orig.model', map_location=torch.device(USE_DEVICE)))
      model.to(USE_DEVICE) # GPUを使うときはGPUメモリに乗せる
      model.train() # モデルを学習用に設定する
  
      # 学習の準備
      optimizer = torch.optim.Adam(model.parameters(), lr=2e-5)
      loss = nn.CrossEntropyLoss()
  
      # データセットの作成
      dataset = MyDataset()
      # 別スレッドでデータを読み込む
      data_loader = torch.utils.data.DataLoader(
          dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS)
  
      # 学習ループ
      for epoch in tqdm(range(NUM_EPOCHS)):
          for X, y in data_loader: # 画像を読み込んでtensorにする
              X = X.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
              y = y.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
  
              # ニューラルネットワークを実行
              res = model(X)
              # 合計の損失値を求める
              losses = loss(res, y)
  
              # 新しいバッチ分の学習を行う
              optimizer.zero_grad() # 一つ前の勾配をクリア
              losses.backward() # 損失値を逆伝播させる
              optimizer.step() # 新しい勾配からパラメーターを更新する
  
      # 最終的なモデルを保存する
      torch.save(model.state_dict(), 'chapt08-model1.pth')
  
  if __name__ == '__main__':
      main()

CHAPTER 09 OCR を完成させる / SECTION-027 モデルを学習させる †

• 実行~結果
  ・GPU (GeForce GTX 1050 Ti)
  

  (py37) > cd ~\workspace_py37\chapter09
  (py37) > python3 chapt09_1a.py 
  100%|███████████████████████████████| 100000/100000 [28:34:11<00:00,  1.03s/it]

  ・CPU (Intel® Core™ i7-1185G7)
  

  (py37) $ cd ~/workspace_py37/chapter09
  (py37) $ python3 chapt09_1a.py 
    0%|                                   | 11/100000 [01:19<199:44:48,  7.19s/it]
      :

• 学習にかかった時間

  機種	開始日時	終了日時	処理時間 (h:m)
  GeForce GTX 1050 Ti Intel® Core™ i7-6700	10/17 09:30	10/18 13:05	27:35
  DELL Latitude 7520 Intel® Core™ i7-1185G7 CPU	--/-- --:--	--/-- --:--	--:--

• ソースファイル
  ※ ループ処理を main() 関数内で処理するようにしたため修正不要。
  
  ▼「chapt09_1a.py」
  ▲「chapt09_1a.py」

  # -*- coding: utf-8 -*-
  ##------------------------------------------
  ## 「PyTorch で始める AI開発」
  ##   Chapter 09 / Section 027
  ##   OCRを完成させる/横書き専用モデルを学習させる
  ##
  ##               2021.10.17 Masahiro Izutsu
  ##------------------------------------------
  ## chapt08_19.py  (original: chapt09_1.py)
  
  import os
  import numpy as np
  from tqdm import tqdm
  from PIL import Image, ImageFont, ImageDraw
  import itertools
  import cv2
  import torch
  import torch.nn as nn
  from torchvision import transforms
  
  from nets.detectionnet import get_detectionnet
  from misc.nihongo import nihongo, hiragana, katakana, jyouyou_kanji
  
  # GPUを使うかどうか
  USE_DEVICE = 'cuda:0' if torch.cuda.is_available() else 'cpu'
  IMAGE_SIZE = 512 # 画像のサイズ
  BATCH_SIZE = 2 # 学習時のバッチサイズ
  NUM_WORKERS = 4 # 読み込みスレッド数
  NUM_ITERATIONS = 200000 # 学習回数
  
  # PyTorchの内部を決定論的に設定する
  torch.backends.cudnn.deterministic = True
  torch.backends.cudnn.benchmark = False
  
  # 乱数を初期化する
  np.random.seed(0)
  torch.manual_seed(0)
  
  # フォントを読み込む
  font_path = os.listdir('fonts/') # フォントファイルのリスト
  font_size = [9,14,20,26,32,48] # 使用するフォントサイズ
  ttf_fonts = [(ImageFont.truetype('fonts/'+fp, fs),fs)
                  for fp,fs in itertools.product(font_path, font_size)]
  
  # 文を構成する文字のクラス
  char_classes = (nihongo, hiragana, katakana, jyouyou_kanji)
  
  # 一行の文字列を描写する関数
  def draw_line(img, draw, heatmap, offset_w, offset_h, sentence, y_pos):
      # ランダムにフォントと前景色を作成する
      font, cur_size = ttf_fonts[np.random.randint(len(ttf_fonts))]
      fgcolor = np.random.randint(128) # 前景色
      sentsize = np.random.randint(5) + 5 # 描写する文字数
      # 行を描写する位置
      x_pos = max(1,IMAGE_SIZE-sentsize*cur_size*2)
      x_pos = np.random.randint(x_pos) # ランダムな開始位置
      mx1,mx2,my1,my2 = -1,-1,-1,-1 # 文字を書いた矩形
      sentheight = 0 # 描写した行の高さ
      img_org = np.array(img) # 一文字描写する前の画像
      char_class = char_classes[np.random.randint(len(char_classes))] # 文字クラス
      # 一行描写する
      for i in range(sentsize): # 文字数分だけ
          # ランダムな文字を描写する
          char = char_class[np.random.randint(len(char_class))]
          draw.text((x_pos,y_pos), char, font=font, fill=fgcolor)
          aimg = np.array(img)
          where = np.where((img_org - aimg) != 0) # 画像の変わったところ
          img_org = aimg # 前の画像
          if len(where[0]) > 0 and len(where[1]) > 0:
              # 画像の変わったところの位置を得る
              y1,y2,x1,x2 = (min(where[0])//2, max(where[0])//2,
                              min(where[1])//2, max(where[1])//2)
              width = x2 - x1 # 描写した文字の幅
              height = y2 - y1 # 描写した文字の高さ
              x_c = (x1 + x2) / 2 # 描写した文字の中央位置
              y_c = (y1 + y2) / 2 # 描写した文字の中央位置
              if width > 0 and height > 0:
                  # 文字である可能性を表すヒートマップ画像
                  heatmap += ((np.exp(-(((np.arange(IMAGE_SIZE//2)-x_c) /
                                      (width/10))**2)/2)).reshape(1,-1) *
                              (np.exp(-(((np.arange(IMAGE_SIZE//2)-y_c) /
                                      (height/10))**2)/2)).reshape(-1,1))
                  # 文字の大きさを表す画像
                  offset_w[y1:y2,x1:x2] = width / IMAGE_SIZE
                  offset_h[y1:y2,x1:x2] = height / IMAGE_SIZE
              if i == 0: # 最初の文字
                  mx1,my1 = int(np.round(x_c)),int(np.round(y_c))
              mx2,my2 = int(np.round(x_c)),int(np.round(y_c))
              sentheight = max(sentheight, height) # 行の高さ
              x_pos += width + cur_size
      if sentheight > 1 and min(mx1,mx2,my1,my2) >= 0:
          # 文字列であることを表すヒートマップ画像
          for w in 1.0 - np.exp(-(((np.arange(sentheight)/2.4))**2)/2)[::-1]:
              lw = int(np.round(w*sentheight/4))+1
              cv2.line(sentence,(mx1,my1),(mx2,my2),
                          int(np.round(255-255*w)),lw,cv2.LINE_AA)
      return y_pos + cur_size * 2
  
  # 学習データを一枚作る関数
  def make_image():
      min_fontsize = font_size[0]
      max_fontsize = font_size[-1]
      # 画像に文字を書く
      bgcolor = np.random.randint(128) + 127 # 背景色
      # 文字を書く画像はPillowのImageで作る
      img = Image.new(size=(IMAGE_SIZE,IMAGE_SIZE), mode='L', color=bgcolor)
      draw = ImageDraw.Draw(img)
      # 出力画像はNumpyの配列で作る
      heatmap = np.zeros((IMAGE_SIZE//2,IMAGE_SIZE//2))
      offset_w = np.zeros((IMAGE_SIZE//2,IMAGE_SIZE//2))
      offset_h = np.zeros((IMAGE_SIZE//2,IMAGE_SIZE//2))
      sentence = np.zeros((IMAGE_SIZE//2,IMAGE_SIZE//2))
      # Y座標を増やしながら横書き文字列を描写してゆく
      y_pos = min_fontsize
      while y_pos < IMAGE_SIZE - max_fontsize:
          y_pos = draw_line(img, draw, heatmap, offset_w, offset_h,
                              sentence, y_pos)
      sentence = sentence/255 # 0から1の値の範囲にする
      img = np.array(img, dtype=np.uint8)
      return img, heatmap, sentence, offset_w, offset_h
  
  # 正弦波のリスト
  def make_wave(start_phase, end_phase, num):
      return [np.sin(p) for p in np.linspace(start_phase, end_phase, num)]
  # 2次元の歪み座標マップを作る関数
  def make_rnd_matwave(x_shape, y_shape, size, n_wave):
      dst = np.ones((y_shape, x_shape), dtype=np.int32)
      # ランダムな位相の正弦波を3つ作る
      w1 = make_wave(n_wave*np.pi*np.random.random(),
                      n_wave*np.pi*np.random.random(),y_shape)
      w2 = make_wave(n_wave*np.pi*np.random.random(),
                      n_wave*np.pi*np.random.random(),y_shape)
      w3 = make_wave(n_wave*np.pi*np.random.random(),
                      n_wave*np.pi*np.random.random(),y_shape)
      # 正弦波を組み合わせて歪みの座標を作る
      for y, (sp, ep, s) in enumerate(zip(w1,w2,w3)):
          # 開始位相と終了位相が変化してゆく正弦波
          d = np.array(make_wave(n_wave*np.pi*sp,n_wave*np.pi*ep,x_shape))
          # 波の大きさが変化してゆく正弦波
          d *= (s * y_shape * size)
          # 場所に対する出力座標にする
          d -= np.linspace(d[0], d[-1], x_shape)
          d = np.round(d)
          d += np.arange(x_shape)
          d = d.astype(np.int32)
          d = np.clip(d, 0, x_shape-1)
          dst[y,:] = d # 入力座標に対する歪んだ座標のマップ
      return dst
  # 正弦波の組み合わせから2次元の歪み座標を作っておく
  tmp_wave = [make_rnd_matwave(512, 512,
                  size=np.random.random()*0.12, n_wave=1.2)
              for _ in range(10)]
  
  # 画像にランダムなノイズを入れる関数
  def _rnd_noize_img(img, scale=15):
      scale = np.random.random() * scale
      # ノイズの大きさを3段階で作る
      a = np.random.normal(loc=0.0, scale=scale,
                          size=(img.shape[0]//4,img.shape[1]//4))
      b = np.random.normal(loc=0.0, scale=scale,
                          size=(img.shape[0]//2,img.shape[1]//2))
      c = np.random.normal(loc=0.0, scale=scale,
                          size=(img.shape[0],img.shape[1]))
      a = cv2.resize(a, (img.shape[0],img.shape[1]),
                          interpolation=cv2.INTER_CUBIC)
      b = cv2.resize(b, (img.shape[0],img.shape[1]),
                          interpolation=cv2.INTER_CUBIC)
      return img + a + b + c # すべて足し合わせる
  
  # 画像をリサイズして配置する関数
  def _clip_img(img, scale=0.9):
      dst = np.zeros(img.shape)
      img = cv2.resize(img, (int(img.shape[1]*scale),
                      int(img.shape[0]*scale)))
      dst[:img.shape[0],:img.shape[1]] = img
      return dst
  
  # 文字画像を生成して返すクラス
  class MyDataset(object):
      def __init__(self):
          pass
  
      def __getitem__(self, idx):
          # 画像を作る
          _img, _heat, _sent, _offw, _offh = make_image()
          # 歪みを入れる
          y_wave = tmp_wave[np.random.randint(len(tmp_wave))]
          x_wave = tmp_wave[np.random.randint(len(tmp_wave))]
          img = _img.copy()
          heat = _heat.copy()
          sent = _sent.copy()
          offw = _offw.copy()
          offh = _offh.copy()
          for x in range(IMAGE_SIZE):
              img[:,x] = _img[y_wave[x,:],x_wave[:,x]]
          y_wave = cv2.resize(y_wave, (IMAGE_SIZE//2, IMAGE_SIZE//2),
                              interpolation=cv2.INTER_NEAREST)
          x_wave = cv2.resize(x_wave, (IMAGE_SIZE//2, IMAGE_SIZE//2),
                              interpolation=cv2.INTER_NEAREST)
          for x in range(IMAGE_SIZE//2):
              heat[:,x] = _heat[y_wave[x,:]//2,x_wave[:,x]//2]
              sent[:,x] = _sent[y_wave[x,:]//2,x_wave[:,x]//2]
              offw[:,x] = _offw[y_wave[x,:]//2,x_wave[:,x]//2]
              offh[:,x] = _offh[y_wave[x,:]//2,x_wave[:,x]//2]
          # ランダムなノイズを入れる
          img = _rnd_noize_img(img)
          # ランダムにリサイズしてクリップ
          scale = 0.9 + np.random.random() * 0.1
          img = _clip_img(img, scale)
          heat = _clip_img(heat, scale)
          sent = _clip_img(sent, scale)
          offw = _clip_img(offw, scale)
          offh = _clip_img(offh, scale)
          # チャンネルが先に来る形にする
          img = img.reshape((1,img.shape[0],img.shape[1]))
          heat = heat.reshape((1,heat.shape[0],heat.shape[1]))
          sent = sent.reshape((1,sent.shape[0],sent.shape[1]))
          # サイズは2チャンネルなので積み重ねる
          of_size = np.stack([offw,offh]).astype(np.float32)
          # 0~1の範囲にする
          img = np.clip(img / 255, 0.0, 1.0)
          heat = np.clip(heat, 0.0, 1.0)
          sent = np.clip(sent, 0.0, 1.0)
          of_size = np.clip(of_size, 0.01, 0.1)  # 5~50px
          # PyTorchのTensorにする
          img = torch.tensor(img, dtype=torch.float32)
          heat = torch.tensor(heat, dtype=torch.float32)
          sent = torch.tensor(sent, dtype=torch.float32)
          of_size = torch.tensor(of_size, dtype=torch.float32)
          # Tensorを返す
          return img, heat, sent, of_size
  
      def __len__(self):
          return NUM_ITERATIONS # 学習回数
  
  def main():
      # OCRプログラムに合わせたクラス数でモデルを作る 
      model = get_detectionnet()
      model.to(USE_DEVICE) # GPUを使うときはGPUメモリに乗せる
      model.train() # モデルを学習用に設定する
  
      # 学習の準備
      optimizer = torch.optim.Adam(model.parameters())
      # 損失関数
      mseloss = nn.MSELoss()
      def loss(v, hm_wd, hm_sent, of_size):
          r = mseloss(v['hm_wd'], hm_wd)
          r += mseloss(v['hm_sent'], hm_sent)
          r += mseloss(v['of_size'], of_size)
          return r
  
      # データセットの作成
      dataset = MyDataset()
      # 別スレッドでデータを読み込む
      data_loader = torch.utils.data.DataLoader(
          dataset, batch_size=BATCH_SIZE,
          shuffle=True, num_workers=NUM_WORKERS)
  
      # 学習ループ
      for X, y_wd, y_sent, of_size in tqdm(data_loader):
          X = X.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
          y_wd = y_wd.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
          y_sent = y_sent.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
          of_size = of_size.to(USE_DEVICE) # GPUを使うときはGPUメモリ上に乗せる
  
          # ニューラルネットワークを実行
          res = model(X)
          # 合計の損失値を求める
          losses = loss(res, y_wd, y_sent, of_size)
  
          optimizer.zero_grad() # 一つ前の勾配をクリア
          losses.backward() # 損失値を逆伝播させる
          optimizer.step() # 新しい勾配からパラメーターを更新する
  
      # 最終的なモデルを保存する
      torch.save(model.state_dict(), 'chapt09-model1.pth')
  
  if __name__ == '__main__':
      main()

Windows10 環境下での注意点 †

Windows10が夜中に勝手に再起動する †

• Windows Updateのスケジュール時間で、設定によってはWindowsが使用されていないと判断した時には、勝手に再起動することがある。
  「コントロールパネル」→「セキュリティとメンテナンス」→「メンテナンス」→「メンテナンス設定の変更」→「自動メンテナンス」で、「スケジュールされたメンテナンスによるコンピュータのスリープ解除を許可する」のチェックを外しておく。
  
• Windows Updateは夜中に起動するように設定されているのでそれを超えて稼働させる場合は一定期間止ておく必要がある。
  
  
  
  
  ● 「設定」→「更新とセキュリティ」→「Windows Update」を開く。
  ● ページの下方「詳細オプション」を選択し「更新の一時停止」を設定する。
  ● 一時停止中は「Windows Update」の画面にその旨表示される。
  
  ※ なぜこのような仕様なのかは不明だが、処理中だろうがお構いなく再起動するので時間のかかった処理結果が一瞬で焼失するのでくれぐれも注意のこと!!
  
   

更新履歴 †

• 2021/10/13 初版
• 2021/10/17 OCR 追加
• 2021/11/09 Chapter07 追加
• 2023/12/17 RTX 40 シリーズ 追加
   

参考資料 †

• GeForce GPUの特徴とスペックの見方
  
• Your data science toolkit Anaconda Individual Edition
  
• CUDA Toolkit Downloads
  
• GPUの動作確認セット
• WindowsでCUDA+PyTorchのサンプル実行するまでのメモ
  
• PyTorchインストール時のCUDAバージョンの選び方
  
• WSL 2(Windows Subsystem for Linux 2)の違いとインストール方法
  

• コマンドプロンプトの使い方と基本的なコマンドを紹介
  
• 今さら聞けない！コマンドプロンプトの使い方【初心者向け】
  

• Windows Updateを一定期間止める方法
  
• Windows10が夜中に勝手に再起動