動画に対する推論の高速化について

Question

動画に対して、1024×1024のフレーム画像を取得し、256×256の領域64個(縦8×横8、オーバーラップあり)に対して識別器を適用し、出力した確率を格納した(フレーム数,8,8)のnumpy配列を作成したいのですが、現在の実装では
①OpenCVでフレーム画像読み込み
②PIL画像に変換
③識別する領域をクロップして変数に格納
④識別
⑤出力した確率を、配列の対応する場所に格納
⑥③へ
という単純な実装で、処理時間が1フレームあたり約1秒かかり、とても遅いです。
処理したい動画は30000フレームちょっとあり、10時間ほどかかります。
0.1秒ほどで処理するのが理想で、高速化のためいくつか思いついたことを試したのですが上手くいきません。
高速化する良い方法がありましたら教えていただきたいです

    #推論
    for i in tqdm(range(num_frame), position=0):
        cap.set(cv2.CAP_PROP_POS_FRAMES, i+1)
        ret, frame = cap.read()

        if not ret:
            break
        else:
            pil_frame = cv2pil(frame)

        with torch.no_grad():
            for j in range(len(x)):
                for k in range(len(y)):
                    cropped_img = pil_frame.crop((int(x[j]), int(y[k]), int(x[j])+256, int(y[k])+256))
                    cropped_img_tensor = transform(cropped_img, phase="test").unsqueeze(0) #transformしたあと、推論するためバッチの次元を追加

                    output = model(cropped_img_tensor)
                    prob = softmax(output)[0][1].item() #softmaxを計算
                    prob_array[i][k][j] = prob

↓実行時間計測

   for i in tqdm(range(num_frame), position=0):
       a = time.time() ###############################
       cap.set(cv2.CAP_PROP_POS_FRAMES, i+1)
       ret, frame = cap.read()
       b = time.time()############################
 
       if not ret:
           break
       else:
           pil_frame = cv2pil(frame)
 
       c = time.time() #######################
 
       with torch.no_grad():
           for j in range(len(x)):
               for k in range(len(y)):
                   cropped_img = pil_frame.crop((int(x[j]), int(y[k]), int(x[j])+256, int(y[k])+256))
                   cropped_img_tensor = transform(cropped_img, phase="test").unsqueeze(0) #transformしたあと、推論するためバッチの次元を追加
 
                   output = model(cropped_img_tensor)
                   prob = softmax(output)[0][1].item() #softmaxを計算
                   prob_array[i][k][j] = prob
 
       d = time.time() ##############################
       print(b-a)
       print(c-b)
       print(d-c)

0%| | 0/32762 [00:00<?, ?it/s]
0.05161237716674805
0.017586469650268555
2.1721038818359375
0%| | 1/32762 [00:02<20:23:48, 2.24s/it]
0.044759511947631836
0.016994237899780273
0.6606061458587646
0%| | 2/32762 [00:02<16:14:59, 1.79s/it]
0.056168556213378906
0.016913175582885742
0.6579580307006836
0%| | 3/32762 [00:03<13:22:14, 1.47s/it]
0.06777358055114746
0.01434183120727539
0.6527915000915527
0%| | 4/32762 [00:04<11:21:56, 1.25s/it]
0.07939982414245605
0.014380693435668945
0.6701173782348633
0%| | 5/32762 [00:05<10:02:29, 1.10s/it]
0.09820103645324707
0.014620542526245117
0.6635544300079346
0%| | 6/32762 [00:05<9:08:54, 1.01s/it]
0.10292172431945801
0.015182971954345703
0.6512439250946045
0%| | 7/32762 [00:06<8:30:15, 1.07it/s]
0.11549758911132812
0.01836109161376953
0.649014949798584
0%| | 8/32762 [00:07<8:05:24, 1.12it/s]
0.13360857963562012
0.016347885131835938
0.6655523777008057
・
・

これはVGG16で実行したときの時間です
32762はフレーム数です
一番時間がかかるのは推論だと思うのですが、なぜかモデルをMobileNet_v2にしてもほとんど実行時間は変わりませんでした

#追記
・1/4
cap.read()すると勝手に次のフレームに行くみたいなので、余計なcap.setをコメントアウトしたところ、実行時間が約1.3倍になり、7時間ほどで処理できるようになりました。
30000フレームちょっとの動画の
read()に7分
cv2pilに8分
cropとtransformに30分
output = model(cropped_img_tensor)に約6時間
かかるようです。

    for i in tqdm(range(num_frame), position=0):
        #cap.set(cv2.CAP_PROP_POS_FRAMES, i+1)
        ret, frame = cap.read()

・1/5
dataloaderを使用し、64枚一気に推論するように変更したところ、1秒で2.6フレームほど処理可能で、3時間ちょっとで処理できるようになりました。
しかし、以前の実装では大丈夫だったのですが、なぜか実行毎に推論結果が同じにならず、原因を調査中です。

getitemを変更
    def __getitem__(self, index):
        i = index // len(self.x)
        j = index % len(self.y)
        cropped_img = self.frame.crop((int(self.x[j]), int(self.y[i]), int(self.x[j])+256, int(self.y[i])+256))
        cropped_img = self.transform(cropped_img)
        return cropped_img

推論部分を変更
    for i in tqdm(range(num_frame), position=0):
        ret, frame = cap.read()

        if not ret:
            break
        else:
            pil_frame = cv2pil(frame)

        train_dataset = Dataset(x, y, pil_frame, transform=Transform(resize, mean, std), phase="test")
        train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=64, num_workers=2, pin_memory=True)

        with torch.no_grad():
            for inputs in train_dataloader:
                if use_cuda:
                    inputs = inputs.cuda()
                outputs = model(inputs)
                prob_array[i] = softmax(outputs)[:, 1].to('cpu').detach().numpy().copy().reshape(len(x), len(y)) #8×8にreshape

・1/8
torch.manual_seed(1)とrandom.seed(1)を行うと推論結果が実行毎に同じになるようになりましたが、以前のように1枚ずつ推論していたときとは少し異なる結果となっています
1枚ずつ推論する方では、実行結果が毎回同じになっています
・1/17
解決しました!!
私の初歩的なミスでした。申し訳ありません。
データ拡張のTransformを

class Transform():
    def __init__(self, resize, mean, std):
        self.data_transform = {
            "train": transforms.Compose([
                #Histogram_Equalization(),
                Luminance_Histogram_Equalization(),
                transforms.RandomRotation((-20,20)),
                transforms.RandomVerticalFlip(),
                transforms.RandomHorizontalFlip(),
                transforms.Resize(resize),
                transforms.ToTensor(),
                transforms.Normalize(mean, std)
            ]),
            "test": transforms.Compose([
                #Histogram_Equalization(),
                # Luminance_Histogram_Equalization(),
                transforms.Resize(resize),
                transforms.ToTensor(),
                transforms.Normalize(mean, std)
            ])
        }

    def __call__(self, img, phase="train"):
        return self.data_transform[phase](img)

というふうに、Transformのtrainとtestを辞書型にしていて、デフォルトでtrainの方を呼び出すようにしていたのが原因でした。
datasetのgetitemを変更し

✖ cropped_img = self.transform(cropped_img)
〇 cropped_img = self.transform(cropped_img, self.phase)

とすることで、ちゃんとtest用のtransformをするようになり、最初に書いていた1枚ずつ推論するコードとまったく同じ結果になりました
seedを固定しないと結果が同じにならなかったのは、train用のtransformのRandom~等の影響だと思います
また、test時には不要なtransformの処理もなくなり、少し早くなって1秒当たり3.9フレームほど処理できるようになり、2時間20分で推論できるようになりましたが、まだ1時間を切れていないので、さらに高速化できればまた追記します
A_kirisakiさん、様々な助言を下さり、本当にありがとうございました。
・1/18
画像の読み込み等をデータローダーで並列化し、1秒で6.5フレームほど処理でき、1時間20分で終わるようになりました

キャッシュを使用してフレーム画像を取得するクラスを追加
class Frame:
    def __init__(self, cap):
        self.cap = cap

    @lru_cache(maxsize=1) # キャッシュ
    def __call__(self, frame_num):
        # self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
        ret, frame = self.cap.read()
        pil_frame = cv2pil(frame)
        return pil_frame

Frameクラスに合わせて__getitem__を変更
class Dataset(data.Dataset):
    def __init__(self, x, y, cap, num_frame, transform=None, phase="test"):
        self.x = x
        self.y = y
        self.num_frame = num_frame
        self.transform = transform
        self.phase = phase
        self.get_frame = Frame(cap)

    def __len__(self):
        return len(self.x) * len(self.y) *  self.num_frame
        
    def __getitem__(self, index):
        frame_num = index // (len(self.x) * len(self.y)) # index // 8 * 8
        i = (index - (frame_num * len(self.x) * len(self.y))) // len(self.x)
        j = (index - (frame_num * len(self.x) * len(self.y))) % len(self.y)
        self.frame = self.get_frame(frame_num)
        cropped_img = self.frame.crop((int(self.x[i]), int(self.y[j]), int(self.x[i])+256, int(self.y[j])+256))
        cropped_img = self.frame.crop((int(self.x[j]), int(self.y[i]), int(self.x[j])+256, int(self.y[i])+256))
        cropped_img = self.transform(cropped_img, self.phase)
        return cropped_img

Frameクラスのおかげで、1フレームずつ読み込んでそのたびにデータローダーを宣言する必要が無くなったので、推論部分を変更
    train_dataset = Dataset(x, y, cap, num_frame, transform=Transform(resize, mean, std), phase="test")
    train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=64, num_workers=1, pin_memory=True) # num_workersは2にすると変なメッセージが出る上に、1と速度が大差ないので1

    model.eval()
    print("-------------")
    print("推論開始")

    #推論
    with torch.no_grad():
        for i, inputs in enumerate(tqdm(train_dataloader)):
            if use_cuda:
                inputs = inputs.cuda()
            outputs = model(inputs)
            prob_array[i] = softmax(outputs)[:, 1].to('cpu').detach().numpy().copy().reshape(len(x), len(y))

目標の50分まではまだ届いていませんが思いつくことは大体やったので、解決にしようと思います。
ありがとうございました。

Comments

[hoshi-takanori]

まずは各ステップの処理時間を計測することから始めましょう。

[daikooooooon]

アドバイスをしていただきありがとうございます。
計測結果を追記しました。

[A_kirisaki]

PyTorch っていい感じに並列化してくれたりしてくんないんですか（エアプ）？for 文中のそれぞれの処理時間が気になるところですね。意外と PIL がヤバそう

[daikooooooon]

256×256の画像を1枚ずつ推論するのではなく、PyTorchのデータローダーを用いれば並列化できそうな気がしますね。明日やって見たいと思います。
動画の読み込みにOpenCVを使わないといけないと思うのですが、PyTorchの学習と推論時の画像読み込みやデータ拡張にPILを用いているので、cv2pilというqiitaからとってきた関数で変換させています。
自分のノートPCで、1024*1024の200kbぐらいの画像を10000回cv2pilするとだいたい10分ほどでした。
推論したい動画は30000フレームほどなので約30分ほどですが、フレーム読み込みとPIL変換を並列化できれば問題ないような気もしますし、今30000フレームちょっとの動画に36000秒(10時間)ほどかかるので、もっと改善できる点がある気がします。
ありがとうございます。

[退会済みユーザー]

> output = model(cropped_img_tensor)に約6時間
ご察しの通り、恐らく30000フレーム（30000バッチ)に約6時間です。並列処理で128枚同時にバッチ(128,255,255,3)に突っ込めれば230倍くらいは早くなり約2.8分で捌けそうです。512枚同時なら43秒くらいでしょうか。

[daikooooooon]

ありがとうございます
128はちょっと実行できるか分かりませんが、実行毎に推論結果が同じにならない問題を解決してからやって見ようと思います

[A_kirisaki]

機械学習の推論結果って基本完全一致はしないんじゃなかったでしたっけ（学生時代のうろ覚え）？ましてや並列ともなるともともとのアルゴリズムに順序依存がなかったか考える必要がありそう。

[daikooooooon]

学習済みのモデルで推論を行っているだけなので演算結果が同じだと思うのですが、
torch.manual_seed(1)
np.random.seed(1)
random.seed(1)
について調べた結果、
torch.manual_seed(1)
random.seed(1)
を行うと推論結果が実行毎に同じになるようになりました。
torch.manual_seed(1)だけ、もしくは random.seed(1)だけだと同じにならないので、この2つが関係があるようです
ですが、以前のように1枚ずつ推論していたときとは少し異なる結果となっているので、それについても調べてみます。
ありがとうございます。

[A_kirisaki]

こんなん書いてました
> # これを有効にしないと、計算した勾配が毎回異なり、再現性が担保できない。
https://pystyle.info/pytorch-how-to-use-pretrained-model/#outline__3_2

後実行結果が違うのは with no_grad の中に入ってる部分が違うからなのではという気が

[daikooooooon]

記事まで報告して頂いてありがとうございます????‍♂️
申し訳ないのですが、他に実装しないといけないものがあり、少し忙しいので、後日試したいと思います。

[退会済みユーザー]

解決できたようで何よりです。解答欄に解決策をのせてCloseするようにお願いします。今後同じ問題に当たった人が助かりますので…。

[daikooooooon]

fourteenlengthさん
助言をいただきありがとうございました
推論結果が同じにならない問題は、元々の高速化の問題解決の中で生じたもので、高速化についてはまだ理想が達成できていないので、もうしばらくしてからそうしたいと思います

Answer 1

追記に記載-----

######・1/21
さらに1.5倍ほど高速化し、1つの動画に約55分という理想に近い速度で処理できるようになりました!
PILのクロップをしているあたりに時間がかかっていたので、
https://blog.shikoan.com/pytorch-extract-patches/
を参考に、フレーム画像をTensorに変換し、それからunfoldを使って一気にクロップするように変更しました

Transformでunfoldするクラス
int(x[1])は109で、フレーム画像から画像をcropするときの画像間のstep幅
class Make_Patch:
    def __init__(self, x):
        self.step = int(x[1] * (224 / 256)) # resize後のstepなので、* (224 / 256)

    def __call__(self, img):
        imgs = img.unsqueeze(0).unfold(2, 224, self.step).unfold(3, 224, self.step).permute([0, 2, 3, 1, 4, 5]).reshape(-1, 3, 224, 224)
        return imgs

Transformを変更
            "test": transforms.Compose([
                transforms.Resize(resize),
                transforms.ToTensor(),
                transforms.Normalize(mean, std),
                Make_Patch(x),
            ])

Datasetを変更
class Dataset(data.Dataset):
    def __init__(self, cap, num_frame, transform=None, phase="test"):
        self.cap = cap
        self.num_frame = num_frame
        self.transform = transform
        self.phase = phase

    def __len__(self):
        return self.num_frame #################################

    def __getitem__(self, index):
        ret, self.frame = self.cap.read()
        self.frame = cv2pil(self.frame)
        cropped_img = self.transform(self.frame, self.phase)#######################
        return cropped_img

Transformのresizeは256→224にしていたが、今回の実装ではフレーム画像をリサイズしてTensorにしてunfoldするので、1024→896にリサイズ
resize = 896 # 224/256 = 0.875, 1024*0.875 = 896

推論部分を変更
    #推論
    with torch.no_grad():
        for i, inputs in enumerate(tqdm(dataloader)):
            inputs = inputs.reshape(-1, 3, 224, 224) # 先頭に余計な次元1があるので消す
            if use_cuda:
                inputs = inputs.cuda()
            outputs = model(inputs)
            if inputs.size()[0] == batch_size * len(x) * len(y): # フレーム数がバッチサイズで割り切れないときは、最後のイテレーションの代入はインデックス指定を変更
                prob_array[i*batch_size:i*batch_size+batch_size] = softmax(outputs)[:, 1].to('cpu').detach().numpy().copy().reshape(batch_size, len(x), len(y))
            else:
                prob_array[i*batch_size:] = softmax(outputs)[:, 1].to('cpu').detach().numpy().copy().reshape(-1, len(x), len(y))

Answer 2

↓↓↓↓↓↓↓↓↓↓