import numpy as np
import torch

# 從列表創(chuàng)建張量
list_data = [1, 2, 3, 4]
tensor_from_list = torch.tensor(list_data)
print(tensor_from_list) # tensor([1, 2, 3, 4])

# 從NumPy數(shù)組創(chuàng)建張量
np_array = np.array([1, 2, 3])
tensor_from_np_tensor = torch.tensor(np_array)
print(tensor_from_np_tensor) # tensor([1, 2, 3], dtype=torch.int32)

'''
tensor([[0., 0., 0.],
        [0., 0., 0.]])
'''
zeros_tensor = torch.zeros(2, 3)
'''
tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
'''
ones_tensor = torch.ones(3, 4)

'''
tensor([[0.7632, 0.9953, 0.8954],
        [0.8681, 0.7707, 0.8806]])
'''
random_tensor = torch.rand(2, 3)
'''
tensor([[ 0.1873, -1.6907,  0.4717,  1.0271],
        [-1.0680,  0.7490, -0.5693,  0.6490],
        [ 0.0429, -1.5796, -2.3312, -0.2733]])
'''
normal_tensor = torch.randn(3, 4)

arange_tensor = torch.arange(1, 10) #tensor([1, 2, 3, 4, 5, 6, 7, 8, 9])

# 創(chuàng)建一個(gè)張量
tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])

# 索引單個(gè)元素
element = tensor[0, 0]  # 1

# 切片
slice_1 = tensor[0, :]  # [1, 2, 3]
slice_2 = tensor[:, 1]  # [2, 5]

# 修改元素
tensor[0, 0] = 7
print(tensor)  # [[7, 2, 3], [4, 5, 6]]

shape = tensor.shape  # torch.Size([2, 3])

expanded_tensor = tensor.unsqueeze(0)  # 添加一個(gè)新維度，形狀變?yōu)閇1, 2, 3]

reshaped_tensor = tensor.reshape(6)  # 變?yōu)樾螤顬閇6]的一維張量

transposed_tensor = tensor.transpose(0, 1)  # 交換第一和第二維度

addition = tensor + tensor # [[2, 4, 6], [8, 10, 12]]。
  subtraction = tensor - tensor #[[0, 0, 0], [0, 0, 0]]
  multiplication = tensor * tensor #[[1, 4, 9], [16, 25, 36]]
  division = tensor / tensor #[[1, 1, 1], [1, 1, 1]]

elementwise_product = tensor * tensor # [[1, 4, 9], [16, 25, 36]]

matrix_product = tensor @ tensor.t()  # 或者 torch.matmul(tensor, tensor.t())
  # tensor @ tensor.t() 結(jié)果是一個(gè)標(biāo)量，因?yàn)閺埩渴欠疥?，且張量與其轉(zhuǎn)置的點(diǎn)積等于1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32

'''
  結(jié)果是一個(gè)2x3的張量，其中每個(gè)元素都是tensor對(duì)應(yīng)位置的元素加上1
  broadcasted_addition = [[2, 3, 4], [5, 6, 7]]
  '''
  broadcasted_addition = tensor + torch.tensor([1, 1, 1])

# 返回一個(gè)2x3的布爾張量，所有元素都為False，因?yàn)槊總€(gè)元素都不大于自身。
  greater_than = tensor > tensor

sum = torch.sum(tensor) # 返回張量所有元素的總和，即1+2+3+4+5+6=21。
  mean = torch.mean(tensor) #返回張量的平均值，即21/6=3.5。
  # 返回最大值張量[4, 5, 6]和最大值的索引[1, 1, 1]，因?yàn)榈诙械乃性囟际亲畲笾怠?  max_value, max_index = torch.max(tensor, dim=0)  # 按列求最大值和對(duì)應(yīng)索引

import torch

# 創(chuàng)建一個(gè)張量并設(shè)置requires_grad=True
x = torch.tensor([1.0, 2.0], requires_grad=True)
# Original tensor: tensor([1., 2.], requires_grad=True)
print("Original tensor:", x)

import torch

# 創(chuàng)建一個(gè)需要梯度的張量
x = torch.tensor([1.0, 2.0], requires_grad=True)

# 張量操作
y = x + 2  # 加法操作
z = y * y * 3  # 乘法操作
out = z.mean()  # 平均值操作

# 計(jì)算梯度
out.backward()

# 現(xiàn)在，x的梯度已經(jīng)計(jì)算出來(lái)了，可以通過(guò)x.grad屬性獲取
print("Gradient of x with respect to the output:", x.grad)

new_tensor = original_tensor.detach()

with torch.no_grad():
       # 在此區(qū)域內(nèi)進(jìn)行的操作不會(huì)追蹤梯度
       intermediate_result = some_operation(original_tensor)

import torch

# 默認(rèn)情況下，梯度追蹤是開(kāi)啟的
print(f"當(dāng)前梯度追蹤狀態(tài): {torch.is_grad_enabled()}")  # 輸出: True

# 使用set_grad_enabled(False)關(guān)閉梯度追蹤
with torch.autograd.set_grad_enabled(False):
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y = x * 2
    print(f"在上下文中，梯度追蹤狀態(tài): {torch.is_grad_enabled()}")  # 輸出: False
    print(f"y的requires_grad屬性: {y.requires_grad}")  # 輸出: False

# 離開(kāi)上下文后，梯度追蹤狀態(tài)恢復(fù)到之前的狀態(tài)
print(f"離開(kāi)上下文后，梯度追蹤狀態(tài): {torch.is_grad_enabled()}")  # 輸出: True

# 這里x的梯度追蹤仍然是開(kāi)啟的，除非在其他地方被改變

import torch
from torch import nn, optim

# 定義一個(gè)簡(jiǎn)單的線性模型
model = nn.Linear(2, 1)  # 輸入2個(gè)特征，輸出1個(gè)值

# 假設(shè)有一些輸入數(shù)據(jù)和標(biāo)簽
inputs = torch.randn(10, 2)  # 10個(gè)樣本，每個(gè)樣本2個(gè)特征
labels = torch.randn(10, 1)  # 10個(gè)樣本，每個(gè)樣本1個(gè)標(biāo)簽

# 創(chuàng)建優(yōu)化器，指定要更新的模型參數(shù)
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 學(xué)習(xí)率為0.01

# 前向傳播
outputs = model(inputs)

# 損失函數(shù)
loss = nn.MSELoss()(outputs, labels)

# 反向傳播并計(jì)算梯度
loss.backward()

# 使用優(yōu)化器更新參數(shù)
optimizer.step()

# 清除梯度（防止梯度累積）
optimizer.zero_grad()

import torch
import torch.nn as nn

class CustomLayer(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(CustomLayer, self).__init__()

        # 創(chuàng)建線性層
        self.linear = nn.Linear(input_size, hidden_size)

        # 創(chuàng)建ReLU激活函數(shù)
        self.relu = nn.ReLU()

        # 創(chuàng)建輸出線性層（如果需要的話，例如對(duì)于分類任務(wù)）
        self.output_linear = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # 應(yīng)用線性變換
        x = self.linear(x)

        # 應(yīng)用ReLU激活函數(shù)
        x = self.relu(x)

        # 如果需要，可以添加更多的操作，例如另一個(gè)線性層
        x = self.output_linear(x)

        return x

input_size = 10
hidden_size = 20
output_size = 5

model = CustomLayer(input_size, hidden_size, output_size)

import torch
import torch.nn as nn

class SimpleLayer(nn.Module):
    def __init__(self, input_size, output_size):
        super(SimpleLayer, self).__init__()
        self.linear = nn.Linear(input_size, output_size)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.linear(x)
        x = self.relu(x)
        return x

class MLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(MLP, self).__init__()
        
        # 第一層：輸入層到隱藏層
        self.layer1 = SimpleLayer(input_dim, hidden_dim)
        
        # 第二層：隱藏層到輸出層
        self.layer2 = SimpleLayer(hidden_dim, output_dim)

    def forward(self, x):
        x = self.layer1(x)  # 第一層前向傳播
        x = self.layer2(x)  # 第二層前向傳播
        return x

# 實(shí)例化一個(gè)MLP模型
input_dim = 784  # 假設(shè)輸入維度為784（例如，MNIST數(shù)據(jù)集）
hidden_dim = 128  # 隱藏層維度
output_dim = 10  # 輸出維度（例如，10類分類問(wèn)題）
model = MLP(input_dim, hidden_dim, output_dim)

# 打印模型結(jié)構(gòu)
print(model)

import torch
import torch.nn as nn

class ComplexModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(ComplexModel, self).__init__()

        # 創(chuàng)建一個(gè)CustomLayer實(shí)例
        self.custom_layer = CustomLayer(input_size, hidden_size, output_size)

        # 創(chuàng)建一個(gè)MLP實(shí)例
        self.mlp = MLP(hidden_size, hidden_size, output_size)

    def forward(self, x):
        x = self.custom_layer(x)
        x = self.mlp(x)
        return x

# 實(shí)例化一個(gè)ComplexModel
input_size = 784  # 假設(shè)輸入維度為784
hidden_size = 128  # 隱藏層維度
output_size = 10  # 輸出維度
model = ComplexModel(input_size, hidden_size, output_size)

# 打印模型結(jié)構(gòu)
print(model)

model = ComplexModel()
   for param in model.parameters():
       print(param)

model = ComplexModel()
   for name, param in model.named_parameters():
       print(f"Name: {name}, Parameter: {param}")

torch.save(model.state_dict(), 'model.pth')

model = ComplexModel(input_size, hidden_size, output_size)
   model.load_state_dict(torch.load('model.pth'))

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
   model.to(device)

class CustomNormalization(nn.Module):
       def __init__(self, dim):
           super(CustomNormalization, self).__init__()
           self.dim = dim

       def forward(self, x):
           mean = x.mean(dim=self.dim, keepdim=True)
           std = x.std(dim=self.dim, keepdim=True)
           return (x - mean) / (std + 1e-8)

   model.add_module('custom_normalization', CustomNormalization(1))

import torch.optim as optim
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))

optimizer = optim.RMSprop(model.parameters(), lr=0.001, alpha=0.99)

import torch
import torch.nn as nn

# 假設(shè)模型輸出和真實(shí)標(biāo)簽
outputs = model(inputs)  # 模型的預(yù)測(cè)輸出
targets = labels  # 真實(shí)標(biāo)簽

# 定義損失函數(shù)
mse_loss = nn.MSELoss()

# 計(jì)算損失
loss = mse_loss(outputs, targets)

# 假設(shè)模型輸出為每個(gè)類別的概率分布
outputs = model(inputs)
# 確保標(biāo)簽是類別索引（而非one-hot編碼），對(duì)于多分類問(wèn)題
targets = torch.LongTensor(labels)  # 確保標(biāo)簽是整數(shù)

cross_entropy_loss = nn.CrossEntropyLoss()

loss = cross_entropy_loss(outputs, targets)

# 假設(shè)二分類問(wèn)題，直接輸出概率
outputs = model(inputs)  # 輸出已經(jīng)是概率
targets = labels.float()  # 標(biāo)簽轉(zhuǎn)換為float，二分類通常為0或1

bce_loss = nn.BCELoss()

loss = bce_loss(outputs, targets)

import torch
import torch.nn as nn

# 假設(shè)有兩類，其中類0的樣本較少
num_samples = [100, 1000]  # 類別0有100個(gè)樣本，類別1有1000個(gè)樣本
weights = [1 / num_samples[0], 1 / num_samples[1]]  # 計(jì)算類別權(quán)重

# 創(chuàng)建一個(gè)加權(quán)二元交叉熵?fù)p失函數(shù)
weighted_bce_loss = nn.BCEWithLogitsLoss(weight=torch.tensor(weights))

# 假設(shè)model是模型，inputs是輸入數(shù)據(jù)，labels是二進(jìn)制標(biāo)簽（0或1）
outputs = model(inputs)
labels = labels.float()  # 將標(biāo)簽轉(zhuǎn)換為浮點(diǎn)數(shù)，因?yàn)锽CEWithLogitsLoss期望的是概率

# 計(jì)算加權(quán)損失
loss = weighted_bce_loss(outputs, labels)

import torch
import torch.nn as nn

# 假設(shè)有兩個(gè)概率分布，preds是模型預(yù)測(cè)的概率分布，targets是實(shí)際的概率分布
preds = torch.randn(3, 5).softmax(dim=1)  # 預(yù)測(cè)概率分布，使用softmax轉(zhuǎn)換
targets = torch.randn(3, 5).softmax(dim=1)  # 真實(shí)概率分布

# 初始化KLDivLoss實(shí)例，reduction參數(shù)定義了損失的聚合方式，可以是'mean'、'sum'或'none'
criterion = nn.KLDivLoss(reduction='batchmean')  # 'batchmean'表示對(duì)批量數(shù)據(jù)求平均

# 計(jì)算KLDivLoss
loss = criterion(preds.log(), targets)  # 注意：preds應(yīng)該取對(duì)數(shù)，因?yàn)镵LDivLoss默認(rèn)期望log_softmax的輸出

print('KLDivLoss:', loss.item())

import torch
import torch.nn as nn

# 設(shè)置隨機(jī)種子以獲得可復(fù)現(xiàn)的結(jié)果
torch.manual_seed(42)

# 假設(shè)特征維度
feature_dim = 128

# 生成隨機(jī)三元組數(shù)據(jù)
num_triplets = 10
anchors = torch.randn(num_triplets, feature_dim)
positives = torch.randn(num_triplets, feature_dim)
negatives = torch.randn(num_triplets, feature_dim)

# 將它們組合成形狀為 (num_triplets, 3, feature_dim) 的張量
triplets = torch.stack((anchors, positives, negatives), dim=1)

# 初始化三元組損失函數(shù)，設(shè)置邊際值m
triplet_loss = nn.TripletMarginLoss(margin=1.0)

# 計(jì)算損失
loss = triplet_loss(triplets[:, 0], triplets[:, 1], triplets[:, 2])

print('Triplet Margin Loss:', loss.item())

output = model(inputs)
loss = criterion(output, labels)

optimizer.zero_grad()
loss.backward()
optimizer.step()

from torch.utils.data import Dataset

class CustomDataset(Dataset):
    def __init__(self, data, labels, transform=None):
        self.data = data
        self.labels = labels
        self.transform = transform

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        sample = {'data': self.data[idx], 'label': self.labels[idx]}

        if self.transform:
            sample = self.transform(sample)

        return sample

from torch.utils.data import DataLoader
from your_dataset_module import YourCustomDataset

custom_dataset = CustomDataset(data, labels,transform=...)

# 創(chuàng)建DataLoader實(shí)例
data_loader = DataLoader(
    dataset=custom_dataset,  # 數(shù)據(jù)集實(shí)例
    batch_size=32,           # 每個(gè)批次的樣本數(shù)
    shuffle=True,            # 是否在每個(gè)epoch開(kāi)始時(shí)打亂數(shù)據(jù)
    num_workers=4,           # 使用的子進(jìn)程數(shù)，用于數(shù)據(jù)加載（0表示不使用多線程）
    drop_last=False,         # 如果數(shù)據(jù)集大小不能被batch_size整除，是否丟棄最后一個(gè)不完整的batch
)

# 使用data_loader在訓(xùn)練循環(huán)中迭代獲取數(shù)據(jù)
for inputs, labels in data_loader:
    # 在這里執(zhí)行模型訓(xùn)練或驗(yàn)證的代碼
    pass

transform = transforms.Compose([
    transforms.Resize((256, 256)),
    transforms.RandomCrop((224, 224)),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# 將轉(zhuǎn)換應(yīng)用于數(shù)據(jù)集
dataset = CustomDataset(data, labels, transform=transform)

# 定義模型
model = SimpleModel()

# 保存狀態(tài)字典
torch.save(model.state_dict(), 'model_state.pth')

# 保存整個(gè)模型
torch.save(model, 'model.pth')

# 加載狀態(tài)字典
loaded_state_dict = torch.load('model_state.pth')

# 創(chuàng)建相同結(jié)構(gòu)的新模型
new_model = SimpleModel()

# 將加載的狀態(tài)字典加載到新模型
new_model.load_state_dict(loaded_state_dict)

# 加載整個(gè)模型
loaded_model = torch.load('model.pth')

# 在CPU上加載GPU上保存的模型
loaded_model = torch.load('model.pth', map_location=torch.device('cpu'))

# 保存整個(gè)模型（包括結(jié)構(gòu)和參數(shù)）
torch.save(model, 'model.pth')

# 加載整個(gè)模型
loaded_model = torch.load('model.pth')

# 保存模型結(jié)構(gòu)
torch.save(model, 'model_structure.pth', save_model_obj=False)

# 加載模型結(jié)構(gòu)
loaded_model_structure = torch.load('model_structure.pth')

# 保存模型參數(shù)
torch.save(model.state_dict(), 'model_parameters.pth')

# 加載模型參數(shù)
loaded_parameters = torch.load('model_parameters.pth')
model.load_state_dict(loaded_parameters)

import torch.optim as optim
from torch.optim.lr_scheduler import StepLR

# 初始化模型和優(yōu)化器
model = YourModel()
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9)

# 創(chuàng)建 StepLR 調(diào)度器
scheduler = StepLR(optimizer, step_size=5, gamma=0.1)

# 訓(xùn)練循環(huán)
for epoch in range(num_epochs):
    # 訓(xùn)練過(guò)程...

    # 在每個(gè)epoch結(jié)束時(shí)調(diào)用scheduler的step()方法來(lái)更新學(xué)習(xí)率
    scheduler.step()

import torch.optim as optim
from torch.optim.lr_scheduler import MultiStepLR

# 初始化模型和優(yōu)化器
model = YourModel()
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9)

# 創(chuàng)建 MultiStepLR 調(diào)度器
scheduler = MultiStepLR(optimizer, milestones=[10, 20, 30], gamma=0.1)

# 訓(xùn)練循環(huán)
for epoch in range(num_epochs):
    # 訓(xùn)練過(guò)程...

    # 每個(gè)epoch結(jié)束時(shí)調(diào)用scheduler的step()方法檢查是否需要調(diào)整學(xué)習(xí)率
    scheduler.step()

import torch.optim as optim
from torch.optim.lr_scheduler import ExponentialLR

# 初始化模型和優(yōu)化器
model = YourModel()
optimizer = optim.SGD(model.parameters(), lr=initial_lr, momentum=0.9)

# 創(chuàng)建 ExponentialLR 調(diào)度器
# 其中 gamma 參數(shù)指定了學(xué)習(xí)率衰減的速率，例如 gamma=0.9 表示每經(jīng)過(guò)一個(gè)調(diào)整周期，學(xué)習(xí)率變?yōu)樵瓉?lái)的 90%
scheduler = ExponentialLR(optimizer, gamma=0.9)

# 訓(xùn)練循環(huán)
for epoch in range(num_epochs):
    # 訓(xùn)練過(guò)程...

    # 每個(gè)epoch結(jié)束時(shí)調(diào)用scheduler的step()方法更新學(xué)習(xí)率
    scheduler.step()

import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR

# 假設(shè)的模型定義
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.linear = nn.Linear(10, 1)

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

# 實(shí)例化模型和優(yōu)化器
model = SimpleModel()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 創(chuàng)建學(xué)習(xí)率調(diào)整器
scheduler = StepLR(optimizer, step_size=5, gamma=0.1)  # 每5個(gè)epoch學(xué)習(xí)率減半

# 訓(xùn)練循環(huán)
num_epochs = 30
for epoch in range(num_epochs):
    # 假設(shè)的訓(xùn)練步驟，這里簡(jiǎn)化處理
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = F.mse_loss(output, target)
        loss.backward()
        optimizer.step()

    # 每個(gè)epoch結(jié)束時(shí)更新學(xué)習(xí)率
    scheduler.step()
    print(f"Epoch [{epoch+1}/{num_epochs}], LR: {scheduler.get_last_lr()[0]}")

model.eval()

model.eval()

with torch.no_grad():
    for inputs, labels in dataloader:
        outputs = model(inputs)
        # 進(jìn)行后續(xù)處理..

import torch

# 假設(shè) outputs 和 labels 都是形狀為 (batch_size,) 的張量
# 對(duì)于多分類問(wèn)題，outputs 通常包含每個(gè)類別的概率，需要獲取預(yù)測(cè)類別
_, predicted = torch.max(outputs.data, 1)

# 將預(yù)測(cè)和真實(shí)標(biāo)簽轉(zhuǎn)換為相同的數(shù)據(jù)類型（例如，都轉(zhuǎn)為整數(shù)）
if isinstance(predicted, torch.Tensor):
    predicted = predicted.cpu().numpy()
if isinstance(labels, torch.Tensor):
    labels = labels.cpu().numpy()

# 計(jì)算并輸出準(zhǔn)確率
accuracy = (predicted == labels).sum() / len(labels)
print(f'Accuracy: {accuracy}')

from sklearn.metrics import precision_score

# 假設(shè) predictions 和 true_labels 是形狀為 (n_samples,) 的數(shù)組
# predictions 是模型的預(yù)測(cè)結(jié)果，true_labels 是對(duì)應(yīng)的真值標(biāo)簽
# 如果是多分類問(wèn)題，labels 參數(shù)是所有類別的列表

# 二分類問(wèn)題
precision_binary = precision_score(true_labels, predictions)

# 多分類問(wèn)題，宏平均
precision_macro = precision_score(true_labels, predictions, average='macro')

# 多分類問(wèn)題，微平均
precision_micro = precision_score(true_labels, predictions, average='micro')

print(f'Binary Precision: {precision_binary}')
print(f'Macro Average Precision: {precision_macro}')
print(f'Micro Average Precision: {precision_micro}')

from sklearn.metrics import recall_score

# 假設(shè) predictions 和 true_labels 是形狀為 (n_samples,) 的數(shù)組
# predictions 是模型的預(yù)測(cè)結(jié)果，true_labels 是對(duì)應(yīng)的真值標(biāo)簽
# 對(duì)于多分類問(wèn)題，labels 參數(shù)是所有類別的列表

# 二分類問(wèn)題
recall_binary = recall_score(true_labels, predictions)

# 多分類問(wèn)題，宏平均
recall_macro = recall_score(true_labels, predictions, average='macro')

# 多分類問(wèn)題，微平均
recall_micro = recall_score(true_labels, predictions, average='micro')

print(f'Binary Recall: {recall_binary}')
print(f'Macro Average Recall: {recall_macro}')
print(f'Micro Average Recall: {recall_micro}')

from sklearn.metrics import f1_score

# 假設(shè) predictions 和 true_labels 是形狀為 (n_samples,) 的數(shù)組
# predictions 是模型的預(yù)測(cè)結(jié)果，true_labels 是對(duì)應(yīng)的真值標(biāo)簽
# 對(duì)于多分類問(wèn)題，labels 參數(shù)是所有類別的列表

# 二分類問(wèn)題
f1_binary = f1_score(true_labels, predictions)

# 多分類問(wèn)題，宏平均
f1_macro = f1_score(true_labels, predictions, average='macro')

# 多分類問(wèn)題，微平均
f1_micro = f1_score(true_labels, predictions, average='micro')

print(f'Binary F1 Score: {f1_binary}')
print(f'Macro Average F1 Score: {f1_macro}')
print(f'Micro Average F1 Score: {f1_micro}')

from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt

# 假設(shè) y_true 是二分類的真值標(biāo)簽，y_scores 是模型的得分或概率輸出
y_true = [0, 1, 1, 0, 1, 0, 1, 1, 0, 1]  # 真實(shí)標(biāo)簽
y_scores = [0.1, 0.4, 0.35, 0.8, 0.6, 0.1, 0.9, 0.7, 0.2, 0.5]  # 模型得分

# 計(jì)算ROC曲線的點(diǎn)
fpr, tpr, thresholds = roc_curve(y_true, y_scores)

# 計(jì)算ROC曲線下面積（AUC）
roc_auc = auc(fpr, tpr)

# 繪制ROC曲線
plt.plot(fpr, tpr, label=f'ROC curve (area = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], 'k--')  # 繪制隨機(jī)猜測(cè)的ROC曲線
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic')
plt.legend(loc="lower right")
plt.show()