常連

注目の的

# 前提条件
例えば以下の画像のエッジを抽出する場合、OpenCVのCannyを利用する事で抽出出来ます。

```python3
img = cv2.imread("img1.png")
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
canny_img = cv2.Canny(gray_img, 100,200)
```

![img1](0401878b45b59ea6ce45d72ae85e0716.png)  ![canny_img](362d627cfc31901ab051cef5a4d9549c.png)


# 実現したいこと
スカスカの画像を入力した場合に、上記内容と同じようなエッジを抽出したいです。
![img2](76dfb5eb4bc8afc105d636118c2f6e98.png)

人間の目で見ると境界線を引けそうに見えるのですが、どのような考え方で抽出すれば良いのかが思い付きません
なお、このスカスカな画像の点の間隔は、実際には一定ではありません
モルフォロジーは試したのですが、隙間が大きい箇所については膨張処理では補いきれませんでした。

### 用途
LIDARの点群を平面に透視投影した際の、色の境目からエッジを抽出したい
→ LIDARに映っている物の輪郭を画像として取得したい


良い方法などありましたら、ご教示いただければ幸いです。
よろしくお願いいたします。

スカスカな画像のエッジ抽出方法

**[実現したいこと]**
訳あってMobileNet_V1をCで実装したい。convolution層,point_convolution層,dw_convolution層等の層は問題なく実装できそうなのだが、当モデルは学習時にBatchNormalization層を通しているので推論時にも同様に入力を正規化する必要があるのでバッチ正規化層を実装したいと考えている。
**[わかっていること]**
ここでどのように正規化するのかということで、調べてみたところどうやら学習中にバッチ毎に正規化するための平均と標準偏差が決定されており、学習時はバッチ毎に決定されたそれら二つのパラメータを用いて入力を正規化するとのこと。

参考にしたサイトの一つ : https://qiita.com/t-tkd3a/items/14950dbf55f7a3095600

**[実現のために知りたいこと]**
推論時のバッチ正規化層では入力をどのように正規化しているのか知りたい。推論時(つまりテスト時)には入力はバッチでは来ないはずであり１枚の画像が入力されてテストが行われるはず。学習時ではバッチ毎に決定した平均と標準偏差を用いて各バッチの入力を正規化するのに対して、推論時はどういったパラメータを用いて中間入出力の値を正規化するのか知りたい。
自分の予想では学習データ全体の平均と標準偏差を用いて正規化するのだとふんでいるのだがいまいち確証が持てないので手詰まりになっている。

またPyTorchを用いて学習を行ったのでPyTorchでどのように学習後のモデルから学習によって決定された平均や標準偏差を抽出するか。ということも知りたいです。

どなたか詳しい方がいらっしゃいましたらご教授頂けると幸いです。
すみませんがよろしくお願いいたします。

MobileNet V1内のバッチ正規化(Batch Normalization)層の推論時の入力データに対する処理内容を知りたい

### 前提・実現したいこと
学習済みモデルの推論時に任意の一枚の画像を入力したときに各層の中間出力の値を可視化したい

例えばImageNetを学習した10層で構成されたモデルに任意のRGB画像を入力して推論中の各層の出力を

Layer1 : 1.1015 1.1187 1.1358 1.0844 ...
Layer2 : 1.3315 0.8887 5.5558 9.8849 ...
Layer3 : ...
...

といったように可視化したい。

### 試したこと

今のところ単一の画像を読み込んで推論させるところまでは出来ている。
```Python
img = Image.open('/content/drive/My Drive/mytest/imagenette-320/val/n03888257/ILSVRC2012_val_00047778.JPEG')
inputs = transform(img)
inputs = inputs.unsqueeze(0).to(device)

model.eval()
output = model(inputs)
pred = output.argmax(dim=1, keepdim=True)
print(pred[0].item())
```
出力(推論されたラベル)
```
9
```

実際このようなことが可能なのか不可能なのかもわからないです。
どなたかご回答いただけると幸いです。すみませんがよろしくお願いいたします。

学習済みモデルの推論時に任意の一枚の画像を入力したときに各層の中間出力の値を可視化したい

PythonでOPENCVで画像処理をしておりますが、
ファイルが多いので高速化検討しようと考えており、並列処理したく思います。

現在は、OPENCVで画像ファイルを並列処理できておりますが、
参照している画像ファイルが時折、重複するときがあります。

そこで、以下コードのどの部分を変更したら画像ファイルの重複を避けれますでしょうか。

WIN10、PsScriter(Spyder)使用しております。

```
import cv2
import numpy as np
import glob
import os
import pandas as pd
import time
import threading


x_1,y_1,z_1,z_1_1=[],[],[],[]
a,b=[],[]

#保存先
r=r"◎"
j1=["◎"]

for j2 in j1:
    a.clear()
    t1 = time.time()
    dock = r"◎"

    for folder,subfolders,files in os.walk(dock + "\" + str(j2)):
        a.append('{}'.format(folder))
    j=0

    for d in a:
        global q

        def worker1():#--------------------------------------
            global q

            while True:

#            for a in range(5):

                img1 = imread(r_1[q]) # 画像ファイル読み込み
                img1_d_1=r_1[q]
                q=q+1

                if q>d_1-1:
                    break
                img1_d_2=os.path.basename(r_1[q])
                img1_d_3=img1_d_2.replace(".jpg","")

                x_1.append(img1_d_3)

                img_ch0 = cv2.split(img1)[0]
                w_num = cv2.countNonZero(img_ch0)
                
                y_1.append(w_num)

#----------------------------------------------------
        def worker2():
            global q

            while True:
                if q>d_1-1:
                    break
                img2 = imread(r_1[q-1]) # 画像ファイル読み込み
                img2_d_1=r_1[q-1]
                q=q+1
                img2_d_2=os.path.basename(img2_d_1)
                img2_d_3=img2_d_2.replace(".jpg","")
                
                x_1.append(img2_d_3)
                
                img_ch0 = cv2.split(img2)[0]
                w_num = cv2.countNonZero(img_ch0)
                
                y_1.append(w_num)
                
        global q

        r_1 = glob.glob(d + "\*.jpg")
        j=j+1
        print(j)
        print(d)
        
        q=0
        d_1=len(r_1)

        t1 = threading.Thread(target=worker1)
        # t1 スレッドをデーモン化する
        t1.setDaemon(True)
        t2 = threading.Thread(target=worker2)
        x_1=[]
        y_1=[]

        t1.start()
        t2.start()

        print('started')
        t1.join()
        print("--end--")
        t2.join()
        print(set(x_1))    

        print(len(set(x_1)))

        print(y_1)

```

何卒、宜しくお願いいたします。

Python OPENCV　Threading並行処理で参照するファイルの重複を避ける

物体検出における False Positive の計上方法が分かりません。

例えば、犬を検出するモデルを用いて、犬を検出した場合、
次のような結果になったとします。

![イメージ説明](7d5418613536331b3f248a05c0293523.png)


**質問1: 今回、FP の計上方法としては、以下のように、IoU の閾値 を用いていますが、これは誤った方法でしょうか。**

**FP の計上方法**
- 予測された矩形について、GT の矩形との IoU が閾値未満の場合 → FP
- 予測された矩形について、GT の矩形との IoU が閾値以上であるが、その GT の矩形との IoU がより高い予測された矩形が他に存在する場合 → FP


**質問2: このとき、IoU の閾値が0.5の場合、検出結果は、以下の通りで問題ないでしょうか。**
- GT: 2, TP: 1, FP: 2, FN: 1
- Precision = TP / TP + FP = 1/3 = 33%
- Recall = TP / GT = 1/2 = 50%


**質問3: また、物体検出における後処理として、NMS (Non-Maximum Suppression)がありますが、
IoU の閾値が0.5の場合、かつ NMS を適用した場合、検出結果は、以下の通りで問題ないでしょうか。**
- GT: 2, TP: 1, FP: 1, FN: 1
- Precision = TP / TP + FP = 1/2 = 50%
- Recall = TP / GT = 1/2 = 50%

NMS については、予測された矩形がある程度重なっている場合に、予測スコアが最も高いものを残す方法として、考えています。
NMS を適用する場合、IoU=0.6, Score=0.7の矩形が除去されるとし、
そのため、FP の数が、NMS を適用しない場合と比べて、1だけ少ない結果にしています。

物体検出における False Positive の計上方法について

バックエンドに影響するような関数
このレイヤーを逆伝播しなくなる　などの関数がどんなものがあるか知りたいです

例えば　.detach().numpy().copy()は　一つ一つが何をしているのかわかりません
detach()はGANに使う　としか出てこずよくわかりません

それに使える関数があるのに　知らずにどうしようかと悩んでしまう
なんてことにはもうなりたくありません
私はあるかわからないもの　と名前がわからないもの　を調べる方法を知りません

一覧や　まとめサイトなど知ってる人がいたら教えてください

pytorch のバックエンドに関係する関数について（detach()みたいなやつ）

### 実現したいこと
物体検出ライブラリを使ったカメラ解析システムを現在作っています。
概要としては、監視カメラの映像からYOLOv3によって映像内にいる人間の領域を抽出し、その後映っている人間の見た目の属性（年齢、性別、服装など）を別のモデルで推測します。

データの収集には以下の赤外線撮影可能な防犯カメラを使用しています。このカメラは昼間は通常のカラー映像を撮影するのですが、夕方～夜間になり周囲が暗くなってくると自動で赤外線撮影のグレースケール様の映像に切り替わります。
> https://www.wtw.jp/ccd/download/catalogue/2017/part5ahd/p24_WTW-AR27NEP_WTW-AR27HJP.pdf


### 試したこと
現在コードの作成と並行してデータ収集を行っているのですが、撮影現場の都合で夜間の映像データの入手量が少なくなることに気がつきました。そこで昼間に撮影したカラー映像を夜間に赤外線撮影したグレースケール様の画像に変換することで学習データとして用いることができないかと考えました。

考えたのは以下の手順です。
1) 昼間に撮影した映像をグレースケールへと変換する。
2) YOLOv3でカラー映像と同じように扱えるようチャンネル数を戻す。

調べてみたところ、以下のブログではpillowを使ってグレースケール化した画像を再度カラー化する方法が紹介されていたので、サンプル画像で試してみました。
> Pillowでグレースケール化するときに3チャンネルで出力するテクニック
https://blog.shikoan.com/pillow-gray-three-channels/

```Script
from PIL import Image

img = Image.open('./hoge.png')
img2 = img.convert("L") # グレースケール化
img3 = img.convert("L").convert("RGB") # グレースケール化のちカラー化

print(img2.getpixel((16, 16))) # 任意の点(16,16)におけるピクセルの情報を出力
print(img3.getpixel((16, 16)))

img2.save("./hoge_L.png")
img3.save("./hoge_RGB.png")
```

```Output
166 # グレースケール化しただけだと1チャンネルになっている
(166, 166, 166)　# グレースケール化のちカラー化すると3チャンネルになっている
```

順に元のカラー画像、グレースケール化画像、グレースケール化にカラー化した画像を示します。
![元の画像](1acbb78d8b86bcaa2198d0fd5c2b59b7.png)![グレースケール化画像](a5b2e21debe3250877dad9edd29806ed.png)　![グレースケール化後にカラー化した画像](a4e3d4271882d8bc29bea879eb8ece85.png)


### 疑問点
前述の手順で見た目上は赤外線画像のように変換できたように思っているのですが、以下の疑問が生じました。
・そもそも変換後の画像は赤外線撮影の画像と同じものとして扱えるのか？（赤外線撮影画像の中身はグレースケールとは別物なのではないか？）
・YOLOv3の学習時に昼間の映像と夜間の映像を混ぜて使ってもいいのか？

何かご意見やアドバイス等いただけないでしょうか。上記の疑問点以外でもおかしな点がありましたらご指摘いただけますと幸いです。よろしくお願いいたします。

昼間の映像を赤外線撮影映像のように変換してYOLOv3の学習に使いたい

YOLOv3の独自モデル学習を行いました。カテゴリーは３種、用いた画像枚数は５２０枚ほどなのですが、その画像の中に物体検出したいサンプルは１８００ほどあります。

ここで気になったのですが、
[オリジナルデータの学習](https://www.nakasha.co.jp/future/ai/yolov3train.html)
このサイトを参照すると、
最低：1カテゴリに対して100枚
基準：1カテゴリ1000枚
推奨：1カテゴリ5000、10000枚
と書いてありました。

もし１枚の画像の中に検出したい物体が３つあるとき、１枚で３枚分ということになるのでしょうか？
日本語レベルの小さい質問ですが、機械学習に詳しい方おねがいします。。

機械学習を用いた物体検出のデータ量について

YOLOv3でリアルタイムな人物の検出を行いたいと考えています。
分類するクラスを少なくすることで速度は向上しますか？
また、クラス数を減らすことのデメリットは存在しますか？
回答よろしくお願いいたします。

映像中の人物の検出を高速に精度良く行いたいです。深層学習での物体検出を行うとき、クラス数を減らして学習すると速度は向上しますか？

### 前提・実現したいこと
Python 3.7.4
Pytorch 1.4.0

### 発生している問題・エラーメッセージ
Pytorchで重み学習済みVGG16モデルのfine-tuningを行っているのですが、200epoch学習させたら以下の画像ように
80epochあたりで急激にlossが増加し、accが低下しました。どのような原因が考えられるでしょうか?
![model loss](5edc6be0514c344229c68616720528e0.png)
![model acc](71df7bda0bb485fc4ed3be5926337512.png)

### 該当のソースコード

```python
 # VGG-16モデルのインスタンスを生成
use_pretrained = True  # 学習済みのパラメータを使用
net = models.vgg16(pretrained=use_pretrained)
# 1000クラス　→　10クラスに変更
net.classifier[6] = nn.Linear(in_features=4096, out_features=10, bias=True)


def do_train(net, dataloader_dict, criterion, optimizer, num_epochs):

    # 初期設定
    #学習中の指標を保存するリストを作成
    #1epochのtrainに一応値を入れておく
    train_acc_list = [0.]
    train_loss_list = [0.]
    val_acc_list = []
    val_loss_list = []

    # GPUが使えるかを確認
    device = "cuda" if torch.cuda.is_available() else "cpu"
    print("使用デバイス：", device)

    # ネットワークをGPUへ
    net = net.to(device)
    if device == 'cuda':
        net = torch.nn.DataParallel(net) # make parallel

        # ネットワークがある程度固定であれば、高速化させる
        torch.backends.cudnn.benchmark = True

    # epochのループ
    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch+1, num_epochs))
        print('-------------')

        # epochごとの訓練と検証のループ
        for phase in ['train', 'val']:
            if phase == 'train':
                net.train()  # モデルを訓練モードに
            else:
                net.eval()   # モデルを検証モードに

            epoch_loss = 0.0  # epochの損失和
            epoch_corrects = 0  # epochの正解数

            # 未学習時の検証性能を確かめるため、epoch=0の訓練は省略
            if (epoch == 0) and (phase == 'train'):
                continue

            # データローダーからミニバッチを取り出すループ
            for inputs, labels in tqdm(dataloader_dict[phase]):

                # GPUが使えるならGPUにデータを送る
                inputs = inputs.to(device)
                labels = labels.to(device)

                # optimizerを初期化
                optimizer.zero_grad()


                # 順伝搬（forward）計算
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = net(inputs)
                    loss = criterion(outputs, labels)  # 損失を計算
                    _, preds = torch.max(outputs, 1)  # ラベルを予測

                    # 訓練時はバックプロパゲーション
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()

                    # 結果の計算
                    epoch_loss += loss.item() * inputs.size(0)  # lossの合計を更新
                    # 正解数の合計を更新
                    epoch_corrects += torch.sum(preds == labels.data)

            # epochごとのlossと正解率を表示
            epoch_loss = epoch_loss / len(dataloader_dict[phase].dataset)
            epoch_acc = epoch_corrects.double(
            ) / len(dataloader_dict[phase].dataset)

            #listにlossとaccを保存
            if phase == "train":
                train_acc_list.append(epoch_acc)
                train_loss_list.append(epoch_loss)
            else:
                val_acc_list.append(epoch_acc)
                val_loss_list.append(epoch_loss)

            print('{} Loss: {:.4f} Acc: {:.4f}'.format(
                phase, epoch_loss, epoch_acc))

    # PyTorchのネットワークパラメータの保存
    save_path = os.path.join(os.getcwd(), "final_weight.pth")
    torch.save(net, save_path)

    #dictで返す
    history = {'acc': train_acc_list,
               'loss': train_loss_list,
               'val_acc': val_acc_list,
               'val_loss': val_loss_list}
    return history

optimizer = optim.Adam(net.parameters())
criterion = nn.CrossEntropyLoss()

num_epochs = 200
hist = do_train(net, dataloader_dict, criterion, optimizer, num_epochs)
```

### 試したこと

環境によって起きたエラーかと思ったのでGoogle Colaboratory上でも実行してみましたが同様の結果が得られたので、コードに問題があると思っています。