首页
/ CLIP-as-service：构建高性能多模态嵌入服务的终极指南

CLIP-as-service：构建高性能多模态嵌入服务的终极指南

2026-01-14 17:48:48作者：霍妲思
clip-as-service
🏄 Scalable embedding, reasoning, ranking for images and sentences with CLIP
项目地址：https://gitcode.com/gh_mirrors/cl/clip-as-service

文章详细介绍了CLIP-as-service项目，这是一个基于OpenAI CLIP模型构建的高性能多模态嵌入服务框架。文章从CLIP模型的基础原理开始，深入解析了其双编码器架构（视觉编码器和文本编码器）以及对比学习机制，详细说明了多模态嵌入的工作原理和实现方式。随后重点阐述了CLIP-as-service的项目架构设计，包括其客户端-服务器分离的三层架构、核心组件（客户端库、服务端执行器、模型管理层）以及支持的多运行时环境（PyTorch、ONNX、TensorRT）。文章还深入分析了分离式架构的设计理念、通信协议支持、数据流处理机制以及部署灵活性优势。

CLIP模型基础与多模态嵌入原理

CLIP（Contrastive Language-Image Pre-training）是OpenAI开发的一种革命性的多模态学习模型，它通过对比学习的方式将视觉和语言信息映射到统一的向量空间中。CLIP-as-service项目正是基于这一强大模型构建的高性能嵌入服务框架。

CLIP模型架构解析

CLIP采用双编码器架构，包含视觉编码器（Vision Encoder）和文本编码器（Text Encoder），两者将各自的输入映射到相同维度的向量空间。

graph TD
    A[输入图像] --> B[视觉编码器<br/>Vision Transformer]
    C[输入文本] --> D[文本编码器<br/>Transformer]
    B --> E[图像特征向量<br/>512维]
    D --> F[文本特征向量<br/>512维]
    E --> G[对比学习损失计算]
    F --> G
    G --> H[统一语义空间]

视觉编码器实现

CLIP的视觉编码器基于Vision Transformer架构，处理流程如下：

class VisionTransformer(nn.Module):
    def __init__(self, image_size=224, patch_size=16, width=768, layers=12, heads=12):
        super().__init__()
        self.conv1 = nn.Conv2d(3, width, kernel_size=patch_size, stride=patch_size)
        self.positional_embedding = nn.Parameter(torch.randn(1, 197, width))
        self.transformer = Transformer(width, layers, heads)
        self.ln_pre = LayerNorm(width)
        self.ln_post = LayerNorm(width)
        self.proj = nn.Parameter(torch.randn(width, 512))
    
    def forward(self, x: torch.Tensor):
        x = self.conv1(x)  # 形状: [*, width, grid, grid]
        x = x.reshape(x.shape[0], x.shape[1], -1)  # [*, width, grid**2]
        x = x.permute(0, 2, 1)  # [*, grid**2, width]
        x = torch.cat([x.mean(dim=1, keepdim=True), x], dim=1)  # [*, grid**2+1, width]
        x = x + self.positional_embedding
        x = self.ln_pre(x)
        x = x.permute(1, 0, 2)  # NLD -> LND
        x = self.transformer(x)
        x = x.permute(1, 0, 2)  # LND -> NLD
        x = self.ln_post(x[:, 0, :])  # 取CLS token
        x = x @ self.proj  # 投影到512维
        return x

文本编码器实现

文本编码器采用标准的Transformer架构：

class TextTransformer(nn.Module):
    def __init__(self, context_length=77, vocab_size=49408, width=512, heads=8, layers=12):
        super().__init__()
        self.token_embedding = nn.Embedding(vocab_size, width)
        self.positional_embedding = nn.Parameter(torch.randn(context_length, width))
        self.transformer = Transformer(width, layers, heads)
        self.ln_final = LayerNorm(width)
        self.text_projection = nn.Parameter(torch.randn(width, 512))
    
    def forward(self, text):
        x = self.token_embedding(text)  # [batch_size, n_ctx, d_model]
        x = x + self.positional_embedding
        x = x.permute(1, 0, 2)  # NLD -> LND
        x = self.transformer(x)
        x = x.permute(1, 0, 2)  # LND -> NLD
        x = self.ln_final(x)
        x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
        return x

多模态嵌入原理

CLIP的核心创新在于其对比学习训练策略，通过大规模图像-文本对训练，学习到高质量的跨模态表示。

对比学习机制

CLIP使用InfoNCE损失函数进行训练，最大化匹配图像-文本对的相似度，同时最小化不匹配对的相似度：

def contrastive_loss(logits_per_image, logits_per_text):
    labels = torch.arange(logits_per_image.shape[0], device=logits_per_image.device)
    loss_i = F.cross_entropy(logits_per_image, labels)
    loss_t = F.cross_entropy(logits_per_text, labels)
    return (loss_i + loss_t) / 2

相似度计算流程

sequenceDiagram
    participant Client
    participant Server
    participant VisionEncoder
    participant TextEncoder
    participant Similarity
    
    Client->>Server: 发送图像和文本
    Server->>VisionEncoder: 编码图像
    VisionEncoder->>Similarity: 图像特征向量
    Server->>TextEncoder: 编码文本
    TextEncoder->>Similarity: 文本特征向量
    Similarity->>Similarity: 计算余弦相似度
    Similarity->>Client: 返回相似度分数

嵌入向量特性

CLIP生成的嵌入向量具有以下重要特性：

特性 描述 应用场景
跨模态对齐 图像和文本嵌入在同一语义空间 图像检索、文本检索
语义丰富性 包含丰富的语义信息 零样本分类、内容理解
尺度一致性 不同模态的向量可比较 相似度计算、排序
可组合性 支持向量运算 概念组合、语义操作

实际应用示例

在CLIP-as-service中，嵌入过程通过统一的API接口实现：

# 图像嵌入示例
def encode_image(image_input):
    # 预处理图像
    image_tensor = preprocess_image(image_input)
    # 通过视觉编码器
    image_features = vision_encoder(image_tensor)
    # 归一化处理
    image_features = F.normalize(image_features, dim=-1)
    return image_features

# 文本嵌入示例  
def encode_text(text_input):
    # 分词处理
    tokens = tokenize(text_input)
    # 通过文本编码器
    text_features = text_encoder(tokens)
    # 归一化处理
    text_features = F.normalize(text_features, dim=-1)
    return text_features

性能优化策略

CLIP-as-service针对生产环境进行了多项优化：

  1. 模型量化：支持FP16、INT8量化，减少内存占用和推理时间
  2. 批处理优化：智能批处理策略，提升吞吐量
  3. 硬件加速：支持TensorRT、ONNX Runtime等推理引擎
  4. 内存管理：动态内存分配和缓存机制

通过深入理解CLIP模型的基础原理和多模态嵌入机制，开发者可以更好地利用CLIP-as-service构建高效的跨模态应用，实现图像和文本之间的无缝语义理解与检索。

CLIP-as-service项目架构与核心特性

CLIP-as-service是一个专为多模态嵌入服务设计的高性能微服务框架，其架构设计体现了现代分布式系统的核心理念。项目采用客户端-服务器分离架构，通过模块化设计实现了高度的可扩展性和灵活性。

分层架构设计

CLIP-as-service采用清晰的三层架构，确保各组件职责单一且易于维护：

flowchart TD
    A[客户端层 Client Layer] --> B[服务层 Service Layer]
    B --> C[模型执行层 Executor Layer]
    C --> D[推理引擎层 Runtime Layer]
    
    subgraph ClientLayer
        A1[HTTP Client]
        A2[gRPC Client]
        A3[WebSocket Client]
    end
    
    subgraph ServiceLayer
        B1[请求路由]
        B2[负载均衡]
        B3[协议转换]
    end
    
    subgraph ExecutorLayer
        C1[CLIP Executor]
        C2[预处理模块]
        C3[后处理模块]
    end
    
    subgraph RuntimeLayer
        D1[PyTorch Runtime]
        D2[ONNX Runtime]
        D3[TensorRT Runtime]
    end

核心组件详解

1. 客户端组件 (clip-client)

客户端库提供了统一的API接口，支持多种协议和调用方式：

功能模块 支持协议 主要方法 异步支持
编码服务 gRPC/HTTP/WebSocket encode(), aencode() ✅
检索服务 gRPC/HTTP/WebSocket search(), asearch() ✅
排序服务 gRPC/HTTP/WebSocket rank(), arank() ✅
索引服务 gRPC/HTTP/WebSocket index(), aindex() ✅

客户端设计采用了多态接口，支持字符串、URL、文档数组等多种输入格式：

# 多种输入格式支持示例
from clip_client import Client

c = Client('grpc://0.0.0.0:23456')

# 字符串列表输入
text_embeddings = c.encode(['First do it', 'then do it right'])

# 混合文本和图像输入
mixed_embeddings = c.encode([
    'First do it',
    'then do it right', 
    'https://picsum.photos/200'
])

# 文档数组输入（高级用法）
from docarray import DocumentArray
docs = DocumentArray([Document(text='hello'), Document(uri='image.jpg')])
doc_embeddings = c.encode(docs)

2. 服务端组件 (clip-server)

服务端采用模块化执行器架构，每个执行器负责特定的模型推理任务：

执行器类型 支持模型 推理引擎 性能特点
CLIPTorchExecutor OpenAI CLIP, OpenCLIP PyTorch 兼容性好，易于调试
CLIPONNXExecutor ONNX格式模型 ONNX Runtime 中等性能，跨平台
CLIPTensorRTExecutor TensorRT优化模型 TensorRT 极致性能，GPU优化

服务端配置采用YAML文件定义，支持灵活的运行时配置：

# torch-flow.yml 示例
jtype: CLIPTorchExecutor
with:
  name: ViT-B-32::openai
  device: cuda
  minibatch_size: 32
metas:
  py_modules:
    - clip_server/executors/clip_torch.py

3. 模型管理层

项目支持多种CLIP模型变体，通过统一的接口进行管理：

classDiagram
    class CLIPModel {
        +encode_image()
        +encode_text()
        +get_model_name()
        +image_size()
    }
    
    class OpenAICLIP {
        +使用官方预训练权重
        +支持多种视觉编码器
    }
    
    class OpenCLIP {
        +社区训练模型
        +多语言支持
    }
    
    class CNCLIP {
        +中文优化版本
        +中文文本理解
    }
    
    class MCLIP {
        +多语言CLIP
        +跨语言检索
    }
    
    CLIPModel <|-- OpenAICLIP
    CLIPModel <|-- OpenCLIP
    CLIPModel <|-- CNCLIP
    CLIPModel <|-- MCLIP

核心特性解析

1. 多运行时支持

CLIP-as-service的核心优势在于对多种推理运行时的深度优化：

运行时 安装方式 性能基准 适用场景
PyTorch pip install clip-server 基准性能 开发调试，快速原型
ONNX Runtime pip install "clip-server[onnx]" 1.5-2x加速 生产环境，CPU优化
TensorRT pip install "clip-server[tensorrt]" 3-5x加速 高性能需求，GPU集群

2. 弹性扩展机制

项目内置智能的负载均衡和弹性扩展能力：

# 多模型并行服务示例
executors:
  - uses: clip_server/executors/clip_torch.yml
    with:
      name: ViT-B-32::openai
    replicas: 2
    
  - uses: clip_server/executors/clip_torch.yml  
    with:
      name: RN50::openai
    replicas: 1

3. 流式处理架构

采用非阻塞双工流式处理，支持大规模数据的长时运行：

sequenceDiagram
    participant Client
    participant Gateway
    participant Executor
    
    Client->>Gateway: 发起流式请求
    Gateway->>Executor: 分发处理任务
    Executor->>Gateway: 流式返回结果
    Gateway->>Client: 实时推送结果
    loop 持续处理
        Client->>Gateway: 发送更多数据
        Gateway->>Executor: 继续处理
        Executor->>Gateway: 返回处理结果
    end

4. 预处理流水线

内置高效的预处理流水线，支持多种输入格式的自动转换：

输入类型 预处理步骤 输出格式
文本字符串 分词、填充、截断 Token IDs
图像URL 下载、解码、归一化 像素张量
本地图像 读取、转换、标准化 像素张量
二进制数据 解码、预处理 标准化张量

性能优化特性

CLIP-as-service在性能优化方面做了大量工作：

  1. 批处理优化：支持动态批处理大小调整，最大化GPU利用率
  2. 内存管理：智能内存分配和释放，减少内存碎片
  3. 缓存机制：模型权重和中间结果缓存，减少重复计算
  4. 异步处理：全链路异步支持，提高并发处理能力
# 性能调优示例
from clip_client import Client

# 配置批处理大小和预取数量
c = Client(
    'grpc://0.0.0.0:23456',
    batch_size=64,      # 增大批处理大小
    prefetch=200        # 增加预取数量
)

# 显示进度条的性能测试
result = c.encode(large_dataset, show_progress=True)

集成生态系统

项目深度集成Jina生态系统，提供完整的多模态搜索解决方案：

集成组件 功能描述 使用场景
DocArray 多模态数据处理 数据序列化、传输
Jina 分布式服务框架 服务编排、部署
Finetuner 模型微调工具 领域适配、优化

这种架构设计使得CLIP-as-service不仅是一个高性能的嵌入服务，更是一个完整的多模态AI应用开发平台。

服务端与客户端分离设计理念

CLIP-as-service采用了经典的客户端-服务器（C/S）架构设计，这种分离式架构为多模态嵌入服务带来了显著的性能优势、可扩展性和部署灵活性。让我们深入探讨这一设计理念的核心思想和技术实现。

架构设计的核心原则

CLIP-as-service的分离式架构建立在几个关键设计原则之上：

职责分离原则：服务端专注于模型推理和计算密集型任务，客户端处理数据预处理、后处理和用户交互逻辑。这种分离确保了每个组件都可以独立优化和扩展。

协议无关性：支持多种通信协议（gRPC、HTTP、WebSocket）及其TLS加密版本，客户端可以根据网络环境和安全需求选择合适的协议。

数据流优化：采用非阻塞双工流式传输，请求发送和响应接收是两个独立的并行流，极大提升了大规模数据传输的效率。

技术架构深度解析

让我们通过架构图来理解客户端与服务端的交互流程：

flowchart TD
    A[客户端应用] --> B[clip_client库]
    B --> C{协议选择}
    C --> D[gRPC/gRPCS]
    C --> E[HTTP/HTTPS]
    C --> F[WebSocket/WebSockets]
    
    D --> G[服务端网关]
    E --> G
    F --> G
    
    G --> H[请求分发器]
    H --> I[模型执行器]
    I --> J[CLIP模型推理]
    J --> K[响应组装]
    K --> G
    G --> B
    B --> A

客户端设计特点

客户端(clip-client)被设计为轻量级库，主要职责包括：

  • 智能数据检测：自动识别输入为文本或图像
  • 流式批处理：将大请求分割成小批次进行流式传输
  • 内存优化：按需加载数据，减少内存占用
  • 多协议支持：无缝切换不同通信协议
# 客户端初始化示例
from clip_client import Client

# 支持多种协议配置
clients = {
    'grpc': Client('grpc://0.0.0.0:23456'),
    'https': Client('https://api.example.com:443'),
    'websocket': Client('websocket://0.0.0.0:23457')
}

服务端架构优势

服务端(clip-server)专注于高性能模型推理：

  • 多运行时支持：PyTorch、ONNX、TensorRT三种运行时选择
  • 弹性扩展：单GPU上水平扩展多个CLIP模型
  • 自动负载均衡：智能分配请求到不同模型实例
  • 预处理优化：专门的图像和文本预处理流水线
graph TB
    subgraph 服务端运行时架构
        A[请求接收] --> B[协议解析]
        B --> C[数据预处理]
        C --> D{运行时选择}
        D --> E[PyTorch Runtime]
        D --> F[ONNX Runtime]
        D --> G[TensorRT Runtime]
        E --> H[模型推理]
        F --> H
        G --> H
        H --> I[结果后处理]
        I --> J[响应返回]
    end

通信协议矩阵

CLIP-as-service支持丰富的通信协议组合，满足不同场景需求：

协议类型 性能等级 加密支持 适用场景
gRPC ⚡⚡⚡ (最高) gRPCS (TLS) 高性能内部通信
HTTP ⚡⚡ (中等) HTTPS (TLS) Web集成和跨平台
WebSocket ⚡⚡ (中等) WebSockets (TLS) 实时双向通信

数据流处理机制

分离式架构的数据处理流程体现了高效的设计理念：

  1. 客户端数据准备：智能检测输入类型，自动转换为合适格式
  2. 流式传输：大文件分块传输，避免内存瓶颈
  3. 服务端并行处理：利用GPU并行计算能力
  4. 结果流式返回：逐步返回处理结果，减少等待时间
# 流式处理示例
from clip_client import Client

client = Client('grpc://0.0.0.0:23456')

# 大规模数据处理（支持生成器）
large_dataset = (f"image_{i}.jpg" for i in range(10000))
results = client.encode(large_dataset, show_progress=True)

部署灵活性优势

分离式架构带来的部署优势：

独立升级：客户端和服务端可以独立版本升级，无需同步更新 混合部署：支持云端服务端+边缘客户端的混合部署模式 弹性伸缩：根据负载动态调整服务端实例数量 故障隔离：客户端故障不影响服务端，服务端维护不影响客户端

性能优化策略

架构分离使得性能优化可以针对性进行：

客户端优化：

  • 连接池管理
  • 请求批处理
  • 本地缓存策略

服务端优化：

  • 模型预热
  • 动态批处理
  • GPU内存管理
pie title 客户端-服务端耗时分布
    "网络传输" : 25
    "客户端预处理" : 15
    "服务端推理" : 50
    "结果序列化" : 10

安全设计考虑

分离式架构天然支持安全增强：

  • 传输加密：支持TLS加密通信
  • 认证授权：灵活的凭证管理机制
  • 输入验证：客户端和服务端双重验证
  • 访问控制：基于协议的访问策略

实际应用场景

这种架构设计特别适合以下场景：

  1. 大规模嵌入计算：客户端收集数据，服务端集中处理
  2. 实时推理服务：低延迟要求的应用场景
  3. 混合云部署：公有云服务端+私有化客户端
  4. 边缘计算：资源受限设备作为客户端

通过客户端-服务端的清晰分离，CLIP-as-service实现了计算密集型任务与用户交互逻辑的有效隔离，既保证了服务的高性能和高可用性，又提供了极佳的用户体验和部署灵活性。这种设计理念使得该项目能够适应从小型实验到大规模生产环境的各种应用需求。

实际应用场景与性能优势分析

CLIP-as-service 作为一个高性能的多模态嵌入服务，在实际应用中展现出卓越的性能优势和广泛的应用场景。通过深入分析其架构设计和性能基准测试数据，我们可以清晰地看到它在不同应用场景中的价值体现。

跨模态搜索与检索应用

CLIP-as-service 最核心的应用场景是跨模态搜索和检索系统。通过将文本和图像编码到统一的向量空间中，系统能够实现：

  • 文本到图像检索：用户输入自然语言描述，系统返回最相关的图像
  • 图像到文本检索：上传图像，系统返回最匹配的文本描述
  • 多模态混合检索：同时支持文本和图像输入的混合查询
flowchart TD
    A[用户输入查询] --> B{查询类型判断}
    B -->|文本查询| C[文本预处理与编码]
    B -->|图像查询| D[图像预处理与编码]
    C --> E[生成文本向量]
    D --> F[生成图像向量]
    E --> G[向量相似度计算]
    F --> G
    G --> H[返回最相关结果]
    H --> I[展示检索结果]

在实际部署中，CLIP-as-service 支持多种运行时环境，每种环境都有其独特的性能特点：

运行时环境 延迟表现 吞吐量 适用场景
PyTorch 中等 中等 开发测试环境
ONNX 较低 较高 生产环境部署
TensorRT 最低 最高 高性能要求场景

视觉推理与内容理解

CLIP-as-service 在视觉推理任务中表现出色，支持多种推理能力：

对象识别与计数

# 对象计数示例
from clip_client import Client

client = Client('grpc://your-server-address')
results = client.rank(
    image_url='https://example.com/image.jpg',
    candidates=[
        "照片中有1个苹果",
        "照片中有2个苹果", 
        "照片中有3个苹果",
        "照片中有4个苹果"
    ]
)

空间关系理解 系统能够准确识别图像中物体的相对位置关系，如"左边的车是蓝色的，右边的车是红色的"等复杂空间描述。

颜色识别与属性分析 CLIP模型在颜色识别方面表现优异，能够准确识别图像中物体的颜色属性。

大规模内容审核与分类

在企业级应用中，CLIP-as-service 可用于：

  • 内容安全审核：自动识别不当内容
  • 商品分类：电商平台的商品自动分类
  • 媒体资产管理：大规模图像和视频内容的智能标签化

性能基准数据显示，在单GPU环境下，不同模型的处理能力差异显著：

模型类型 文本QPS 图像QPS 内存占用 适用场景
ViT-B-32 1064 286 1.4GB 通用场景
ViT-L-14 1040 140 2.04GB 高精度需求
ViT-H-14 642 91 3.26GB 最高精度

实时推荐系统集成

在推荐系统场景中，CLIP-as-service 提供：

实时特征提取

# 实时商品特征提取
def extract_product_features(images, descriptions):
    client = Client('grpc://recommendation-service')
    
    # 并行处理图像和文本
    image_embeddings = client.encode(images)
    text_embeddings = client.encode(descriptions)
    
    return {
        'image_vectors': image_embeddings,
        'text_vectors': text_embeddings
    }

多模态相似度计算 系统能够计算图像-图像、文本-文本、图像-文本之间的相似度，为推荐算法提供丰富的特征信息。

边缘计算与移动端部署

CLIP-as-service 的轻量级特性使其适合边缘计算场景：

  • 移动应用集成：在移动设备上提供本地化的多模态理解能力
  • IoT设备部署：在资源受限的设备上运行轻量级模型
  • 实时处理需求：对延迟敏感的应用场景

性能优化策略

基于大量性能测试数据，我们总结出以下优化策略：

模型选择策略

graph LR
    A[应用需求分析] --> B{精度要求}
    B -->|高精度| C[选择ViT-H-14或ViT-g-14]
    B -->|平衡型| D[选择ViT-L-14]
    B -->|高效率| E[选择ViT-B-32]
    
    C --> F[评估硬件资源]
    D --> F
    E --> F
    
    F --> G{延迟要求}
    G -->|极低延迟| H[使用TensorRT运行时]
    G -->|低延迟| I[使用ONNX运行时] 
    G -->|普通延迟| J[使用PyTorch运行时]

批量处理优化 通过合理的批量大小配置，可以显著提升吞吐量：

批量大小 吞吐量提升 内存占用 推荐场景
16 1.5x 低 实时交互
32 2.8x 中等 一般应用
64 4.2x 高 批量处理

企业级部署架构

在大规模企业部署中，CLIP-as-service 支持：

水平扩展架构

flowchart TD
    A[负载均衡器] --> B[CLIP服务实例1]
    A --> C[CLIP服务实例2]
    A --> D[CLIP服务实例N]
    
    B --> E[GPU资源池]
    C --> E
    D --> E
    
    F[监控系统] --> G[性能指标收集]
    G --> H[自动扩缩容]

高可用性设计

  • 多实例冗余部署
  • 自动故障转移
  • 实时性能监控
  • 动态资源调度

通过上述分析，CLIP-as-service 在各种实际应用场景中都能提供卓越的性能表现，其灵活架构设计使得它能够适应从小型应用到大型企业系统的各种需求。

CLIP-as-service在实际应用中展现出卓越的性能优势和广泛的应用价值。在跨模态搜索与检索场景中，它能够高效实现文本到图像、图像到文本以及多模态混合检索。在视觉推理与内容理解方面，系统支持对象识别计数、空间关系理解和颜色属性分析等复杂任务。对于大规模内容审核与分类、实时推荐系统集成以及边缘计算与移动端部署等企业级应用，CLIP-as-service都提供了可靠的解决方案。性能基准数据显示，不同模型和运行时有显著差异：ViT-B-32模型在文本处理上可达1064 QPS，图像处理286 QPS；而TensorRT运行时能提供3-5倍的性能加速。通过合理的模型选择策略、批量处理优化（批量64可达4.2x吞吐量提升）以及水平扩展架构设计，CLIP-as-service能够适应从小型应用到大型企业系统的各种需求，为企业提供高性能、高可用的多模态AI服务能力。

clip-as-service
🏄 Scalable embedding, reasoning, ranking for images and sentences with CLIP
项目地址：https://gitcode.com/gh_mirrors/cl/clip-as-service
登录后查看全文
热门项目推荐
相关项目推荐

项目优选

收起
kernelkernel
deepin linux kernel
C
27
11
docsdocs
OpenHarmony documentation | OpenHarmony开发者文档
Dockerfile
474
3.54 K
ohos_react_nativeohos_react_native
React Native鸿蒙化仓库
JavaScript
287
339
kernelkernel
openEuler内核是openEuler操作系统的核心，既是系统性能与稳定性的基石，也是连接处理器、设备与服务的桥梁。
C
224
92
pytorchpytorch
Ascend Extension for PyTorch
Python
283
316
flutter_flutterflutter_flutter
暂无简介
Dart
723
175
nop-entropynop-entropy
Nop Platform 2.0是基于可逆计算理论实现的采用面向语言编程范式的新一代低代码开发平台，包含基于全新原理从零开始研发的GraphQL引擎、ORM引擎、工作流引擎、报表引擎、规则引擎、批处理引引擎等完整设计。nop-entropy是它的后端部分，采用java语言实现，可选择集成Spring框架或者Quarkus框架。中小企业可以免费商用
Java
10
1
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
849
441
RuoYi-Vue3RuoYi-Vue3
🎉 (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统
Vue
1.27 K
701
leetcodeleetcode
🔥LeetCode solutions in any programming language | 多种编程语言实现 LeetCode、《剑指 Offer（第 2 版）》、《程序员面试金典（第 6 版）》题解
Java
65
19