常連

### 実現したいこと
Pythonでmain処理が書いているmain.pyファイルで外部ライブラリを実行中、Ctrl+Cでmain.pyのexceptで処理できるようにしたいです。
ただし、外部ライブラリは変更せずmain.pyのみで対処したいです。

### 発生している問題・分からないこと
pytorchを使ってAIモデルを学習している際に、pytorchの外部ライブラリを参照しに行きます。
その際にCtrl+Cを実行すると
```ここに言語を入力
(略)
KeyboardInterrupt
```
となってしまい、Ctrl+Cの入力は認識していますがコマンドプロンプトが固まってしまいます。

この問題をtyr exceptで囲んでいるmain.pyファイルで正常に処理したいです。

エラーが確認されているソースコード
[pytorch github](https://github.com/pytorch/pytorch/blob/main/torch/utils/data/dataloader.py)
上記URLの131行目、class DataLoaderを使っているときにエラーが発生します。

（追記）
上記DataLoaderを読み込むとき、
```python
trainloader = torch.utils.data.DataLoader(
        train_dataset,
        batch_size=batch_size,
        shuffle=config.TRAIN.SHUFFLE and train_sampler is None,
        num_workers=config.WORKERS,
        pin_memory=True,
        drop_last=True,
        sampler=train_sampler)
```
のように書きますが、num_workersが0のときは正常にexcept KeyboardInterruptできます。
num_workersを2より大きくすると、コマンドプロンプトが固まります。
num_workersの値分、バッチ処理が裏に走るようで複数バッチ処理が走っている場合にctrl+Cをするとすべてのバッチ処理を止めることができず、フリーズするようです。

### 該当のソースコード

```
特になし
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [x] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
- signalを使ってCtrl+Cの入力を拒否しようとしてもclass DataLoaderを参照中はCtrl+Cの入力を認識しており、コマンドプロンプトが固まる
→signal.signal(signal.SIGINT, signal.SIG_IGN)

◯自分の見解
- 参照しているclass DataLoaderはmultiprocessingが走っておりmain.pyとは別のプロセスが走っていることが原因だと考えている。
[pytorch github](https://github.com/pytorch/pytorch/blob/main/torch/utils/data/dataloader.py)

signal.signal(signal.SIGINT, signal.SIG_IGN)した場合、メインとなるプロセスのCtrl+Cは無視することができてもmultiprocessingのサブプロセスは無視することができないと思っている。

ただ、外部ライブラリのファイルを変更せずにmain.pyからの処理だけで正常に処理する方法が分からず苦戦している。

### 補足
- 業務PC
→Windows11/python 3.13.2/cmd.exe/PyTorch 2.5/CUDA version 11.8/num_workers 2～4で検証
- 自宅PC
→Windows11/python 3.12.9/cmd.exe/PyTorch 2.5/CUDA version 12.6/num_workers 2～4で検証


Pythonで外部ライブラリを実行中にctrl+Cで正常終了したい

### 実現したいこと
PythonでPytorchを使って学習したモデルをonnxに変換するとき、pycryptdomeライブラリを使って暗号しました。
暗号したファイルをC++のOpenSSLライブラリを使って復号化してモデルをロードしたいのですが、うまく復号することができませんでした。復号したモデルはTensorRTでモデル変換した後、ロードする予定です。

◯python
暗号化ではpycryptdome==3.22.0を使って添付のコードのようにpytorchモデルをonnxモデルに変換しました。python側では問題なく復号化することはできました。

◯C++
OpenSSL==v3.4.1を使って添付のコードのように復号化する関数を作りました。

手探りで作ったものなので、python側の暗号化に問題があるのか・C++の復号側に問題があるのか・そもそもpythonで暗号化したものがC++で複合するのは難しいのかなど問題の特定ができていないです。
別の方法でも気密性・完全性が担保されるような方法であれば問題ないのでご享受ください。

### 発生している問題・分からないこと
C++の復号の関数（53行目）
EVP_CIPHER_CTX_ctr (ctx, EVP_CTRL_GCM_SET_TAG, tag.size(), tag.data()) != 1
がfalseのため、raiseでエラー終了します。

C++でOpenSSLを使ってEER_print_errors_fp(stderr);で出力すると以下のようなエラーが出ています。



### エラーメッセージ
```error
OPENSSL_Uplink(00007FFAD83F6A28,08): no OPENSSL_Applink

```

### 該当のソースコード

```Python
import io
import torch
from Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2
from Crypto.Random import get_random_bytes

def export_onnx(self, onnx_model,dummy_input, output_model_path, export_params, opset_version, do_constant_folding, input_names, output_names, dynamic_axes, verbose) :

    # メモリにONNXモデルをエクスポート
    buffer = io.BytesIO)
    torch.onnx.export (onnx_model,
　　　　　dummy_ input, 
　　　　　buffer, 
　　　　　export_params=export_params,
　　　　　opset_version=opset_version,
　　　　　do_constant_folding=do_constant_folding,
　　　　　input_names=input_names,
　　　　　output_names=output_names,
　　　　　dynamic_axes=dynamic_axes,
　　　　　verbose=verbose)
    onnx_model_binary = buffer getvalue()

    pass = "abcdefg"
    salt = get_random_bytes(16)
    key = PBKDF2(pass, salt, dkLen=32, count=1000000)
    cipher = AES.new (key, AES.MODE_GCM)
    ciphertext, tag = cipher.encrypt_and_digest(onnx_model_binary)
    # 暗号されたデータをファイルに保存
    with open (output_model_path, 'wb') as f:
        f.write(salt + cipher.nonce + tag + ciphertext)
```

```C++
#include <openssl/evp.h>
#include <openssl/aes.h>
#include <openssl/err.h>

std::vector<char› decryptModel(char* modelpath, std::string pass) {
     std:: ifstream file(modelpath, std:: ios: :binary):
     if (!file) {
          throw std::runtime_error ("Failed to open encrypted model file.");
     }

     //ファイルから復号化に必要なデータを取得
     std::vector <unsigned char > salt (16);
     std::vector<unsigned char> nonce (16);
     std::vector<unsignedchar› tag (16);

     file.read (reinterpret_cast<char*>(salt.data()), salt.size());
     file.read (reinterpret_cast<char*>(nonce.data()), nonce.size ());
     file.read (reinterpret_cast<char*>(tag.data()), tag.size());

     //暗号化されたモデルデータを取得
     std::vector<unsigned char› ciphertext ((std:: istreambuf_iterator<char›(file)), std::istreambuf_iterator<char›());
     file.close();

     //PBKDF2を使用してキーを取得
     std::vector<unsigned char> key (32) ;
     if (IPKCS5 PBKDF2_ HMAC(pass.c_str(), pass.size(), salt.data(), salt.size(), 1000000, 
         EVP_sha256(), key-size(), key .data())){
          throw std::runtime_error ("Failed to derive key using PBKDF2."); 
     }

     // 復号化コンテキスト初期化
     EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
     if (!ctx) {
          throw std::runtime error ("Failed to create EVP_CIPHER_СTX.");
     }

     if (EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), (), nullptr, nullptr, nullptr) != 1 || 
         EVP_CIPHER_CTX_ctrl (ctx, EVP_CTRL_GCM_SET_IVLEN, nonce.size(), nullptr) != 1 || 
         EVP_DecryptInit_ex(ctx, nullptr, nullptr, key.data(), nonce.data()) != 1){

          EVP_CIPHER _CTX_free (ctx) ;
          throw std::runtime error ("Failed to initialize decrypt ion.");
}

     // モデルデータを復号化
     std::vector<unsigned char› decrypted (ciphertext.size));
     int len = 0;
     if (EVP DecryptUpdate(ctx, decrypted.data(), &len, ciphertext.data(), ciphertext.size ()) != 1)
     {
          EVP_CIPHER_CTX_free (ctx);
          throw std::runtime error ("Decrypt ion failed.");
     }

     int decryptedLen = len;
     if (EVP_CIPHER_CTX_ctr (ctx, EVP_CTRL_GCM_SET_TAG, tag.size(), tag.data()) != 1 || 
         EVP_DecryptFinal_ex(ctx, decrypted.data() + len, &len) != 1) {
         
         EVP_CIPHER_CTX_free (ctx);
         throw std::runtime_error ("Decryption failed.");
     }

     decryptedLen += len;
     decrypted.resize (decryptedLen) :
     EVP_CIPHER_CTX_free (ctx);

     //復号化されたデータからモデル情報を取得
     std::vector<char› mode_Data(decrypted.begin(), decrypted.end ()); 
     return modelData;
}
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [ ] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
Google等で調べながら作ったコードで何が問題なのか自体が特定できていません。

### 補足
特になし

C++) pythonで暗号化したファイルを復号する方法

### 前提・実現したいこと
pytorchを使った学習を行いたいがmat1 and mat2 shapes cannot be multipliedとエラーが出る

### 発生している問題・エラーメッセージ

```
Traceback (most recent call last):
  File "C:~~~/test.py", line 52, in <module>
    output=net(input)
  File "C:~~~\module.py", line 727, in _call_impl
    result = self.forward(*input, **kwargs)
  File "C:~~~/test.py", line 30, in forward
    x = F.relu(self.fc1(x))
  File "C:~~~\module.py", line 727, in _call_impl
    result = self.forward(*input, **kwargs)
  File "C:~~~\linear.py", line 93, in forward
    return F.linear(input, self.weight, self.bias)
  File "C:~~~\functional.py", line 1690, in linear
    ret = torch.addmm(bias, input, weight.t())
RuntimeError: mat1 and mat2 shapes cannot be multiplied (1x400 and 576x120)

```

### 該当のソースコード

```ここに言語名を入力
class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        self.conv1=nn.Conv2d(1,6,3)
        self.conv2=nn.Conv2d(6,16,3)
        self.fc1=nn.Linear(16*6*6,120)
        self.fc2=nn.Linear(120,84)
        self.fc3=nn.Linear(84,10)

    def forward(self,x):
        x=F.max_pool2d(F.relu(self.conv1(x)),(2,2))
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

net = Net()
print(net)


input=torch.randn(1,1,28,28)
print(input)
output=net(input)
print('output', output)
target=torch.randn(10)
print('target',target)
target=target.view(1,-1)
criterion  = nn.MSELoss()
```

### 試したこと

参考にしたコードではinput = torch.randn(1, 1, 32, 32)となっていたものをinput = torch.randn(1, 1, 28, 28)としたところエラーが表示されるようになりました。
エラー内容からすると行列の形が合わないということだと思うのですが1x400の部分が理解できません。576x120は(16*6*6,120)から理解できますが、1x400の部分は28x28で1x784になると思ったのですがなぜエラーメッセージのようになるのでしょうか。

### 補足情報（FW/ツールのバージョンなど）

Python 3.7.9
torch   1.7.1

pytorchを使った学習を行いたいがmat1 and mat2 shapes cannot be multipliedとエラーが出る

以下のプログラムは途中までのものですが、google colabだと動いたのですが、会社のGPUを積んだマシンだとエラーがでました。エラーが出た原因が知りたいです。
動かしたプログラム
#####
```ここに言語を入力
import gym
from creversi.gym_reversi.envs import ReversiVecEnv
from creversi import *

import os
import datetime
import math
import random
import numpy as np
from collections import namedtuple
from itertools import count
from tqdm import tqdm_notebook as tqdm
import matplotlib.pyplot as plt

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

BATCH_SIZE = 256

vecenv = ReversiVecEnv(BATCH_SIZE)

# if gpu is to be used
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

######################################################################
# Replay Memory

Transition = namedtuple('Transition',
                        ('state', 'action', 'next_state', 'next_actions', 'reward'))


class ReplayMemory(object):

    def __init__(self, capacity):
        self.capacity = capacity
        self.memory = []
        self.position = 0

    def push(self, *args):
        """Saves a transition."""
        if len(self.memory) < self.capacity:
            self.memory.append(None)
        self.memory[self.position] = Transition(*args)
        self.position = (self.position + 1) % self.capacity

    def sample(self, batch_size):
        return random.sample(self.memory, batch_size)

    def __len__(self):
        return len(self.memory)

######################################################################
# DQN

k = 192
fcl_units = 256
class DQN(nn.Module):

    def __init__(self):
        super(DQN, self).__init__()
        self.conv1 = nn.Conv2d(2, k, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(k)
        self.conv2 = nn.Conv2d(k, k, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(k)
        self.conv3 = nn.Conv2d(k, k, kernel_size=3, padding=1)
        self.bn3 = nn.BatchNorm2d(k)
        self.conv4 = nn.Conv2d(k, k, kernel_size=3, padding=1)
        self.bn4 = nn.BatchNorm2d(k)
        self.conv5 = nn.Conv2d(k, k, kernel_size=3, padding=1)
        self.bn5 = nn.BatchNorm2d(k)
        self.conv6 = nn.Conv2d(k, k, kernel_size=3, padding=1)
        self.bn6 = nn.BatchNorm2d(k)
        self.conv7 = nn.Conv2d(k, k, kernel_size=3, padding=1)
        self.bn7 = nn.BatchNorm2d(k)
        self.conv8 = nn.Conv2d(k, k, kernel_size=3, padding=1)
        self.bn8 = nn.BatchNorm2d(k)
        self.conv9 = nn.Conv2d(k, k, kernel_size=3, padding=1)
        self.bn9 = nn.BatchNorm2d(k)
        self.conv10 = nn.Conv2d(k, k, kernel_size=3, padding=1)
        self.bn10 = nn.BatchNorm2d(k)
        self.fcl1 = nn.Linear(k * 64, fcl_units)
        self.fcl2 = nn.Linear(fcl_units, 65)

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = F.relu(self.bn3(self.conv3(x)))
        x = F.relu(self.bn4(self.conv4(x)))
        x = F.relu(self.bn5(self.conv5(x)))
        x = F.relu(self.bn6(self.conv6(x)))
        x = F.relu(self.bn7(self.conv7(x)))
        x = F.relu(self.bn8(self.conv8(x)))
        x = F.relu(self.bn9(self.conv9(x)))
        x = F.relu(self.bn10(self.conv10(x)))
        x = F.relu(self.fcl1(x.view(-1, k * 64)))
        x = self.fcl2(x)
        return x.tanh()

def get_states(envs):
    features_vec = np.zeros((BATCH_SIZE, 2, 8, 8), dtype=np.float32)
    for i, env in enumerate(envs):
        env.board.piece_planes(features_vec[i])
    return torch.from_numpy(features_vec).to(device)
```
この最後のreturn torch.from_numpy(features_vec).to(device)のところで、、google colabでは
エラーが出ないのですが、会社のGPUを積んだLinuxだと
RuntimeError: CUDA error: out of memory
CUDA kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect.
For debugging consider passing CUDA_LAUNCH_BLOCKING=1.
というエラーがでます。ググったりして調べたのですが、原因が分かりませんでした。
会社のGPUの環境は、下記の通りです。
-bash-4.2$ lspci | grep -i nvidia
3b:00.0 VGA compatible controller: NVIDIA Corporation TU102 [GeForce RTX 2080 Ti] (rev a1)
3b:00.1 Audio device: NVIDIA Corporation TU102 High Definition Audio Controller (rev a1)
3b:00.2 USB controller: NVIDIA Corporation TU102 USB 3.1 Host Controller (rev a1)
3b:00.3 Serial bus controller [0c80]: NVIDIA Corporation TU102 USB Type-C UCSI Controller (rev a1)
af:00.0 VGA compatible controller: NVIDIA Corporation GP102 [GeForce GTX 1080 Ti] (rev a1)
af:00.1 Audio device: NVIDIA Corporation GP102 HDMI Audio Controller (rev a1)

ご教示いただけますと幸いです。
何卒、よろしくお願い申し上げます。

強化学習でRuntimeError: CUDA error: out of memoryが出る

### 前提・実現したいこと
cuda11.0
cudnn8.0を使用しています
cuda11.0ではtorch1.7.1が対応しているとわかったためインストールしましたがエラーが出ています。
また、下記(python3コマンド)のprint(torch.version.cuda)では10.2と出力しているためそもそもcudaが出来ていないのでしょうか。
申し訳ございませんがご教示いただけないでしょうか。
よろしくお願い致します。

### 発生している問題・エラーメッセージ

```
NVIDIA GeForce RTX 3060 with CUDA capability sm_86 is not compatible with the current PyTorch installation.
The current PyTorch install supports CUDA capabilities sm_37 sm_50 sm_60 sm_70 sm_75.
If you want to use the NVIDIA GeForce RTX 3060 GPU with PyTorch, please check the instructions at https://pytorch.org/get-started/locally/

RuntimeError: CUDA error: no kernel image is available for execution on the device

```
###pip3 list

```
torch                        1.7.1
torchaudio                   0.7.2
torchvision                  0.8.2

```
###python3コマンド
```
Python 3.8.10 (default, Sep 28 2021, 16:10:42) 
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
>>> torch.cuda
<module 'torch.cuda' from '/home/limlab/.local/lib/python3.8/site-packages/torch/cuda/__init__.py'>
>>> torch.cuda.is_available()
True
>>> print(torch.version.cuda)
10.2
>>> torch.backends.cudnn.enabled
True

```

pytorchとcudaの依存関係

win10 
デスクトップpc
pythonコード
jupyterから起動

pytorch opengym使用

機械学習をやっていて長い時には10時間以上かかってしまうことがあるのですが
コード実行中にスリープしコードが停止してしまいます
pythonコードを何時間も動かすにはどうしたらいいですか？
printの表示を見る限り大体一時間20分ぐらいでスリープしていました


あと　なんかのボタンを押すとpcも再び起動しコードも再び動作したように見えました
以前unityで何時間も放置するプログラムを使っていた時にはそのようなことがありませんでした（もしかしたらunityではなく　python APIのほうにその機能があるのかも）

この症状を調べてもos違いや画面が暗くなるについての記事が
が多かったのですが　画面が暗くなる　ではなくpcのほうがスリープします
電源＞スリープを手動で押したときと同様のやつ

pythonコードの実行中にスリープさせたくない

resnetベースで転移学習を行おうとしています。(torchvisionのmodelを使用)
resnet含むImagenet系のモデルを扱う場合、入力サイズを224×224にする必要がある、との記載をよく見るのですが、
サイズを合わせなくても学習/推定が実行でき、かつ、それなりに良い学習ができています。
resizeする時間がもったいないので可能であれば入力サイズを整えずに学習したいのですが、
処理が不明なため判断がついていません。

画像サイズが224×224でない場合、どのような処理を実行しているのでしょうか？
また、どのような問題が発生する可能性があるのでしょうか？
・内部でリサイズしている
・入力画像が小さい場合は、ゼロパディングしている。
・入力画像が大きい場合は、ランダムクロップしている。
など

Resnet 画像サイズが224×224以外の場合の処理

### 実現したいこと
Pytorch初心者です。
以下のモデルを使って画像のスコアを出力したいのですが、エラーが出てしまいます。

使用したいモデル
https://huggingface.co/Eugeoter/waifu-scorer-v3

### 発生している問題・分からないこと
・発生しているエラー
RuntimeError: Error(s) in loading state_dict for MLP:                                                                           Missing key(s) in state_dict: "layers.7.weight", "layers.7.bias".                                                       Unexpected key(s) in state_dict: "layers.8.weight", "layers.8.bias", "layers.10.weight", "layers.10.bias", "layers.10.running_mean", "layers.10.running_var", "layers.10.num_batches_tracked", "layers.12.weight", "layers.12.bias", "layers.14.weight", "layers.14.bias", "layers.14.running_mean", "layers.14.running_var", "layers.14.num_batches_tracked", "layers.16.weight", "layers.16.bias", "layers.18.weight", "layers.18.bias", "layers.2.running_mean", "layers.2.running_var", "layers.2.num_batches_tracked", "layers.6.running_mean", "layers.6.running_var", "layers.6.num_batches_tracked".            size mismatch for layers.0.weight: copying a param with shape torch.Size([2048, 768]) from checkpoint, the shape in current model is torch.Size([1024, 768]).                                                                                   size mismatch for layers.0.bias: copying a param with shape torch.Size([2048]) from checkpoint, the shape in current model is torch.Size([1024]).                                                                                               size mismatch for layers.2.weight: copying a param with shape torch.Size([2048]) from checkpoint, the shape in current model is torch.Size([128, 1024]).                                                                                        size mismatch for layers.2.bias: copying a param with shape torch.Size([2048]) from checkpoint, the shape in current model is torch.Size([128]).                                                                                                size mismatch for layers.4.weight: copying a param with shape torch.Size([512, 2048]) from checkpoint, the shape in current model is torch.Size([64, 128]).                                                                                     size mismatch for layers.4.bias: copying a param with shape torch.Size([512]) from checkpoint, the shape in current model is torch.Size([64]).                                                                                                  size mismatch for layers.6.weight: copying a param with shape torch.Size([512]) from checkpoint, the shape in current model is torch.Size([16, 64]).                                                                                            size mismatch for layers.6.bias: copying a param with shape torch.Size([512]) from checkpoint, the shape in current model is torch.Size([16]).  

こちらのソースコードを使用しました（モデルの説明文に記載されていたため）
https://github.com/christophschuhmann/improved-aesthetic-predictor/blob/main/simple_inference.py




### 該当のソースコード

```python
import numpy as np
import torch
import pytorch_lightning as pl
import torch.nn as nn
from torchvision import datasets, transforms
import clip
from PIL import Image, ImageFile


#####  This script will predict the aesthetic score for this image file:

img_path = "anime.jpg"

# if you changed the MLP architecture during training, change it also here:
class MLP(pl.LightningModule):
    def __init__(self, input_size, xcol='emb', ycol='avg_rating'):
        super().__init__()
        self.input_size = input_size
        self.xcol = xcol
        self.ycol = ycol
        self.layers = nn.Sequential(
            nn.Linear(self.input_size, 1024),
            #nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(1024, 128),
            #nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(128, 64),
            #nn.ReLU(),
            nn.Dropout(0.1),

            nn.Linear(64, 16),
            #nn.ReLU(),

            nn.Linear(16, 1)
        )

    def forward(self, x):
        return self.layers(x)

    def training_step(self, batch, batch_idx):
            x = batch[self.xcol]
            y = batch[self.ycol].reshape(-1, 1)
            x_hat = self.layers(x)
            loss = F.mse_loss(x_hat, y)
            return loss
    
    def validation_step(self, batch, batch_idx):
        x = batch[self.xcol]
        y = batch[self.ycol].reshape(-1, 1)
        x_hat = self.layers(x)
        loss = F.mse_loss(x_hat, y)
        return loss

    def configure_optimizers(self):
        optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)
        return optimizer

def normalized(a, axis=-1, order=2):
    # import numpy as np  # pylint: disable=import-outside-toplevel

    l2 = np.atleast_1d(np.linalg.norm(a, order, axis))
    l2[l2 == 0] = 1
    return a / np.expand_dims(l2, axis)


model = MLP(768)  # CLIP embedding dim is 768 for CLIP ViT L 14
model_path = "waifu-scorer-v3.pth"
if torch.cuda.is_available():
    s = torch.load(model_path)   # load the model you trained previously or the model available in this repo
else:
    s = torch.load((model_path), map_location=torch.device('cpu'))

model.load_state_dict(s)
model.to("cuda")
model.eval()

device = "cuda" if torch.cuda.is_available() else "cpu"
model2, preprocess = clip.load("ViT-L/14", device=device)  #RN50x64   


pil_image = Image.open(img_path)

image = preprocess(pil_image).unsqueeze(0).to(device)



with torch.no_grad():
   image_features = model2.encode_image(image)

im_emb_arr = normalized(image_features.cpu().detach().numpy() )

prediction = model(torch.from_numpy(im_emb_arr).to(device).type(torch.cuda.FloatTensor))

print( "Aesthetic score predicted by the model:")
print( prediction )


```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [x] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
上記のモデルはパラメータのみ保存されており、使用するためには自分でクラスを作成する必要があると認識しています。
しかしながら、どのような層の構造にすれば良いかが分かりません。

### 補足
モデルのOrderedDictは次のようになっています。
layers.0.weight 	 torch.Size([2048, 768])
layers.0.bias 	 torch.Size([2048])
layers.2.weight 	 torch.Size([2048])
layers.2.bias 	 torch.Size([2048])
layers.2.running_mean 	 torch.Size([2048])
layers.2.running_var 	 torch.Size([2048])
layers.2.num_batches_tracked 	 torch.Size([])
layers.4.weight 	 torch.Size([512, 2048])
layers.4.bias 	 torch.Size([512])
layers.6.weight 	 torch.Size([512])
layers.6.bias 	 torch.Size([512])
layers.6.running_mean 	 torch.Size([512])
layers.6.running_var 	 torch.Size([512])
layers.6.num_batches_tracked 	 torch.Size([])
layers.8.weight 	 torch.Size([256, 512])
layers.8.bias 	 torch.Size([256])
layers.10.weight 	 torch.Size([256])
layers.10.bias 	 torch.Size([256])
layers.10.running_mean 	 torch.Size([256])
layers.10.running_var 	 torch.Size([256])
layers.10.num_batches_tracked 	 torch.Size([])
layers.12.weight 	 torch.Size([128, 256])
layers.12.bias 	 torch.Size([128])
layers.14.weight 	 torch.Size([128])
layers.14.bias 	 torch.Size([128])
layers.14.running_mean 	 torch.Size([128])
layers.14.running_var 	 torch.Size([128])
layers.14.num_batches_tracked 	 torch.Size([])
layers.16.weight 	 torch.Size([32, 128])
layers.16.bias 	 torch.Size([32])
layers.18.weight 	 torch.Size([1, 32])
layers.18.bias 	 torch.Size([1])

使用したプログラム
```python
import torch

state_dict = torch.load("waifu-scorer-v3.pth")

# OrderedDict の内容を確認
for param_tensor in state_dict:
    print(param_tensor, "\t", state_dict[param_tensor].size())
```