使用python写一个3d视频动作分类识别的代码，预处理视频代码文件和训练代码文件

以下是一个简单的Python代码示例，用于预处理3D视频数据和训练3D卷积神经网络模型，以进行视频动作分类识别。

## 预处理视频数据

import cv2
import numpy as np
import os

# 定义函数，用于加载视频并将其转换为numpy数组
def load_video(path):
    cap = cv2.VideoCapture(path)
    frames = []
    
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        frame = cv2.resize(frame, (128, 128))
        frames.append(frame)
    
    cap.release()
    
    return np.array(frames)

# 定义函数，用于将视频数据保存为npy文件
def preprocess_videos(input_dir, output_dir):
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
    
    for foldername in os.listdir(input_dir):
        folderpath = os.path.join(input_dir, foldername)
        for filename in os.listdir(folderpath):
            filepath = os.path.join(folderpath, filename)
            video = load_video(filepath)
            np.save(os.path.join(output_dir, foldername, filename[:-4]), video)

此代码将读取一个目录中的所有视频文件，并将每个视频转换为numpy数组，然后保存为npy文件。在这里，我们假设每个视频都是128x128像素大小的灰度图像。

## 训练3D卷积神经网络模型

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import os

class VideoDataset(Dataset):
    def __init__(self, input_dir):
        self.data = []
        for foldername in os.listdir(input_dir):
            folderpath = os.path.join(input_dir, foldername)
            for filename in os.listdir(folderpath):
                filepath = os.path.join(folderpath, filename)
                self.data.append((filepath, int(foldername)))
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        filepath, label = self.data[idx]
        video = np.load(filepath)
        video = np.expand_dims(video, axis=0)
        return torch.from_numpy(video), label

class Conv3DNet(nn.Module):
    def __init__(self):
        super(Conv3DNet, self).__init__()
        
        self.conv1 = nn.Conv3d(in_channels=1, out_channels=16, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm3d(16)
        self.relu1 = nn.ReLU(inplace=True)
        self.pool1 = nn.MaxPool3d(kernel_size=2, stride=2)
        
        self.conv2 = nn.Conv3d(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1)
        self.bn2 = nn.BatchNorm3d(32)
        self.relu2 = nn.ReLU(inplace=True)
        self.pool2 = nn.MaxPool3d(kernel_size=2, stride=2)
        
        self.conv3 = nn.Conv3d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)
        self.bn3 = nn.BatchNorm3d(64)
        self.relu3 = nn.ReLU(inplace=True)
        self.pool3 = nn.MaxPool3d(kernel_size=2, stride=2)
        
        self.fc1 = nn.Linear(in_features=64*4*4*4, out_features=256)
        self.fc2 = nn.Linear(in_features=256, out_features=10)
        
    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu1(x)
        x = self.pool1(x)
        
        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu2(x)
        x = self.pool2(x)
        
        x = self.conv3(x)
        x = self.bn3(x)
        x = self.relu3(x)
        x = self.pool3(x)
        
        x = x.view(-1, 64*4*4*4)
        x = self.fc1(x)
        x = self.relu1(x)
        x = self.fc2(x)
        
        return x

# 定义函数，用于训练模型
def train_model(model, dataloader, optimizer, criterion, device):
    model.train()
    running_loss = 0.0
    running_corrects = 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)
        running_corrects += torch.sum(preds == labels.data)
    
    epoch_loss = running_loss / len(dataloader.dataset)
    epoch_acc = running_corrects.double() / len(dataloader.dataset)
    
    return epoch_loss, epoch_acc

# 定义函数，用于评估模型
def evaluate_model(model, dataloader, criterion, device):
    model.eval()
    running_loss = 0.0
    running_corrects = 0
    
    with torch.set_grad_enabled(False):
        for inputs, labels in dataloader:
            inputs = inputs.to(device)
            labels = labels.to(device)
            
            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)
            loss = criterion(outputs, labels)
            
            running_loss += loss.item() * inputs.size(0)
            running_corrects += torch.sum(preds == labels.data)
    
    epoch_loss = running_loss / len(dataloader.dataset)
    epoch_acc = running_corrects.double() / len(dataloader.dataset)
    
    return epoch_loss, epoch_acc

# 定义主函数，用于训练和评估模型
def main():
    input_dir = 'path/to/preprocessed/videos'
    output_dir = 'path/to/save/model'
    batch_size = 32
    num_epochs = 10
    
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    dataset = VideoDataset(input_dir)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
    
    model = Conv3DNet()
    model.to(device)
    
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    best_acc = 0.0
    
    for epoch in range(num_epochs):
        train_loss, train_acc = train_model(model, dataloader, optimizer, criterion, device)
        val_loss, val_acc = evaluate_model(model, dataloader, criterion, device)
        
        if val_acc > best_acc:
            best_acc = val_acc
            torch.save(model.state_dict(), os.path.join(output_dir, 'best_model.pth'))
        
        print('Epoch [{}/{}], Train Loss: {:.4f}, Train Acc: {:.4f}, Val Loss: {:.4f}, Val Acc: {:.4f}'
              .format(epoch+1, num_epochs, train_loss, train_acc, val_loss, val_acc))

if __name__ == '__main__':
    main()

此代码将加载预处理后的视频数据，并将其作为数据集传递给DataLoader。然后，它会定义一个Conv3DNet模型，并在训练和验证阶段使用train_model和evaluate_model函数进行训练和评估。最后，它将保存最佳模型的权重，并输出每个时期的训练和验证损失以及准确性。