好的，下面是通過 Pytorch 的 ResNet 提取視頻特征的代碼，以及視頻預處理的示例代碼：

視頻預處理：

import cv2
import numpy as np

def preprocess_video(video_path, n_frames=16, resize=(224, 224)):
    # 讀取視頻
    cap = cv2.VideoCapture(video_path)
    frames = []
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        # 強制轉換為 RGB
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        # 圖像縮放
        frame = cv2.resize(frame, resize)
        # 圖像增強等操作
        # ...
        frames.append(frame)
    cap.release()
    # 取固定幀數(shù) n_frames，超過后從中間開始截取
    n_frames = min(len(frames), n_frames)
    start = (len(frames) - n_frames) // 2
    end = start + n_frames
    # 截取幀數(shù)后堆疊成四維數(shù)組
    frames = np.stack(frames[start:end], axis=0)
    # 轉換為支持 Pytorch 模型的格式 (B, C, T, H, W)
    frames = np.transpose(frames, (0, 3, 1, 2))
    return frames
提取視頻特征：

import torch
import torchvision.models as models

def extract_features(frames):
    # 加載 ResNet 模型
    resnet = models.resnet50(pretrained=True)
    # 去掉最后的全連接層
    resnet = torch.nn.Sequential(*list(resnet.children())[:-1])
    # 將 ResNet 設置為評估模式
    resnet.eval()
    # 將預處理后的視頻序列轉化為 Tensor，并調(diào)整為指定的數(shù)據(jù)類型和范圍
    frames = torch.from_numpy(frames).float() / 255.0
    # 減去 ImageNet 數(shù)據(jù)集的均值和標準差
    normalize = torch.nn.Normalize(
        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
    )
    frames = normalize(frames)
    # 前向預測，輸出 2048 維特征向量
    with torch.no_grad():
        features = resnet(frames)
    return features.reshape(-1, 2048)
在上面這兩塊代碼中，preprocess_video() 函數(shù)將讀取視頻，并將其轉換為指定大小的圖像幀，返回處理后的數(shù)據(jù)；extract_features() 函數(shù)將接受上一步處理后的數(shù)據(jù)，并將其轉化為 Pytorch 的 Tensor，使用訓練好的 ResNet 模型對每一幀圖像進行特征提取，并返回一個形狀為 (B, 2048) 的 Tensor，其中 B 為幀數(shù)。

好的，下面是使用 Pytorch 訓練視頻分類模型的代碼：

import torch
import torch.nn as nn
import torch.optim as optim

# 訓練函數(shù)
def train(model, criterion, optimizer, dataloader, num_epochs=10):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)  # 將模型移動到 GPU 或 CPU 上
    for epoch in range(num_epochs):
        running_loss = 0.0
        correct_predictions = 0
        total_predictions = 0
        for inputs, labels in dataloader:
            inputs = inputs.to(device)
            labels = labels.to(device)

            optimizer.zero_grad()

            with torch.set_grad_enabled(True):
                outputs = model(inputs)
                _, preds = torch.max(outputs, 1)
                loss = criterion(outputs, labels)

                loss.backward()
                optimizer.step()

            running_loss += loss.item() * inputs.size(0)
            correct_predictions += torch.sum(preds == labels.data)
            total_predictions += labels.size(0)

        epoch_loss = running_loss / len(dataloader.dataset)
        epoch_acc = correct_predictions.double() / total_predictions

        print("Epoch {}: Loss {:.4f} Acc: {:.4f}".format(epoch + 1, epoch_loss, epoch_acc))

# 定義超參數(shù)
BATCH_SIZE = 4
NUM_EPOCHS = 20

# 定義數(shù)據(jù)集，假設已經(jīng)準備好了訓練數(shù)據(jù)集和測試數(shù)據(jù)集
train_dataset = ...
test_dataset = ...

# 定義數(shù)據(jù)加載器
train_dataloader = torch.utils.data.DataLoader(
    train_dataset, batch_size=BATCH_SIZE, shuffle=True
)
test_dataloader = torch.utils.data.DataLoader(
    test_dataset, batch_size=BATCH_SIZE, shuffle=False
)

# 定義模型
input_size = 2048
hidden_size = 512
num_layers = 1
num_classes = 2
model = VideoLSTM(input_size, hidden_size, num_layers, num_classes)

# 定義損失函數(shù)和優(yōu)化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# 訓練模型
train(model, criterion, optimizer, train_dataloader, num_epochs=NUM_EPOCHS)
在代碼中，首先定義了模型的超參數(shù)，如 BATCH_SIZE 和 NUM_EPOCHS。接著定義了訓練數(shù)據(jù)集和測試數(shù)據(jù)集，并使用 Pytorch 的 DataLoader 將數(shù)據(jù)加載為 batch。然后定義了模型、損失函數(shù)和優(yōu)化器。最后調(diào)用 train() 函數(shù)進行模型訓練。

在訓練過程中，每個 epoch 循環(huán)訓練所有的視頻幀，計算損失函數(shù)，計算準確率，并輸出當前 epoch 的平均損失和準確率。訓練完成后，可以將模型的參數(shù)保存到磁盤上，以便以后使用。