人工智能：计算机视觉高级应用与前沿发展

星辰徐哥2026-03-19 19:39

计算机视觉高级应用与前沿发展

学习目标

💡 理解计算机视觉的前沿技术和发展趋势

💡 掌握高级计算机视觉应用（如人脸识别、图像分割、图像生成）

💡 学会使用前沿计算机视觉模型（如ViT、Swin Transformer、CLIP）

💡 理解计算机视觉在多模态融合、零样本学习、少样本学习中的应用

💡 通过实战项目，开发一个高级人脸识别应用

重点内容

  • 计算机视觉前沿技术和发展趋势
  • 高级计算机视觉应用（人脸识别、图像分割、图像生成）
  • 前沿计算机视觉模型（ViT、Swin Transformer、CLIP）
  • 多模态融合、零样本学习、少样本学习
  • 实战项目：高级人脸识别应用开发

一、计算机视觉前沿技术和发展趋势

1.1 多模态融合

1.1.1 多模态融合的基本概念

多模态融合是将不同模态的数据（如文本、图像、音频）结合起来，进行处理和分析的过程。它可以提高模型的性能和准确性。

1.1.2 多模态融合的应用场景

多模态融合在各个领域都有广泛的应用，主要包括：

  • 图像字幕生成：为图像生成自然语言描述
  • 视频理解：分析视频内容，生成文本摘要
  • 语音识别：结合图像和语音数据，提高识别准确性

1.2 零样本学习和少样本学习

1.2.1 零样本学习和少样本学习的基本概念
  • 零样本学习：模型在没有见过训练数据的情况下，能够识别新类别的物体
  • 少样本学习：模型在只见过少量训练数据的情况下，能够识别新类别的物体
1.2.2 零样本学习和少样本学习的应用场景

零样本学习和少样本学习在各个领域都有广泛的应用，主要包括：

  • 图像识别：识别新类别的物体
  • 文本分类：分类新类别的文本
  • 机器翻译：翻译新语言的文本

1.3 可解释性计算机视觉

1.3.1 可解释性计算机视觉的基本概念

可解释性计算机视觉是研究如何让计算机视觉模型的决策过程变得可解释的技术。它可以帮助用户理解模型的决策依据。

1.3.2 可解释性计算机视觉的应用场景

可解释性计算机视觉在各个领域都有广泛的应用，主要包括：

  • 医疗领域：解释疾病诊断的依据
  • 金融领域：解释风险评估的依据
  • 法律领域：解释法律决策的依据

二、高级计算机视觉应用

2.1 人脸识别

2.1.1 人脸识别的基本概念

人脸识别是一种计算机视觉技术，用于识别和验证人脸。它分为以下几个步骤：

  1. 人脸检测：在图像中检测人脸的位置
  2. 特征提取：从人脸图像中提取特征
  3. 特征匹配：将提取的特征与数据库中的特征进行匹配
2.1.2 人脸识别的应用场景

人脸识别在各个领域都有广泛的应用，主要包括：

  • 安防领域：用于门禁系统、视频监控
  • 金融领域：用于身份验证、支付
  • 社交媒体：用于标签和识别
  • 医疗领域：用于疾病诊断
2.1.3 人脸识别的代码实现

以下是使用OpenCV和face_recognition库进行人脸识别的代码实现：

python 复制代码 
import cv2
import face_recognition

def recognize_face(image_path, known_face_encodings, known_face_names):
    # 加载图像
    image = cv2.imread(image_path)
    rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # 检测人脸和提取特征
    face_locations = face_recognition.face_locations(rgb_image)
    face_encodings = face_recognition.face_encodings(rgb_image, face_locations)
    
    # 识别人脸
    for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings):
        matches = face_recognition.compare_faces(known_face_encodings, face_encoding)
        name = "Unknown"
        
        if True in matches:
            first_match_index = matches.index(True)
            name = known_face_names[first_match_index]
            
        # 绘制人脸框和标签
        cv2.rectangle(image, (left, top), (right, bottom), (0, 255, 0), 2)
        cv2.putText(image, name, (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
        
    return image

2.2 图像分割

2.2.1 图像分割的基本概念

图像分割是将图像分割成多个区域的过程。它分为以下几种类型：

  1. 语义分割：对图像进行像素级的分割和标记
  2. 实例分割：对图像中的每个实例进行分割和标记
  3. 全景分割：同时进行语义分割和实例分割
2.2.2 图像分割的应用场景

图像分割在各个领域都有广泛的应用，主要包括：

  • 医疗领域：用于医学影像分析
  • 汽车领域：用于自动驾驶
  • 视频监控：用于目标检测
  • 社交媒体：用于图像编辑
2.2.3 图像分割的代码实现

以下是使用PyTorch进行图像分割的代码实现：

python 复制代码 
import torch
from torchvision import transforms, models
from PIL import Image
import numpy as np
import cv2

def segment_image(image_path, model_path, class_names):
    # 数据预处理
    data_transforms = transforms.Compose([
        transforms.Resize((512, 512)),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
    
    # 加载图像
    image = Image.open(image_path)
    image_tensor = data_transforms(image)
    image_tensor = image_tensor.unsqueeze(0)
    
    # 加载模型
    model = models.segmentation.deeplabv3_resnet101(pretrained=False, num_classes=len(class_names))
    model.load_state_dict(torch.load(model_path))
    model.eval()
    
    # 分割图像
    with torch.no_grad():
        outputs = model(image_tensor)['out']
        
    # 处理分割结果
    masks = torch.argmax(outputs, dim=1).squeeze().numpy()
    color_map = np.array([[0, 0, 0], [255, 0, 0], [0, 255, 0], [0, 0, 255]])
    
    segmented_image = color_map[masks]
    segmented_image = cv2.resize(segmented_image, (image.size[0], image.size[1]))
    
    return segmented_image

2.3 图像生成

2.3.1 图像生成的基本概念

图像生成是生成新图像的过程。它分为以下几种类型：

  1. GAN生成：使用生成对抗网络生成图像
  2. 扩散模型生成：使用扩散模型生成图像
  3. 自回归模型生成：使用自回归模型生成图像
2.3.2 图像生成的应用场景

图像生成在各个领域都有广泛的应用，主要包括：

  • 艺术创作：生成艺术作品
  • 游戏开发：生成游戏场景和角色
  • 医疗领域：生成医学影像
  • 社交媒体：生成虚拟形象
2.3.3 图像生成的代码实现

以下是使用PyTorch进行图像生成的代码实现：

python 复制代码 
import torch
from torchvision import transforms, models
from PIL import Image
import numpy as np
import cv2

def generate_image(text, model_path):
    # 数据预处理
    data_transforms = transforms.Compose([
        transforms.Resize((256, 256)),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
    
    # 加载模型
    model = models.detection.fasterrcnn_resnet50_fpn(pretrained=False)
    model.load_state_dict(torch.load(model_path))
    model.eval()
    
    # 生成图像
    with torch.no_grad():
        outputs = model(text)
        
    # 处理生成结果
    generated_image = outputs['images'][0]
    generated_image = generated_image.permute(1, 2, 0).numpy()
    generated_image = (generated_image * 255).astype(np.uint8)
    generated_image = cv2.cvtColor(generated_image, cv2.COLOR_RGB2BGR)
    
    return generated_image

三、前沿计算机视觉模型

3.1 ViT模型

3.1.1 ViT模型的基本原理

ViT（Vision Transformer）是一种基于Transformer架构的计算机视觉模型。它将图像分割成多个图像块，然后将这些图像块视为序列数据进行处理。

3.1.2 ViT模型的使用

以下是使用PyTorch进行ViT模型训练的代码实现：

python 复制代码 
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms, models

def train_vit_model(data_dir, num_classes=2, batch_size=32, num_epochs=10, lr=0.001):
    # 数据预处理
    data_transforms = {
        'train': transforms.Compose([
            transforms.RandomResizedCrop(224),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
        'val': transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
    }
    
    # 加载数据
    image_datasets = {x: datasets.ImageFolder(f'{data_dir}/{x}', data_transforms[x]) for x in ['train', 'val']}
    dataloaders = {x: DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=4) for x in ['train', 'val']}
    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
    class_names = image_datasets['train'].classes
    
    # 加载模型
    model = models.vit_b_16(pretrained=True)
    model.heads = nn.Sequential(
        nn.Linear(model.config.hidden_size, num_classes)
    )
    
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
    
    # 训练模型
    for epoch in range(num_epochs):
        print(f'Epoch {epoch}/{num_epochs - 1}')
        print('-' * 10)
        
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
                
            running_loss = 0.0
            running_corrects = 0
            
            for inputs, labels in dataloaders[phase]:
                optimizer.zero_grad()
                
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _, preds = torch.max(outputs, 1)
                    loss = criterion(outputs, labels)
                    
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()
                        
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)
                
            if phase == 'train':
                scheduler.step()
                
            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects.double() / dataset_sizes[phase]
            
            print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
            
    print('Training complete')
    return model

3.2 Swin Transformer模型

3.2.1 Swin Transformer模型的基本原理

Swin Transformer是一种基于Transformer架构的计算机视觉模型。它使用滑动窗口注意力机制，能够处理高分辨率图像。

3.2.2 Swin Transformer模型的使用

以下是使用PyTorch进行Swin Transformer模型训练的代码实现：

python 复制代码 
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms, models

def train_swin_model(data_dir, num_classes=2, batch_size=32, num_epochs=10, lr=0.001):
    # 数据预处理
    data_transforms = {
        'train': transforms.Compose([
            transforms.RandomResizedCrop(224),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
        'val': transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
    }
    
    # 加载数据
    image_datasets = {x: datasets.ImageFolder(f'{data_dir}/{x}', data_transforms[x]) for x in ['train', 'val']}
    dataloaders = {x: DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=4) for x in ['train', 'val']}
    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
    class_names = image_datasets['train'].classes
    
    # 加载模型
    model = models.swin_t(pretrained=True)
    model.head = nn.Sequential(
        nn.Linear(model.config.hidden_size, num_classes)
    )
    
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
    
    # 训练模型
    for epoch in range(num_epochs):
        print(f'Epoch {epoch}/{num_epochs - 1}')
        print('-' * 10)
        
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
                
            running_loss = 0.0
            running_corrects = 0
            
            for inputs, labels in dataloaders[phase]:
                optimizer.zero_grad()
                
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _, preds = torch.max(outputs, 1)
                    loss = criterion(outputs, labels)
                    
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()
                        
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)
                
            if phase == 'train':
                scheduler.step()
                
            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects.double() / dataset_sizes[phase]
            
            print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
            
    print('Training complete')
    return model

3.3 CLIP模型

3.3.1 CLIP模型的基本原理

CLIP（Contrastive Language-Image Pretraining）是一种多模态模型，能够将文本和图像进行关联。它通过对比学习的方法，训练模型理解文本和图像之间的关系。

3.3.2 CLIP模型的使用

以下是使用Hugging Face Transformers库中的CLIP模型进行图像和文本关联的代码实现：

python 复制代码 
from transformers import CLIPProcessor, CLIPModel
import torch
from PIL import Image

def image_text_embedding(image_path, text, model_name='openai/clip-vit-base-patch32'):
    processor = CLIPProcessor.from_pretrained(model_name)
    model = CLIPModel.from_pretrained(model_name)
    
    # 加载图像
    image = Image.open(image_path)
    
    # 编码图像和文本
    inputs = processor(text=[text], images=image, return_tensors='pt')
    outputs = model(**inputs)
    
    # 计算相似度
    logits_per_image = outputs.logits_per_image
    probs = logits_per_image.softmax(dim=1)
    
    return probs[0][0]

四、实战项目：高级人脸识别应用开发

4.1 项目需求分析

4.1.1 应用目标

构建一个高级人脸识别应用，能够识别和验证人脸。

4.1.2 用户需求
  • 支持图像输入和处理
  • 支持人脸识别
  • 提供友好的用户界面，使用简单方便
4.1.3 功能范围
  • 图像输入和处理
  • 人脸识别
  • 结果可视化

4.2 系统架构设计

4.2.1 应用架构

该高级人脸识别应用的架构采用分层设计，分为以下几个层次：

  1. 用户界面层：提供用户与系统的交互接口，包括图像输入、图像处理、结果可视化等功能
  2. 应用逻辑层：处理用户请求、业务逻辑和应用控制
  3. 图像处理层：对图像进行处理和分析
  4. 数据存储层：存储图像数据和处理结果
4.2.2 数据存储方案

该系统的数据存储方案包括以下几个部分：

  1. 图像数据存储：使用文件系统存储图像数据
  2. 处理结果存储：使用文件系统存储处理结果

4.3 系统实现

4.3.1 开发环境搭建

首先，需要搭建开发环境。该系统使用 Python 作为开发语言，使用 OpenCV、face_recognition、PyTorch 和 Tkinter 等库作为计算机视觉工具。

bash 复制代码 
# 安装 OpenCV 库
pip install opencv-python

# 安装 face_recognition 库
pip install face_recognition

# 安装 PyTorch 库
pip install torch torchvision

# 安装 Tkinter 库（通常已安装）
4.3.2 图像输入和处理

图像输入和处理是系统的基础功能。以下是图像输入和处理的实现代码：

python 复制代码 
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

class ImageInputFrame(tk.Frame):
    def __init__(self, parent, on_image_selected):
        tk.Frame.__init__(self, parent)
        self.parent = parent
        self.on_image_selected = on_image_selected
        
        # 创建组件
        self.create_widgets()
        
    def create_widgets(self):
        # 图像显示区域
        self.image_label = tk.Label(self)
        self.image_label.pack(pady=10, padx=10, fill="both", expand=True)
        
        # 选择图像按钮
        tk.Button(self, text="选择图像", command=self.select_image).pack(pady=10, padx=10)
        
    def select_image(self):
        # 选择图像文件
        file_path = filedialog.askopenfilename(filetypes=[("Image Files", "*.png *.jpg *.jpeg *.bmp")])
        
        if file_path:
            # 打开图像
            image = Image.open(file_path)
            
            # 调整图像大小
            image = image.resize((400, 300), Image.ANTIALIAS)
            
            # 显示图像
            photo = ImageTk.PhotoImage(image)
            self.image_label.configure(image=photo)
            self.image_label.image = photo
            
            # 调用回调函数
            self.on_image_selected(file_path)
4.3.3 人脸识别

人脸识别是系统的核心功能。以下是人脸识别的实现代码：

python 复制代码 
import cv2
import face_recognition
import os

def load_known_faces(known_faces_dir):
    known_face_encodings = []
    known_face_names = []
    
    for filename in os.listdir(known_faces_dir):
        if filename.endswith('.jpg') or filename.endswith('.jpeg') or filename.endswith('.png'):
            image_path = os.path.join(known_faces_dir, filename)
            image = face_recognition.load_image_file(image_path)
            
            # 检测人脸和提取特征
            face_encodings = face_recognition.face_encodings(image)
            
            if face_encodings:
                known_face_encodings.append(face_encodings[0])
                known_face_names.append(os.path.splitext(filename)[0])
                
    return known_face_encodings, known_face_names

def recognize_face(image_path, known_face_encodings, known_face_names):
    # 加载图像
    image = cv2.imread(image_path)
    rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # 检测人脸和提取特征
    face_locations = face_recognition.face_locations(rgb_image)
    face_encodings = face_recognition.face_encodings(rgb_image, face_locations)
    
    # 识别人脸
    for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings):
        matches = face_recognition.compare_faces(known_face_encodings, face_encoding)
        name = "Unknown"
        
        if True in matches:
            first_match_index = matches.index(True)
            name = known_face_names[first_match_index]
            
        # 绘制人脸框和标签
        cv2.rectangle(image, (left, top), (right, bottom), (0, 255, 0), 2)
        cv2.putText(image, name, (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
        
    return image
4.3.4 结果可视化

结果可视化是系统的重要功能之一。以下是结果可视化的实现代码：

python 复制代码 
import tkinter as tk
from PIL import Image, ImageTk
import cv2

class ResultFrame(tk.Frame):
    def __init__(self, parent):
        tk.Frame.__init__(self, parent)
        self.parent = parent
        
        # 创建组件
        self.create_widgets()
        
    def create_widgets(self):
        # 结果显示区域
        self.result_image_label = tk.Label(self)
        self.result_image_label.pack(pady=10, padx=10, fill="both", expand=True)
        
    def display_result(self, image):
        # 调整图像大小
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image_pil = Image.fromarray(image)
        image_pil = image_pil.resize((400, 300), Image.ANTIALIAS)
        
        # 显示图像
        photo = ImageTk.PhotoImage(image_pil)
        self.result_image_label.configure(image=photo)
        self.result_image_label.image = photo
4.3.5 用户界面

用户界面是系统的交互部分。以下是用户界面的实现代码：

python 复制代码 
import tkinter as tk
from tkinter import ttk, messagebox, filedialog
from PIL import Image, ImageTk

from image_input_frame import ImageInputFrame
from result_frame import ResultFrame
from face_recognition_functions import load_known_faces, recognize_face

class FaceRecognitionApp:
    def __init__(self, root):
        self.root = root
        self.root.title("高级人脸识别应用")
        
        # 已知人脸目录
        self.known_faces_dir = 'known_faces'
        
        # 加载已知人脸
        self.known_face_encodings, self.known_face_names = load_known_faces(self.known_faces_dir)
        
        # 创建组件
        self.create_widgets()
        
    def create_widgets(self):
        # 图像输入和处理区域
        self.image_input_frame = ImageInputFrame(self.root, self.process_image)
        self.image_input_frame.pack(pady=10, padx=10, fill="both", expand=True)
        
        # 功能选择区域
        function_frame = tk.LabelFrame(self.root, text="功能选择")
        function_frame.pack(pady=10, padx=10, fill="x")
        
        self.function_var = tk.StringVar()
        self.function_var.set("人脸识别")
        
        tk.Radiobutton(function_frame, text="人脸识别", variable=self.function_var, value="人脸识别").grid(row=0, column=0, padx=5, pady=5)
        
        # 结果显示区域
        self.result_frame = ResultFrame(self.root)
        self.result_frame.pack(pady=10, padx=10, fill="both", expand=True)
        
    def process_image(self, image_path):
        function = self.function_var.get()
        
        try:
            if function == "人脸识别":
                result_image = recognize_face(image_path, self.known_face_encodings, self.known_face_names)
                self.result_frame.display_result(result_image)
            else:
                raise ValueError("未知功能")
        except Exception as e:
            messagebox.showerror("错误", f"处理失败：{str(e)}")
            
if __name__ == "__main__":
    root = tk.Tk()
    app = FaceRecognitionApp(root)
    root.mainloop()

4.4 系统运行与测试

4.4.1 系统运行

运行系统时，需要执行以下步骤：

  1. 安装 OpenCV、face_recognition、PyTorch 和 Tkinter 库
  2. 创建一个名为 known_faces 的目录，并在其中放置一些人脸图像
  3. 运行 face_recognition_app.py 文件
  4. 选择图像
  5. 查看结果
4.4.2 系统测试

系统测试时，需要使用一些测试图像。以下是一个简单的测试图像示例：

  1. 测试图像：一张包含已知人脸的图像
  2. 测试操作 ：
    • 选择图像
    • 查看结果

五、总结

本章介绍了计算机视觉的前沿技术和发展趋势，以及高级计算机视觉应用（如人脸识别、图像分割、图像生成）。同时，本章还介绍了前沿计算机视觉模型（如ViT、Swin Transformer、CLIP）和计算机视觉在多模态融合、零样本学习、少样本学习中的应用。最后，通过实战项目，展示了如何开发一个高级人脸识别应用。

计算机视觉是人工智能的一个重要分支，它涉及计算机与图像之间的交互。其目标是让计算机能够理解和解释图像内容，从而实现与人类视觉系统类似的功能。

通过学习本章的内容，读者可以掌握计算机视觉前沿技术和高级应用的开发方法和技巧，具备开发高级计算机视觉应用的能力。同时，通过实战项目，读者可以将所学知识应用到实际项目中，进一步提升自己的技能水平。

相关推荐
星河耀银海1 小时前
人工智能大模型项目实战：从需求到落地的全流程指南
人工智能·ai·大模型
catchadmin1 小时前
保姆级 OpenClaw （原 Clawdbot）飞书对接教程 手把手教你搭建 AI 助手
人工智能·elasticsearch·飞书
InfiniSynapse2 小时前
连上Snowflake就能取数：InfiniSynapse + Spider2-Snow实战企业数据分析
数据结构·图像处理·人工智能·算法·语言模型·数据挖掘·数据分析
京东零售技术2 小时前
2026京东零售技术国际顶会论文合集第一期 CVPR/WWW/ICLR等收录
人工智能·零售
IT_陈寒2 小时前
React开发者都在偷偷用的5个性能优化黑科技，你知道几个？
前端·人工智能·后端
The Open Group2 小时前
韧性未来如何打造？IT 可持续性、AI 与能源的协同之道
人工智能·能源
大傻^2 小时前
LangChain4j RAG 核心：Document、Embedding 与向量存储抽象
开发语言·人工智能·python·embedding·langchain4j
港股研究社2 小时前
腾讯音乐的多元增长新路径：音乐IP经济
大数据·人工智能·tcp/ip
深圳季连AIgraphX2 小时前
UROVAs 端到端自动驾驶模型训练、开闭环测试与上车联调
人工智能·机器学习·自动驾驶
热门推荐
01GitHub 镜像站点02Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南03OpenClaw 使用和管理 MCP 完全指南04AI 编程三剑客：Spec-Kit、OpenSpec、Superpowers 深度对比与实战指南05UV安装并设置国内源06Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services07OpenClaw Control UI安全上下文访问配置08小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）09本地部署 OpenClaw + DeepSeek-R1 完全指南10OpenClaw macOS 完整安装与本地模型配置教程（实战版）