class Car:
    # 类是一个模板，描述车的属性和行为
    pass

# 实例化类，生成对象
my_car = Car()

class Dog:
    # 初始化方法，定义属性
    def __init__(self, name, breed):
        self.name = name  # 属性1
        self.breed = breed  # 属性2

    # 定义方法
    def bark(self):
        print(f"{self.name} is barking!")

# 创建对象
dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Max", "Beagle")

# 调用对象的方法
dog1.bark()  # 输出：Buddy is barking!
dog2.bark()  # 输出：Max is barking!

class Circle:
    pi = 3.14  # 类变量

    def __init__(self, radius):
        self.radius = radius  # 实例变量

# 访问类变量和实例变量
c1 = Circle(5)
c2 = Circle(10)

print(Circle.pi)  # 3.14，访问类变量
print(c1.radius)  # 5，访问实例变量
print(c2.radius)  # 10

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

# 创建对象并调用方法
rect = Rectangle(5, 10)
print(rect.area())  # 50

class MyClass:
    count = 0

    @classmethod
    def increment_count(cls):
        cls.count += 1

MyClass.increment_count()
print(MyClass.count)  # 1

class Math:
    @staticmethod
    def add(x, y):
        return x + y

print(Math.add(3, 5))  # 8

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

class Cat(Animal):
    def speak(self):
        print(f"{self.name} meows.")

# 创建对象
animal = Animal("Generic Animal")
animal.speak()  # Generic Animal makes a sound.

cat = Cat("Kitty")
cat.speak()  # Kitty meows.

def animal_sound(animal):
    animal.speak()

dog = Dog("Buddy", "Golden Retriever")
cat = Cat("Kitty")
animal_sound(dog)  # Buddy is barking!
animal_sound(cat)  # Kitty meows.

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __str__(self):
        return f"'{self.title}' by {self.author}"

book = Book("1984", "George Orwell")
print(book)  # '1984' by George Orwell

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # Vector(4, 6)

Animal (父类)
└── Dog (子类)
    ├── 属性：name, breed
    ├── 方法：bark()

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        print(f"Deposited ${amount}. New balance: ${self.balance}")

    def withdraw(self, amount):
        if amount > self.balance:
            print("Insufficient funds.")
        else:
            self.balance -= amount
            print(f"Withdrew ${amount}. New balance: ${self.balance}")

# 创建账户并操作
account = BankAccount("Alice", 1000)
account.deposit(500)
account.withdraw(300)
account.withdraw(1500)

import requests
import json

# 设置 API 密钥和 URL
API_KEY = "your_api_key"
CITY = "Beijing"
URL = f"http://api.openweathermap.org/data/2.5/weather?q={CITY}&appid={API_KEY}"

# 发送请求
response = requests.get(URL)
data = response.json()

# 打印天气信息
print(f"城市: {data['name']}")
print(f"温度: {data['main']['temp']} K")
print(f"天气: {data['weather'][0]['description']}")

import pandas as pd

# 加载数据
df = pd.read_csv("weather_data.csv")

# 检查数据
print(df.head())

# 处理缺失值
df = df.dropna()

# 转换日期格式
df['date'] = pd.to_datetime(df['date'])

# 计算基本统计量
print(df['temperature'].describe())

# 按月统计平均温度
monthly_avg_temp = df.groupby(df['date'].dt.month)['temperature'].mean()
print(monthly_avg_temp)

pip install statsmodels

from statsmodels.tsa.arima_model import ARIMA
import matplotlib.pyplot as plt

# 准备时间序列数据
time_series = df.set_index('date')['temperature']

# 拆分训练集和测试集
train = time_series[:int(0.8 * len(time_series))]
test = time_series[int(0.8 * len(time_series)):]

# 构建 ARIMA 模型
model = ARIMA(train, order=(5, 1, 0))
model_fit = model.fit(disp=False)

# 预测
forecast = model_fit.forecast(steps=len(test))[0]

# 绘图
plt.plot(test, label='Actual')
plt.plot(test.index, forecast, label='Forecast')
plt.legend()
plt.show()

import matplotlib.pyplot as plt

# 绘制折线图
plt.figure(figsize=(10, 5))
plt.plot(df['date'], df['temperature'], label='Temperature', color='blue')
plt.xlabel('Date')
plt.ylabel('Temperature (°C)')
plt.title('Temperature Over Time')
plt.legend()
plt.show()

import seaborn as sns

# 生成数据
df['day_of_week'] = df['date'].dt.day_name()
df['hour'] = df['date'].dt.hour
heatmap_data = df.pivot_table(values='temperature', index='day_of_week', columns='hour', aggfunc='mean')

# 绘制热力图
plt.figure(figsize=(12, 6))
sns.heatmap(heatmap_data, cmap='coolwarm', annot=True)
plt.title('Average Temperature Heatmap')
plt.show()

import folium

# 创建地图
m = folium.Map(location=[39.9042, 116.4074], zoom_start=10)

# 添加天气标记
folium.Marker([39.9042, 116.4074], popup="Beijing: Sunny 25°C").add_to(m)
folium.Marker([31.2304, 121.4737], popup="Shanghai: Cloudy 22°C").add_to(m)

# 显示地图
m.save("weather_map.html")

import requests
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# 获取天气数据
API_KEY = "your_api_key"
CITY = "Beijing"
URL = f"http://api.openweathermap.org/data/2.5/forecast?q={CITY}&appid={API_KEY}&units=metric"
response = requests.get(URL)
data = response.json()

# 提取关键数据
forecast = []
for item in data['list']:
    forecast.append({
        "date": item['dt_txt'],
        "temperature": item['main']['temp'],
        "humidity": item['main']['humidity'],
        "weather": item['weather'][0]['description']
    })

# 转为 DataFrame
df = pd.DataFrame(forecast)
df['date'] = pd.to_datetime(df['date'])

# 绘制温度趋势图
plt.figure(figsize=(10, 5))
plt.plot(df['date'], df['temperature'], label='Temperature', color='red')
plt.xlabel('Date')
plt.ylabel('Temperature (°C)')
plt.title('Temperature Forecast')
plt.legend()
plt.show()

# 绘制湿度热力图
df['day_of_week'] = df['date'].dt.day_name()
df['hour'] = df['date'].dt.hour
heatmap_data = df.pivot_table(values='humidity', index='day_of_week', columns='hour', aggfunc='mean')

plt.figure(figsize=(12, 6))
sns.heatmap(heatmap_data, cmap='Blues', annot=True)
plt.title('Humidity Heatmap')
plt.show()

pip install pyspark

pyspark

from pyspark.sql import SparkSession

# 初始化 SparkSession
spark = SparkSession.builder \
    .appName("PySpark Example") \
    .getOrCreate()

# 读取 CSV 文件
data = spark.read.csv("example.csv", header=True, inferSchema=True)

# 查看数据
data.show()

# 创建 RDD
rdd = spark.sparkContext.parallelize([1, 2, 3, 4, 5])

# 转换操作（map）
rdd_squared = rdd.map(lambda x: x ** 2)

# 行动操作（collect）
print(rdd_squared.collect())

# 加载 JSON 数据
data = spark.read.json("people.json")

# 创建临时表
data.createOrReplaceTempView("people")

# 使用 SQL 查询
result = spark.sql("SELECT name, age FROM people WHERE age > 30")
result.show()

from pyspark.streaming import StreamingContext

# 创建 StreamingContext
ssc = StreamingContext(spark.sparkContext, batchDuration=1)

# 模拟数据流（本地文本文件）
lines = ssc.textFileStream("file:///path/to/directory")

# 统计每行单词数
word_counts = lines.flatMap(lambda line: line.split(" ")) \
                   .map(lambda word: (word, 1)) \
                   .reduceByKey(lambda a, b: a + b)

word_counts.pprint()

# 启动流处理
ssc.start()
ssc.awaitTermination()

from pyspark.ml.classification import LogisticRegression
from pyspark.ml.feature import VectorAssembler

# 加载数据
data = spark.read.csv("data.csv", header=True, inferSchema=True)

# 特征工程
assembler = VectorAssembler(inputCols=["feature1", "feature2"], outputCol="features")
data = assembler.transform(data)

# 训练逻辑回归模型
lr = LogisticRegression(featuresCol="features", labelCol="label")
model = lr.fit(data)

# 预测
predictions = model.transform(data)
predictions.show()

import numpy as np

# 判断矩阵
criteria_matrix = np.array([
    [1, 1/3, 3],
    [3, 1, 5],
    [1/3, 1/5, 1]
])

def calculate_weights(matrix):
    eigvals, eigvecs = np.linalg.eig(matrix)
    max_eigval = np.max(eigvals.real)  # 最大特征值
    max_eigvec = eigvecs[:, np.argmax(eigvals.real)].real  # 对应特征向量
    weights = max_eigvec / sum(max_eigvec)  # 归一化
    return weights, max_eigval

# 计算权重和一致性比率
weights, max_eigval = calculate_weights(criteria_matrix)
n = len(criteria_matrix)
CI = (max_eigval - n) / (n - 1)  # 一致性指标
RI = [0, 0, 0.58, 0.9, 1.12][n-1]  # 随机一致性指标（对应矩阵大小）
CR = CI / RI  # 一致性比率

if CR < 0.1:
    print(f"权重: {weights}, 矩阵通过一致性检查，CR={CR:.4f}")
else:
    print("判断矩阵一致性检查未通过，请调整判断矩阵！")

import numpy as np

# 原始数据矩阵
data = np.array([
    [0.9, 0.8, 0.6],
    [0.7, 0.9, 0.4],
    [0.8, 0.7, 0.5]
])

def entropy_weight(data):
    # 归一化处理
    norm_data = data / data.sum(axis=0)
    # 计算信息熵
    entropy = -np.sum(norm_data * np.log(norm_data + 1e-10), axis=0) / np.log(len(data))
    # 熵权
    weights = (1 - entropy) / np.sum(1 - entropy)
    return weights

weights = entropy_weight(data)
print(f"熵权法计算的权重: {weights}")

def topsis(data, weights):
    # 数据归一化
    norm_data = data / np.sqrt((data**2).sum(axis=0))
    # 加权矩阵
    weighted_data = norm_data * weights
    # 正理想解和负理想解
    ideal_best = weighted_data.max(axis=0)
    ideal_worst = weighted_data.min(axis=0)
    # 计算距离
    dist_best = np.sqrt(((weighted_data - ideal_best)**2).sum(axis=1))
    dist_worst = np.sqrt(((weighted_data - ideal_worst)**2).sum(axis=1))
    # 计算得分
    scores = dist_worst / (dist_best + dist_worst)
    return scores

# 示例数据
data = np.array([
    [100, 80, 90],
    [95, 85, 85],
    [90, 90, 80]
])
weights = np.array([0.3, 0.4, 0.3])  # 假设已知的权重

scores = topsis(data, weights)
print(f"TOPSIS分析得分: {scores}")

pip install seaborn

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

# 生成随机数据
data = np.random.rand(10, 10)  # 10x10 矩阵
columns = [f"Feature {i+1}" for i in range(10)]
index = [f"Sample {i+1}" for i in range(10)]

# 转换为 Pandas DataFrame
df = pd.DataFrame(data, columns=columns, index=index)
print(df.head())

plt.figure(figsize=(10, 8))
sns.heatmap(df, cmap="viridis")
plt.title("Basic Heatmap")
plt.show()

plt.figure(figsize=(10, 8))
sns.heatmap(df, cmap="coolwarm", annot=True, fmt=".2f")
plt.title("Heatmap with Values")
plt.show()

plt.figure(figsize=(10, 8))
sns.heatmap(df, cmap="YlGnBu", cbar=True)
plt.title("Heatmap with Color Bar")
plt.show()

plt.figure(figsize=(10, 8))
sns.heatmap(df, cmap="coolwarm", xticklabels=2, yticklabels=2)
plt.title("Heatmap with Adjusted Labels")
plt.show()

# 生成对称矩阵（示例：相关性矩阵）
correlation_matrix = np.corrcoef(data)
mask = np.triu(np.ones_like(correlation_matrix, dtype=bool))  # 上三角为 True

plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, mask=mask, cmap="coolwarm", annot=True, fmt=".2f")
plt.title("Heatmap with Masked Upper Triangle")
plt.show()

# 示例数据
tips = sns.load_dataset("tips")

# 计算相关性矩阵
corr = tips.corr()

# 绘制相关性热力图
plt.figure(figsize=(10, 8))
sns.heatmap(corr, annot=True, cmap="coolwarm", fmt=".2f", linewidths=0.5)
plt.title("Correlation Heatmap")
plt.show()

pip install pandas numpy scikit-learn matplotlib

import pandas as pd
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.feature_extraction.text import TfidfVectorizer
import matplotlib.pyplot as plt

data = {
    "User": ["A", "A", "B", "B", "C", "C", "D", "E"],
    "Movie": ["Matrix", "Inception", "Matrix", "Avatar", "Inception", "Titanic", "Matrix", "Titanic"],
    "Rating": [5, 4, 4, 5, 5, 3, 4, 2]
}

df = pd.DataFrame(data)
print(df)

movie_data = {
    "Movie": ["Matrix", "Inception", "Avatar", "Titanic"],
    "Description": [
        "Sci-fi action with AI and virtual reality",
        "Dream manipulation and sci-fi thriller",
        "Sci-fi adventure on an alien planet",
        "Romantic drama on a sinking ship"
    ]
}
movies_df = pd.DataFrame(movie_data)

tfidf = TfidfVectorizer(stop_words="english")
tfidf_matrix = tfidf.fit_transform(movies_df["Description"])

print(f"TF-IDF 矩阵形状: {tfidf_matrix.shape}")

cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)
similarity_df = pd.DataFrame(cosine_sim, index=movies_df["Movie"], columns=movies_df["Movie"])
print(similarity_df)

def recommend_movies(movie_name, similarity_matrix, movies, top_n=3):
    similar_scores = similarity_matrix[movie_name]
    similar_movies = similar_scores.sort_values(ascending=False)[1:top_n+1]
    return similar_movies

recommendation = recommend_movies("Matrix", similarity_df, movies_df)
print("推荐的电影：\n", recommendation)

user_movie_matrix = df.pivot(index="User", columns="Movie", values="Rating").fillna(0)
print(user_movie_matrix)

user_similarity = cosine_similarity(user_movie_matrix)
user_similarity_df = pd.DataFrame(user_similarity, index=user_movie_matrix.index, columns=user_movie_matrix.index)
print(user_similarity_df)

def recommend_by_user(user_id, similarity_matrix, ratings_matrix, top_n=3):
    similar_users = similarity_matrix[user_id].sort_values(ascending=False).index[1:]
    recommended_movies = ratings_matrix.loc[similar_users].mean().sort_values(ascending=False)
    return recommended_movies.head(top_n)

user_recommendation = recommend_by_user("A", user_similarity_df, user_movie_matrix)
print("为用户 A 推荐的电影：\n", user_recommendation)

user_recommendation.plot(kind="bar", title="User A Recommendations", color="skyblue")
plt.xlabel("Movies")
plt.ylabel("Predicted Rating")
plt.show()

pip install sklearn pandas jieba matplotlib

import pandas as pd
import jieba
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
from wordcloud import WordCloud

data = [
    "我喜欢看科幻小说",
    "编程是我的兴趣之一",
    "足球比赛非常精彩",
    "Python 是一门强大的编程语言",
    "人工智能正在改变世界",
    "我最喜欢的运动是篮球",
    "机器学习和深度学习是 AI 的核心",
    "NBA 比赛非常刺激",
    "大数据和云计算正在兴起",
    "小说中的人物非常有趣"
]

df = pd.DataFrame(data, columns=["content"])

def chinese_tokenizer(text):
    return " ".join(jieba.cut(text))

df['tokenized'] = df['content'].apply(chinese_tokenizer)
print(df.head())

tfidf = TfidfVectorizer()
tfidf_matrix = tfidf.fit_transform(df['tokenized'])

print(f"TF-IDF 矩阵形状: {tfidf_matrix.shape}")

kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(tfidf_matrix)

# 将聚类结果添加到数据集中
df['cluster'] = kmeans.labels_
print(df)

inertia = []
for k in range(1, 10):
    km = KMeans(n_clusters=k, random_state=42)
    km.fit(tfidf_matrix)
    inertia.append(km.inertia_)

plt.plot(range(1, 10), inertia, marker='o')
plt.title('肘部法则')
plt.xlabel('聚类数 (k)')
plt.ylabel('SSE')
plt.show()

for i in range(3):
    cluster_texts = df[df['cluster'] == i]['tokenized'].str.cat(sep=" ")
    wordcloud = WordCloud(font_path="simhei.ttf", background_color="white").generate(cluster_texts)

    plt.figure()
    plt.imshow(wordcloud, interpolation="bilinear")
    plt.axis("off")
    plt.title(f"Cluster {i} WordCloud")
    plt.show()

from sklearn.decomposition import PCA

# 降维至 2D
pca = PCA(n_components=2)
reduced_data = pca.fit_transform(tfidf_matrix.toarray())

# 可视化
plt.figure(figsize=(8, 6))
for i in range(3):
    cluster_data = reduced_data[df['cluster'] == i]
    plt.scatter(cluster_data[:, 0], cluster_data[:, 1], label=f"Cluster {i}")

plt.legend()
plt.title("KMeans Clustering")
plt.show()

content                tokenized  cluster
0          我喜欢看科幻小说             我 喜欢 看 科幻 小说       0
1          编程是我的兴趣之一             编程 是 我 的 兴趣 之一       1
2          足球比赛非常精彩             足球 比赛 非常 精彩       2
...

pip install facenet-pytorch
pip install torchvision

import torch
from facenet_pytorch import MTCNN

# 检查 GPU 可用性
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

from facenet_pytorch import MTCNN

# 初始化 MTCNN 模型
mtcnn = MTCNN(keep_all=True, device=device)

from PIL import Image

# 加载测试图像
image_path = "test_image.jpg"  # 替换为你的图像路径
image = Image.open(image_path)

# 检测人脸
boxes, probs, landmarks = mtcnn.detect(image, landmarks=True)

print(f"检测到 {len(boxes)} 张人脸")

import matplotlib.pyplot as plt
import cv2

# 绘制检测结果
image_cv = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB)
for box, landmark in zip(boxes, landmarks):
    # 绘制人脸框
    cv2.rectangle(image_cv,
                  (int(box[0]), int(box[1])),
                  (int(box[2]), int(box[3])),
                  (255, 0, 0), 2)

    # 绘制关键点
    for x, y in landmark:
        cv2.circle(image_cv, (int(x), int(y)), 2, (0, 255, 0), -1)

plt.imshow(image_cv)
plt.axis("off")
plt.show()

mtcnn = MTCNN(keep_all=True, device=device, min_face_size=20, thresholds=[0.6, 0.7, 0.7])

from PIL import Image

# 加载多张图像
images = [Image.open(f"image_{i}.jpg") for i in range(5)]

# 批量检测
boxes, probs, landmarks = mtcnn.detect(images, landmarks=True)

from facenet_pytorch import extract_face

# 提取并对齐人脸
aligned_faces = [extract_face(image, box) for box in boxes]
aligned_faces[0].show()  # 显示第一个对齐的人脸

import cv2

cap = cv2.VideoCapture(0)  # 打开摄像头
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # 转换为 PIL 图像
    image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))

    # 检测人脸
    boxes, _, _ = mtcnn.detect(image)

    # 绘制检测结果
    if boxes is not None:
        for box in boxes:
            cv2.rectangle(frame,
                          (int(box[0]), int(box[1])),
                          (int(box[2]), int(box[3])),
                          (0, 255, 0), 2)

    cv2.imshow('Video', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

# 检查 GPU 可用性
nvidia-smi

# PyTorch 安装（以 CUDA 11.7 为例）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117

# TensorFlow 安装
pip install tensorflow-gpu

import torch

# 检查 GPU 是否可用
print("GPU Available:", torch.cuda.is_available())

# 获取 GPU 数量
print("Number of GPUs:", torch.cuda.device_count())

# 获取当前 GPU 名称
print("GPU Name:", torch.cuda.get_device_name(0))

import torch
import torch.nn as nn

# 简单的线性模型
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = nn.Linear(10, 1)

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

# 初始化模型和数据
model = SimpleModel()
data = torch.randn(32, 10)  # 输入数据
target = torch.randn(32, 1)  # 目标

# 将模型和数据迁移到 GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
data, target = data.to(device), target.to(device)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 模型训练循环
for epoch in range(5):
    optimizer.zero_grad()
    output = model(data)
    loss = criterion(output, target)
    loss.backward()  # GPU 上计算梯度
    optimizer.step()  # GPU 上更新参数
    print(f"Epoch {epoch+1}, Loss: {loss.item()}")

import tensorflow as tf

# 检查 TensorFlow 的 GPU 可用性
print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))

# 创建一个简单的张量
a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
b = tf.constant([[1.0, 1.0], [0.0, 1.0]])

# 矩阵相乘
c = tf.matmul(a, b)
print(c)

from tensorflow.keras import layers, models

# 创建简单模型
model = models.Sequential([
    layers.Dense(64, activation='relu', input_shape=(10,)),
    layers.Dense(1)
])

import numpy as np

# 数据准备
x_train = np.random.randn(1000, 10).astype('float32')
y_train = np.random.randn(1000, 1).astype('float32')

model.compile(optimizer='adam', loss='mse')

# 使用 GPU 进行训练
model.fit(x_train, y_train, epochs=5, batch_size=32)

from torch.utils.data import DataLoader, TensorDataset

# 数据加载器示例
dataset = TensorDataset(data, target)
loader = DataLoader(dataset, batch_size=32, shuffle=True, pin_memory=True)

# PyTorch 混合精度示例
scaler = torch.cuda.amp.GradScaler()

with torch.cuda.amp.autocast():
    output = model(data)
    loss = criterion(output, target)

scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

# 克隆 YOLOv5 仓库
git clone https://github.com/ultralytics/yolov5.git
cd yolov5
pip install -r requirements.txt

# 安装 DeepSORT
git clone https://github.com/nwojke/deep_sort.git
cd deep_sort
pip install -r requirements.txt

# 安装 SlowFast（需 PyTorch 支持）
pip install slowfast

import cv2
import torch
from yolov5.models.common import DetectMultiBackend
from yolov5.utils.general import non_max_suppression
from yolov5.utils.torch_utils import select_device
from deep_sort import DeepSort

# 初始化 YOLOv5
device = select_device("")
model = DetectMultiBackend(weights="yolov5s.pt", device=device)
model.warmup()

# 初始化 DeepSORT
deepsort = DeepSort(model_path="ckpt.t7")

# 打开视频流
cap = cv2.VideoCapture("input_video.mp4")
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # YOLOv5 目标检测
    results = model(frame)
    detections = non_max_suppression(results)

    # DeepSORT 跟踪
    for detection in detections[0]:
        x1, y1, x2, y2, conf, cls = detection
        deepsort.update([[x1, y1, x2, y2]], frame)

    # 显示结果
    tracked_objects = deepsort.tracked_objects
    for obj in tracked_objects:
        bbox = obj.bbox
        cv2.rectangle(frame, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)

    cv2.imshow("Video", frame)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

from slowfast.models.video_model_builder import build_model
from slowfast.utils.checkpoint import load_checkpoint

# 初始化 SlowFast 模型
cfg = load_cfg("slowfast_config.yaml")
model = build_model(cfg)
load_checkpoint("slowfast_pretrained.pyth", model)

# 行为识别函数
def recognize_action(clip):
    clip = preprocess_clip(clip)  # 预处理
    with torch.no_grad():
        output = model(clip)
    action_idx = torch.argmax(output)
    return action_labels[action_idx]

# 将行为检测整合到主循环中
for obj in tracked_objects:
    bbox = obj.bbox
    track_id = obj.track_id
    clip = extract_clip(frame, bbox)  # 提取目标的动作序列

    action = recognize_action(clip)
    cv2.putText(frame, f"ID:{track_id} Action:{action}",
                (bbox[0], bbox[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)