初心者です。pytorchで作成したAI　モデルの感度特異度を算出したいがやり方がわからない

実現したいこと

作成したモデルの感度特異度を算出したい

前提

pytorch勉強中の初心者です。
簡単な予測モデルを作りました。accuracyの計算はなんとかできたのですが、感度特異度の計算方法が調べてもよくわかりません。

発生している問題・エラーメッセージ

インターネットで以下のライブラリから混合行列がだせるとかいてあったのでやってみたのですが、エラーを出してしまいます。
from sklearn.metrics import confusion_matrix
confusion_matrix(t, y_label)

エラーメッセージ
```TypeError: can't convert cuda:0 device type tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first.

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

```python
ソースコード


import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data as data_utils
import numpy as np
import torchvision
import torchvision.transforms as transforms
import pandas as pd 
df = pd.read_csv('parameter.csv')  

print(df.info())


x = torch.FloatTensor(df.drop('h', axis=1).values)
y = torch.LongTensor(df['h'].values)
type(x),type(y)


dataset = torch.utils.data.TensorDataset(x, y)
dataset[0]


n_train = int(len(dataset)*0.6)
n_val = int(len(dataset)*0.2)
n_test = len(dataset) - n_train - n_val


train, val, test = torch.utils.data.random_split(dataset,[n_train, n_val, n_test])
len(train), len(val), len(test)

#ミニバッチ学習
batch_size = 10
                                                        
train_loader = torch.utils.data.DataLoader(train, batch_size, shuffle=True, drop_last=True)
val_loader = torch.utils.data.DataLoader(val, batch_size)
test_loader = torch.utils.data.DataLoader(test, batch_size)

#ネットワークを定義する
class Net(nn.Module):
  
  def __init__(self):
   super().__init__()
   self.fc1 = nn.Linear(27,27)
   self.fc2 = nn.Linear(27,2)

   #順伝播       
  def forward(self, x):
    h = self.fc1(x)
    h = F.relu(h)
    h = self.fc2(x)
    
    return h

#ネットワークをインスタンス化
net = Net()
net

#最適化手法　　　　　　　　　　　　　　　　　　学習係数
optimizer  = torch.optim.SGD(net.parameters(), lr=0.1)
batch = next(iter(train_loader))
x, t = batch
x,t

y=net.forward(x) #予測値の算出
y

loss = F.cross_entropy(y,t)
loss

loss.backward()#勾配の算出

#パラメーターの更新
optimizer.step()

torch.cuda.is_available()

device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

net.to(device)
x = x.to(device)
t = t.to(device)

#勾配情報の初期化
optimizer.zero_grad()

#エポック数
max_epoch = 10
#モデルのインスタンス化とデバイスへの転送
net = Net().to(device)
#最適化手法
optimizer = torch.optim.SGD(net.parameters(), lr=0.1)

#学習のループ
for epoch in range(max_epoch):
  
  for batch in train_loader:

    x, t = batch

    x = x.to(device)
    t = t.to(device)

    y = net(x)

    loss = F.cross_entropy(y, t)

    
    optimizer.zero_grad()

    loss.backward()

    optimizer.step()

x, t = next(iter(train_loader))
x = x.to(device)
t = t.to(device)
y = net(x)
y

y_label = torch.argmax(y, dim=1)
y_label

(y_label == t).sum().float()

#正解率を計算する関数
def calc_accuracy(data_loader):

    with torch.no_grad():
       total = 0
       correct =0.0

       for batch in data_loader:
           x, t = batch
           x = x.to(device)
           t = t.to(device)
           y = net(x)

           y_label = torch.argmax(y, dim=1)
           total += len(t)
           correct += (y_label == t).sum()
        
       #全体の平均を算出
       accuracy = correct / total

    return accuracy

net.eval()

**from sklearn.metrics import confusion_matrix
confusion_matrix(t, y_label)**


calc_accuracy(val_loader) #評価データの正解率

calc_accuracy(test_loader)#テストデータの正解率

calc_sensitivity(test_loader)

試したこと

関数を直せば計算できるらしいが、条件がわからず困っている。

def calc_sensitivity(data_loader):

    with torch.no_grad():
       total = 0
       correct =0.0

       for batch in data_loader:
           x, t = batch
           x = x.to(device)
           t = t.to(device)
           y = net(x)

           y_label = torch.argmax(y, dim=1)
           Positive += (t ==1).sum
           True_positive += 　**＃ここがどのような条件式でできるのかわからない**
        
       #感度を算出
       sensitivity = True_positive / Positive

    return sensitivity```

### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。