常連

注目の的

回答者

ベストアンサー

拍手喝采

自己紹介

有名人

動画に対して、1024×1024のフレーム画像を取得し、256×256の領域64個(縦8×横8、オーバーラップあり)に対して識別器を適用し、出力した確率を格納した(フレーム数,8,8)のnumpy配列を作成したいのですが、現在の実装では
①OpenCVでフレーム画像読み込み
②PIL画像に変換
③識別する領域をクロップして変数に格納
④識別
⑤出力した確率を、配列の対応する場所に格納
⑥③へ
という単純な実装で、処理時間が1フレームあたり約1秒かかり、とても遅いです。
処理したい動画は30000フレームちょっとあり、10時間ほどかかります。
0.1秒ほどで処理するのが理想で、高速化のためいくつか思いついたことを試したのですが上手くいきません。
高速化する良い方法がありましたら教えていただきたいです
```Python
    #推論
    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
```

↓実行時間計測
```Python
   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時間
かかるようです。
```Python
    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時間ちょっとで処理できるようになりました。
しかし、以前の実装では大丈夫だったのですが、なぜか実行毎に推論結果が同じにならず、原因を調査中です。
```Python
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を
```Python
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を変更し
```Python
✖ 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分で終わるようになりました
```Python
キャッシュを使用してフレーム画像を取得するクラスを追加
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分まではまだ届いていませんが思いつくことは大体やったので、解決にしようと思います。
ありがとうございました。

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

### 前提・実現したいこと

Pythonで機械学習をテストするコードを書いています。
データが十数GBあり、それを予めメモリにロードすることで高速化していますが、（コードを書き換えるなどした）異なるプログラムを同時実行するにはメモリ容量に限界があります。

そこでメモリにロードするプログラムと、そこにアクセスして機械学習を実行するプログラムに分離したいと考えていますが、この機能を実現する方法・コードサンプルはあるでしょうか。

ネットで調べても、同一のプログラムからマルチプロセスに分岐して共有メモリを実現する方法しか見つけられませんでした……。
よろしくお願いします。

環境：Python 3.6.9、Ubuntu 18.04.3 LTS

Pythonでプログラム間でメモリを共有する方法

以下の記事を読んでていきなり”unique symbol”型というところで行き詰まってしまって記事の要点まで行けず困っております

[TypeScriptでMapped Typesを使ってきれいなインターフェースを作る話](https://qiita.com/uhyo/items/f5e4483b8e3005f3f5fc)

そもそも”unique symbol”とは？ということで調べますと以下のような要点が得られました
- 「unique symbol」型も Symbol( )で生成する
- 「unique symbol」型はconstまたはstatic readonlyのフィールドでのみ利用可
- 「unique symbol」型同士の変数でも相互代入は不可
- 「unique symbol」型の変数が定義されるとそれが一種の型として定義空間に追加される（const mySym: unique symbol;とあると、一意な mySymという 「ユニークな型」が同時に宣言されるということ）

そしてもっとも知りたいところは、記事内で「イミュータブルなレコード（ImmutableRecord<Data>）を扱うempty関数とset関数を定義する」というくだりで、どうして以下のエイリアスでイミュータブルな型が出来るのかという点です
```TypeScript
declare const recordBrand: unique symbol;
type ImmutableRecord<Data> = {
    [recordBrand]: Data
};
```
これであっても変更は可能と思います。なのでコードの主旨が汲み取れてないなとずっと悩んでおります
```TypeScript
let obj: ImmutableRecord<{name: string}> = {
    [recordBrand]: {name: 'Mike'}
}
obj[recordBrand].name = 'John'
console.log(obj[recordBrand].name) // 'John'
```

質問の要点としては「これはどこがイミュータブルなの？」ということなのですが。

またさらに記事内でこれに続くコードで、関数の実装を書いてみれば何か思いつくかと思いやってみたのですが、ここでも理解不足でset関数の正しい実装がわからず、こちらについても教えていただきたいです。
```TypeScript
function empty(): ImmutableRecord<{}>{
    return {[recordBrand]:{}}
}
function set<Data, Key extends string, Value>(
    map: ImmutableRecord<Data>,
    key: Key,
    value: Value,
): ImmutableRecord<Data & {
    [K in Key]: Value
}>{
    map.key = value
　　return map
}
// error message
// Type 'ImmutableRecord<Data>' is not assignable to type 'ImmutableRecord<Data & { [K in Key]: Value; }>'
```

交差型であればいいのなら単にプロパティーを追加するだけ可と思い上のようにしたのですがこれではだめなのでしょうか？これでどうして返り値の型と一致しないエラーになるのでしょうか？

unique symbol型でイミュータブルを実現する方法について

### 前提・実現したいこと

現在，API_KEY(secret key)を必要とするREST APIを内部で利用するGoogle chrome 拡張機能の開発をしています．
各ユーザのAPIを用いるためのAPI_KEYの安全な保存方法についてアドバイスをいただければと思います．

外部サイトにてユーザが各自取得してきたAPI_KEYを拡張機能のOptionsでユーザに入力させて`chrome.storage.sync.set({apikey: API_KEY}, function() {});`にて保存する方法を考えました．
しかし，[https://developer.chrome.com/docs/extensions/reference/storage/](https://developer.chrome.com/docs/extensions/reference/storage/)によると，
> Confidential user information should not be stored! The storage area isn't encrypted.

とあり，APIの秘密鍵を保存するには適さないと考えられます．
このような場合，どのようにAPI_KEYを保存するのが適切でしょうか．

また，仮に上記の方法で保存した場合，(chromeの脆弱性を除いて)`chrome.storage.sync`によって同期されるアカウント保持者以外の第三者が保存されたデータを取得する方法が存在するということなのでしょうか．それとも万が一データを取得された場合に，暗号化されていないため安全性が担保されないという話なのでしょうか．


### ソースコード例
`save`ボタンを押すと，入力欄に入力されたAPI_KEYの値を`chrome.storage.sync.set`により保存する例

`options.html`
```javascript
<!DOCTYPE html>
<html>
<head>
  <title>Options Page</title>
<meta http-equiv="content-type" charset="utf-8">
</head>
<body>
<input type="password" id="apikey"><button id="save">Save API_KEY</button>
  <script src="options.js"></script>
</body>
</html>
```

`options.js`

```javascript
function check_apikey(){
    chrome.storage.sync.get(null, function (items) {
        var api_key = items.apikey;//ここでchrome.storage.syncで保存したAPI_KEYを取得
        var api_url = "https://api.hoge.com/foo";
        var params = {
            auth_key: api_key,
            text: "APIで送信するテキストデータ",
        };
        var data = new URLSearchParams();
        Object.keys(params).forEach((key) => data.append(key, params[key]));
        fetch(api_url, {
            method: "POST",
            headers: {
                "Content-Type": "application/x-www-form-urlencoded; utf-8",
            },
            body: data,
        }).then((res) => {
            alert("resはAPIからのレスポンス"+res) 
        }
}

function save_apikey() {
    chrome.storage.sync.set(
        {
            apikey: document.querySelector("#apikey").value,
        },
        function () {
            check_apikey();
        }
    );
}
document.querySelector("#save").addEventListener("click", save_apikey);
```

### 調べたこと
[https://www.anupshinde.com/posts/salesforce-rest-api-chrome-extension/](https://www.anupshinde.com/posts/salesforce-rest-api-chrome-extension/)ではユーザにソースコードをダウンロードさせ，直接ソースコードを書き換えてもらう手法が提案されています．しかし，将来的に開発中の拡張機能はChromeWebStoreに公開したいと考えているのでこの方法はあまり現実的ではありません．
それに，(この分野に明るくないので的外れな考えかもしれませんが)ソースコードにcredentialsを直接書き込むのはセキュリティ的にいかがなものだろうかと疑問が残ります．

### 補足情報（FW/ツールのバージョンなど）
Google chrome Version 87.0 (Official Build) (64-bit)


### 追記

[https://www.reddit.com/r/javascript/comments/8txe2q/how_to_securely_store_an_api_token_in_a_chrome/](https://www.reddit.com/r/javascript/comments/8txe2q/how_to_securely_store_an_api_token_in_a_chrome/)によると，
> What you should not store inside the local storage are e.g. passwords. For that you should simply use the credential management API that lets chrome store any credentials in its password storage for you.

とのことですが，多くの方の見解を伺いたいです．よろしくお願いします．

chrome extensionにおけるユーザデータのセキュアな保存方法

RustのCloneとCopyトレイトについての質問です。

配列の要素として、Stringのclone()を並べるとコンパイルが通ります。
let s = String::from("xxx");
let a = [s.clone(),s.clone(),];  **←これはOK**

配列の初期化の書き方をすると、エラーになります(String型にCopyトレイトが実装されていないので)。
let s = String::from("xxx");
let a = [s;2];  **←これはNG**

clone()を並べる書き方が許されていて、初期化の書き方が許されていないのは、
何故なのでしょうか。同じように見えるのですが‥‥？

実害はないのですがすごく気になり質問いたしました‥‥ X-(
```
error[E0277]: the trait bound `std::string::String: std::marker::Copy` is not satisfied
 --> src/main.rs:5:10
  |
5 |     let a = [s;2];
  |             ^^^^^ the trait `std::marker::Copy` is not implemented for `std::string::String`
  |
  = note: the `Copy` trait is required because the repeated element will be copied
```

RustのCloneとCopyについての素朴な疑問

lambda 関数を用いて、以下のような処理をしたいと考えています。

### 実現したい処理

- 文字列 s を解析して、対応する無名関数を返す関数 `calc(s)` を定義して実行
- 文字列 `x+3` を受け取り`f=calc("x+3")` とする（入力は `x+[1桁の整数]` or `[1桁の整数]+x` の形式（`+` の部分には `+, -, *, /` のいずれかが入る）とする）
- `f(1)` の値を実際に計算してみる

### やったこと

次のようなコードを書いたのですが、 `TypeError: unsupported operand type(s) for +: 'function' and 'int'` となってしまい、 `lambda` と `int` の計算は型が合わないためできないとなってしまいます。

原因は分かっているのですが、このような処理を実行するために適切なコードの書き方が分かりません。教えていただけると助かります。

```python
def calculator(x, op, y):
    if op == "+":
        return x + y
    elif op == "-":
        return x - y
    elif op == "*":
        return x * y
    else:
        return x // y

def read_char(c):
    if c == "x":
        return lambda x: x
    else:
        return int(c)

def calc(s):
    lf = read_char(s[0])
    op = s[1]
    rf = read_char(s[2])
    def func(x):
        return calculator(lf, op, rf)
    return func
```

実行結果

```
>>> f = calc("x+3")
>>> f(1)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 f(1)

 in func(x)
     20     rf = read_char(s[2])
     21     def func(x):
---> 22         return calculator(lf, op, rf)
     23     return func

 in calculator(x, op, y)
      1 def calculator(x, op, y):
      2     if op == "+":
----> 3         return x + y
      4     elif op == "-":
      5         return x - y

TypeError: unsupported operand type(s) for +: 'function' and 'int'
```

Python の lambda 関数の挙動について

以下のコード､
変数の宣言により､コンパイラーが､変数がメモリのどの部分を使うのか決定する｡
そしてa=5により､そのメモリ領域に､値５(２進法の101)が入る｡ここまでは直感的に分かるのですが｡
b=aにより､bによるメモリ領域に､aの値５が入る所がすっきりしません｡
たとえば､bにaが代入される際に､bはaのメモリのアドレスを参照し､そこから値の５を持ってくる｡そういう理解で良いのでしょうか｡
よろしくお願いいたします｡


```C
# include <stdio.h>

int main(void)

{
    int a;
    int b;

    a=5;
    b=a;

    return 0;
}


```