Sturzerkennung – vollständig mit ChatGPT entwickelt. Erfahren Sie, wie Sie ChatGPT richtig Fragen stellen

Hallo zusammen.

Ich habe Ihnen bereits die Sturzerkennung und die Kampferkennung mitgeteilt. Heute werden wir die Sturzerkennung als Beispiel nehmen, um zu sehen, ob wir sie vollständig ChatGPT überlassen können.

Lassen Sie ChatGPT dies tun. Das Wichtigste ist, wie Sie alle Fragen direkt an ChatGPT stellen. Es ist nicht ratsam, einen Sturzerkennungscode in Python zu schreiben, aber es sollte wie ein Ausquetschen sein Zahnpasta, führen Sie ChatGPT Schritt für Schritt, um genaue Antworten zu erhalten, damit ChatGPT unsere Effizienz bei der Lösung von Problemen wirklich verbessern kann.

Der heute geteilte Sturzerkennungsfall hat eine klare Vorstellung vom Dialog mit ChatGPT und einer hohen Code-Benutzerfreundlichkeit. Gemäß den von GPT zurückgegebenen Ergebnissen kann ein Sturzerkennungsprojekt entwickelt werden, und es gibt auch einige erweiterte Themen, wie zum Beispiel: Bi She Verbesserungspunkte.

Die offizielle Weitergabe beginnt unten.

1. Rolleneinstellung

Um ChatGPT eine Frage zu stellen, müssen Sie ihm zunächst eine Rolleneinstellung geben. Dies wird als Eingabeaufforderung bezeichnet. Nur durch die Eingabe der Rolle können Sie die Frage besser beantworten. Der erste Satz meiner Frage lautet also:

Wenn Sie ein KI-Ingenieur sind, möchte ich feststellen, ob das Video einen Absturz aufweist und welche Methoden es gibt.

Es besteht keine Notwendigkeit, ihn zu bitten, den Code direkt zu schreiben Wenn er auftaucht, fragen Sie zuerst: Welche Methoden oder Ideen hat er?

Werfen wir einen Blick auf die Antwort von ChatGPT

bietet 3 Lösungen, darunter traditionelle Bildmethoden und Deep-Learning-Methoden.

2. Ideenberatung

Natürlich sind wir an Deep Learning interessiert, daher fragen wir weiterhin nach Deep Learning-Methoden

Welche Methoden gibt es für die Verwendung von Deep Learning? ChatGPT-Antwort: Vom Faltungs-Neuronalen Netzwerk bis Über das Faltungs-Rekurrenten-Neuronale-Netzwerk wurde überall gesprochen.

Es scheint, dass das wiederkehrende neuronale Netzwerk (RNN) einfacher und zuverlässiger ist. Meine nächste Frage ist:

Ich brauche die Methode des wiederkehrenden neuronalen Netzwerks (RNN). Die ChatGPT-Antwort bietet eine sehr detaillierte und praktische Bedienung Ich werde diese sehr spezifischen Schritte, die grob zwei Schritte sind, kurz klassifizieren:

Der erste Schritt besteht darin, das Video vorzuverarbeiten und ein Faltungs-Neuronales Netzwerk (wie ResNet) zu verwenden, um Videoaktionsfunktionen zu extrahieren (ähnlich der Worteinbettung). Der Schritt besteht darin, Aktionsfunktionen als Eingabe für das lstm-Modell zu verwenden, das wiederkehrende neuronale Netzwerk von lstm zu trainieren, die Aktionsfunktionen zu klassifizieren und fallende Verhaltensweisen zu identifizieren

3. Code schreiben

Bisher hat uns ChatGPT eine sehr klare Vorstellung davon geliefert ​​​​Das Problem wird gelöst.

Jetzt können wir ChatGPT Code schreiben lassen.

Gemäß den Schritten, die ich oben aufgeteilt habe, habe ich ihn gebeten, den Code für den ersten Schritt sofort zu schreiben. Meine Frage lautet also:

Schreiben Sie den Code für die Videovorverarbeitung und verwenden Sie Pytorch Resnet, um Videofunktionen zu extrahieren.

ChatGPTs Antwort.

好的，下面是通过 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 为帧数。

Das Bild ist zu lang, damit jeder die Antwort von ChatGPT besser verstehen kann. Ich habe den Codetext direkt gepostet.

Definieren Sie zwei unabhängige Funktionen, die jeweils die beiden kleinen Schritte im ersten Schritt ausführen.

Es gibt kein Problem mit dem Code. Rufen Sie zuerst die Funktion preprocess_video auf, um das Video vorzuverarbeiten, und rufen Sie dann die Faltungsoperation extract_features auf, um einen Vektor in einen 2048-dimensionalen Vektor einzubetten.

Im zweiten Schritt teile ich ihn in zwei kleine Schritte auf, erstelle zuerst das lstm-Modell und trainiere dann

Basierend auf den oben erzielten Ergebnissen verwende ich Pytorch lstm, um das Videoklassifizierungsmodell zu erstellen

ChatGPTs Antwort

Schreiben Sie den Code für das Modelltraining auf

ChatGPTs Antwort

好的，下面是使用 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 的平均损失和准确率。训练完成后，可以将模型的参数保存到磁盘上，以便以后使用。

Die Benutzerfreundlichkeit des Codes ist sehr hoch. Abgesehen von den Kosten für die Codeverkettung muss grundsätzlich nicht jedes einzelne Modul verschoben werden, und die Entwicklungseffizienz ist sehr effizient.

Sie können ChatGPT auch bitten, einige Datensätze zu finden

Sie können ihn auch bitten, den Code für die Modellinferenz zu schreiben

Er kann uns automatisch dabei helfen, die drei Teile der Videovorverarbeitung und Merkmalsextraktion zusammenzuführen und Schlussfolgerung bilden ein vollständiges Projekt.

4. Erweiterung

Bis zu diesem Zeitpunkt haben wir das Projekt vollständig mit ChatGPT abgeschlossen.

Wir können auch über einige erweiterte Themen sprechen, wie zum Beispiel:

Sie können ChatGPT auch bitten, uns dabei zu helfen, einige Punkte zu finden, die den akademischen Wert hervorheben können.

Wenn Sie dies sehen, bedeutet dies, dass mein Artikel für Sie einigermaßen hilfreich ist. Unabhängig davon, ob ich Planet beitrete oder nicht, bin ich für die Anerkennung und das Vertrauen aller dankbar.

Das obige ist der detaillierte Inhalt vonSturzerkennung – vollständig mit ChatGPT entwickelt. Erfahren Sie, wie Sie ChatGPT richtig Fragen stellen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!