Détection de chute - entièrement développé avec ChatGPT, partagez comment poser correctement des questions à ChatGPT

Bonjour à tous.

J'ai déjà partagé avec vous la reconnaissance des chutes et la reconnaissance des combats. Aujourd'hui, nous prendrons la reconnaissance des chutes comme exemple pour voir si nous pouvons complètement laisser le soin à ChatGPT.

Laissez ChatGPT faire cela. La chose la plus importante est de savoir comment poser des questions à ChatGPT. Par exemple : il n'est pas conseillé d'écrire un code de détection de chute en Python, mais cela devrait être comme l'extraire. dentifrice. , guidez ChatGPT étape par étape pour obtenir des réponses précises, afin que ChatGPT puisse réellement améliorer notre efficacité dans la résolution des problèmes.

Le cas de reconnaissance des chutes partagé aujourd'hui a une idée claire du dialogue avec ChatGPT et d'une grande convivialité du code. Selon les résultats renvoyés par GPT, un projet de reconnaissance des chutes peut être développé, et il existe également des sujets étendus, tels que : Points d'amélioration de Bi She.

Le partage officiel commence ci-dessous.

1. Paramètre de rôle

Pour poser une question à ChatGPT, vous devez d'abord lui donner un paramètre de rôle. Dans le champ de l'algorithme, cela s'appelle une invite. Ce n'est qu'en entrant le rôle que vous pourrez mieux répondre à la question. Donc, la première phrase de ma question est :

Si vous êtes un ingénieur en IA, je souhaite identifier s'il y a une chute dans la vidéo, quelles sont les méthodes

Il n'est pas nécessaire de lui demander d'écrire le code ? directement lorsqu'il arrive, demandez d'abord Quelles méthodes ou quelles idées a-t-il ?

Jetons un coup d'œil à la réponse de ChatGPT

donne 3 solutions, y compris les méthodes d'image traditionnelles et les méthodes d'apprentissage en profondeur.

2. Conseils d'idées

Bien sûr, nous sommes intéressés par l'apprentissage profond, nous continuons donc à poser des questions sur les méthodes d'apprentissage profond

Quelles sont les méthodes d'utilisation de l'apprentissage profond

Réponse ChatGPT

Du réseau neuronal convolutif au Le réseau neuronal convolutif récurrent a été évoqué partout.

Il semble que le réseau neuronal récurrent RNN ​​est plus simple et plus fiable. Ma prochaine question est

J'ai besoin de la méthode du réseau neuronal récurrent (RNN)

Réponse ChatGPT

donne un fonctionnement très détaillé et pratique. Je vais brièvement classer ces étapes très spécifiques, qui sont grosso modo en deux étapes :

La première étape consiste à prétraiter la vidéo et à utiliser un réseau neuronal convolutionnel (tel que ResNet) pour extraire les fonctionnalités d'action vidéo (similaires à l'intégration de mots). L'étape consiste à utiliser les fonctionnalités d'action comme entrée du modèle lstm, à entraîner le réseau neuronal récurrent lstm, à classer les fonctionnalités d'action et à identifier les comportements de chute

3 Écrire du code

Jusqu'à présent, ChatGPT nous a fourni une idée très claire de. ​​​​résoudre le problème. Et c’est très exécutoire.

Donc, nous pouvons maintenant laisser ChatGPT écrire du code.

Selon les étapes que j'ai divisées ci-dessus, je lui ai demandé d'écrire le code de la première étape à la fois, donc ma question est la suivante :

Écrivez le code pour le prétraitement vidéo et utilisez pytorch resnet pour extraire les fonctionnalités vidéo

Réponse de ChatGPT

好的，下面是通过 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()
# 取固定帧数 n_frames，超过后从中间开始截取
n_frames = min(len(frames), n_frames)
start = (len(frames) - n_frames) // 2
end = start + n_frames
# 截取帧数后堆叠成四维数组
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，并调整为指定的数据类型和范围
frames = torch.from_numpy(frames).float() / 255.0
# 减去 ImageNet 数据集的均值和标准差
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() 函数将读取视频，并将其转换为指定大小的图像帧，返回处理后的数据；extract_features() 函数将接受上一步处理后的数据，并将其转化为 Pytorch 的 Tensor，使用训练好的 ResNet 模型对每一帧图像进行特征提取，并返回一个形状为 (B, 2048) 的 Tensor，其中 B 为帧数。

L'image est trop longue. Afin que tout le monde puisse mieux comprendre la réponse de ChatGPT, j'ai directement posté le texte du code.

Définissez deux fonctions indépendantes, qui complètent respectivement les deux petites étapes de la première étape.

Il n'y a aucun problème avec le code. Appelez d'abord la fonction preprocess_video pour prétraiter la vidéo, puis appelez l'opération de convolution extract_features pour intégrer un vecteur dans un vecteur de 2048 dimensions.

La deuxième étape, je l'ai divisée en deux petites étapes, je construis d'abord le modèle lstm, puis je m'entraîne

Sur la base des résultats produits ci-dessus, j'utilise pytorch lstm pour construire le modèle de classification vidéo

Réponse de ChatGPT

Écrivez-le Le code pour la formation des modèles

Réponse de ChatGPT

好的，下面是使用 Pytorch 训练视频分类模型的代码：

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

# 训练函数
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))

# 定义超参数
BATCH_SIZE = 4
NUM_EPOCHS = 20

# 定义数据集，假设已经准备好了训练数据集和测试数据集
train_dataset = ...
test_dataset = ...

# 定义数据加载器
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)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# 训练模型
train(model, criterion, optimizer, train_dataloader, num_epochs=NUM_EPOCHS)
在代码中，首先定义了模型的超参数，如 BATCH_SIZE 和 NUM_EPOCHS。接着定义了训练数据集和测试数据集，并使用 Pytorch 的 DataLoader 将数据加载为 batch。然后定义了模型、损失函数和优化器。最后调用 train() 函数进行模型训练。

在训练过程中，每个 epoch 循环训练所有的视频帧，计算损失函数，计算准确率，并输出当前 epoch 的平均损失和准确率。训练完成后，可以将模型的参数保存到磁盘上，以便以后使用。

La convivialité du code est très élevée. À l'exception du coût de concaténation de code, chaque module indépendant n'a fondamentalement pas besoin d'être déplacé et l'efficacité du développement est très efficace.

Vous pouvez également demander à ChatGPT de trouver des ensembles de données

Vous pouvez également lui demander d'écrire le code pour l'inférence du modèle

Il peut automatiquement nous aider à enchaîner les trois parties du prétraitement vidéo, de l'extraction des fonctionnalités et l'inférence forment un projet complet.

4. Expansion

Jusqu'à présent, nous avons complètement terminé le projet en utilisant ChatGPT.

Nous pouvons également parler de certains sujets étendus, tels que :

Vous pouvez également demander à ChatGPT de nous aider à réfléchir à certains points qui peuvent mettre en valeur la valeur académique

Voir cela signifie que mon article vous est quelque peu utile. Que je rejoigne Planet ou non, je suis reconnaissant de la reconnaissance et de la confiance de chacun en moi.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!