计算机视觉（CV）¶

import cv2
import numpy as np
from PIL import Image

# 读取图像
img = cv2.imread('image.jpg')
print(f"图像形状: {img.shape}")  # (高度, 宽度, 通道)

# 转灰度
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 显示图像
cv2.imshow('Image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

import torch
from torchvision import transforms

# 定义预处理流程
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

# 加载图像
from PIL import Image
img = Image.open('image.jpg')
img_tensor = transform(img)
print(f"张量形状: {img_tensor.shape}")  # [3, 224, 224]

import torch
from torchvision import models, transforms
from PIL import Image

# 加载预训练的ResNet
model = models.resnet50(pretrained=True)
model.eval()

# 预处理
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], 
                        [0.229, 0.224, 0.225])
])

# 加载和预处理图像
img = Image.open('cat.jpg')
img_tensor = transform(img).unsqueeze(0)

# 预测
with torch.no_grad():
    output = model(img_tensor)
    probabilities = torch.nn.functional.softmax(output[0], dim=0)

# 获取Top-5预测
top5_prob, top5_idx = torch.topk(probabilities, 5)
for prob, idx in zip(top5_prob, top5_idx):
    print(f"Class {idx.item()}: {prob.item():.2%}")

from ultralytics import YOLO

# 加载YOLO模型
model = YOLO('yolov8n.pt')

# 检测
results = model('image.jpg')

# 可视化
for result in results:
    boxes = result.boxes
    for box in boxes:
        x1, y1, x2, y2 = box.xyxy[0]
        conf = box.conf[0]
        cls = box.cls[0]
        print(f"Class: {int(cls)}, Confidence: {conf:.2f}")

import cv2

def draw_boxes(image, detections):
    for det in detections:
        x1, y1, x2, y2 = det['bbox']
        label = det['class']
        conf = det['confidence']

        # 绘制边界框
        cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)

        # 添加标签
        text = f"{label}: {conf:.2f}"
        cv2.putText(image, text, (x1, y1-10), 
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

    return image

import torch
from torchvision import models

# 加载预训练的分割模型
model = models.segmentation.deeplabv3_resnet50(pretrained=True)
model.eval()

# 预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                        std=[0.229, 0.224, 0.225])
])

# 分割
with torch.no_grad():
    output = model(img_tensor)['out']
    predictions = torch.argmax(output.squeeze(), dim=0)

from torchvision.models.detection import maskrcnn_resnet50_fpn

# 加载Mask R-CNN
model = maskrcnn_resnet50_fpn(pretrained=True)
model.eval()

# 预测
with torch.no_grad():
    predictions = model(img_tensor.unsqueeze(0))

# 获取预测结果
boxes = predictions[0]['boxes']
labels = predictions[0]['labels']
scores = predictions[0]['scores']
masks = predictions[0]['masks']

import face_recognition

# 加载已知人脸
known_image = face_recognition.load_image_file("known_face.jpg")
known_encoding = face_recognition.face_encodings(known_image)[0]

# 加载待识别图像
unknown_image = face_recognition.load_image_file("unknown_face.jpg")
unknown_encodings = face_recognition.face_encodings(unknown_image)

# 比较人脸
for encoding in unknown_encodings:
    matches = face_recognition.compare_faces(
        [known_encoding], encoding, tolerance=0.6
    )
    if matches[0]:
        print("匹配成功!")
    else:
        print("未匹配")

import torch
import torch.nn as nn

# 生成器
class Generator(nn.Module):
    def __init__(self, latent_dim=100):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(latent_dim, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 256),
            nn.BatchNorm1d(256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 512),
            nn.BatchNorm1d(512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, 784),
            nn.Tanh()
        )

    def forward(self, z):
        return self.model(z)

# 判别器
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(784, 512),
            nn.LeakyReLU(0.2),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, img):
        return self.model(img)

from diffusers import StableDiffusionPipeline
import torch

# 加载模型
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

# 生成图像
prompt = "A beautiful landscape painting, mountains and lake"
image = pipe(prompt).images[0]
image.save("generated_image.png")

import cv2

# 打开视频
cap = cv2.VideoCapture('video.mp4')

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # 处理帧
    # ... 在这里添加你的处理逻辑

    # 显示
    cv2.imshow('Frame', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

# 背景减除器
bg_subtractor = cv2.createBackgroundSubtractorMOG2()

cap = cv2.VideoCapture('video.mp4')

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # 前景掩码
    mask = bg_subtractor.apply(frame)

    # 形态学操作
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)

    # 寻找轮廓
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, 
                                   cv2.CHAIN_APPROX_SIMPLE)

    for contour in contours:
        if cv2.contourArea(contour) > 500:
            x, y, w, h = cv2.boundingRect(contour)
            cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

import albumentations as A
from albumentations.pytorch import ToTensorV2

# 定义增强流程
transform = A.Compose([
    A.RandomCrop(224, 224),
    A.HorizontalFlip(p=0.5),
    A.VerticalFlip(p=0.5),
    A.RandomBrightnessContrast(p=0.2),
    A.Rotate(limit=30, p=0.5),
    A.Normalize(mean=(0.485, 0.456, 0.406), 
                std=(0.229, 0.224, 0.225)),
    ToTensorV2()
])

# 应用增强
augmented = transform(image=image)
image_tensor = augmented['image']