首页
/ DGL异构图卷积深度调试：从报错到优化的5个实战突破点

DGL异构图卷积深度调试：从报错到优化的5个实战突破点

2026-03-17 06:46:42作者：温艾琴Wonderful
pytorch_geometric
Graph Neural Network Library for PyTorch
项目地址：https://gitcode.com/GitHub_Trending/py/pytorch_geometric

开篇：三个典型故障现象

在处理知识图谱、电商推荐系统等复杂数据时，你是否遇到过这些问题：

  1. 维度不匹配错误：当训练包含用户、商品、订单三种节点类型的推荐模型时，控制台突然抛出"RuntimeError: Expected input batch_size (32) to match target batch_size (64)"，且错误堆栈指向异构图卷积层。

  2. 内存溢出崩溃：在学术合作网络数据集上运行关系预测任务时，程序在迭代到第12个epoch时突然崩溃，系统日志显示"Out of memory: Kill process 12345 (python) score 850 or sacrifice child"。

  3. 性能瓶颈问题：使用默认参数训练包含100万节点的异质图时，每个epoch耗时超过45分钟，GPU利用率始终低于30%，且随着训练进行耗时逐渐增加。

这些问题都与异构图卷积（Heterogeneous Graph Convolution）的实现细节密切相关。本文将通过"问题诊断-原理剖析-解决方案-实战验证"四象限框架，帮你系统解决这些挑战。

1. 特征维度对齐：解决"维度不匹配"错误

错误表现

RuntimeError: Dimension 1 mismatch: got 64 vs 128

当使用不同类型节点的特征进行消息传递时，经常会遇到上述维度不匹配错误，尤其在处理知识图谱和推荐系统数据时更为常见。

根因分析

异构图中不同类型节点往往具有不同维度的特征表示：用户节点可能用128维特征，商品节点可能用64维特征，订单节点可能用256维特征。异构图卷积要求同一目标节点类型的所有入边消息必须具有相同维度，否则会在聚合阶段出现维度冲突。

分布式图划分示意图 图1：分布式环境下的图划分示意图，不同节点类型可能分布在不同设备上，加剧了特征维度对齐难度

解决方案

方案1：预对齐输入特征

import torch
import dgl
from dgl.nn import HeteroGraphConv, GraphConv

# 为不同类型节点应用线性变换统一维度
class FeatureAligner(torch.nn.Module):
    def __init__(self, in_dims, out_dim):
        super().__init__()
        self.aligners = torch.nn.ModuleDict()
        for node_type, dim in in_dims.items():
            self.aligners[node_type] = torch.nn.Linear(dim, out_dim)
    
    def forward(self, x_dict):
        return {
            node_type: self.alignersnode_type 
            for node_type, x in x_dict.items()
        }

# 使用示例
in_dims = {'user': 128, 'item': 64, 'order': 256}
aligner = FeatureAligner(in_dims, 64)
x_dict = {
    'user': torch.randn(100, 128),
    'item': torch.randn(200, 64),
    'order': torch.randn(150, 256)
}
aligned_x = aligner(x_dict)  # 所有节点类型特征均为64维

方案2：自适应消息维度转换

# 在卷积层内部处理维度差异
class AdaptiveHeteroConv(torch.nn.Module):
    def __init__(self, in_dims, hidden_dim, out_dim):
        super().__init__()
        self.conv = HeteroGraphConv({
            rel: GraphConv(in_dims[rel[0]], hidden_dim) 
            for rel in [('user', 'buy', 'item'), ('item', 'belong_to', 'category')]
        })
        self.fc = torch.nn.Linear(hidden_dim, out_dim)
    
    def forward(self, g, x_dict):
        h_dict = self.conv(g, x_dict)
        # 对每个节点类型的输出应用线性变换
        return {k: self.fc(v) for k, v in h_dict.items()}

方案对比

方案 优点 缺点 适用场景
预对齐输入特征 实现简单，调试方便 增加额外参数，可能丢失类型特有信息 节点类型较少，特征差异不大
自适应消息转换 保留类型特征，灵活性高 实现复杂，计算开销大 节点类型多，特征差异显著

[!TIP] 最佳实践：对于中小型异构图，推荐使用预对齐方案；对于包含10种以上节点类型的复杂图，建议采用自适应消息转换。

效果验证

# 维度对齐验证工具函数
def validate_dimensions(model, g, x_dict):
    try:
        with torch.no_grad():
            output = model(g, x_dict)
            # 检查所有输出特征维度是否一致
            dims = {k: v.shape[1] for k, v in output.items()}
            if len(set(dims.values())) == 1:
                print(f"✅ 维度验证通过，所有节点类型输出维度均为{dims.values().__iter__().__next__()}")
                return True
            else:
                print(f"❌ 维度验证失败，输出维度: {dims}")
                return False
    except RuntimeError as e:
        print(f"❌ 维度错误: {str(e)}")
        return False

2. 聚合策略选择：解决"语义丢失"问题

错误表现

模型在验证集上的准确率停滞在65%左右，即使增加训练轮次或调整学习率也无法提升。通过特征可视化发现，不同关系类型的消息被无差别处理，导致重要语义信息丢失。

根因分析

异构图中不同关系类型具有不同的语义含义：在电商场景中，"用户-购买-商品"关系与"商品-相似-商品"关系需要不同的聚合策略。使用单一聚合器（如平均聚合）会导致关系特异性信息被稀释。

解决方案

方案1：关系感知聚合器

import torch
import dgl
from dgl.nn import HeteroGraphConv, SAGEConv
from torch.nn import functional as F

# 为不同关系定制聚合器
class RelationAwareConv(torch.nn.Module):
    def __init__(self, in_dims, hidden_dim):
        super().__init__()
        self.conv = HeteroGraphConv({
            # 购买关系使用mean聚合保留整体趋势
            ('user', 'buy', 'item'): SAGEConv(in_dims, hidden_dim, aggregator_type='mean'),
            # 相似关系使用max聚合突出显著特征
            ('item', 'similar', 'item'): SAGEConv(in_dims, hidden_dim, aggregator_type='max'),
            # 评价关系使用lstm聚合捕捉序列信息
            ('user', 'rate', 'item'): SAGEConv(in_dims, hidden_dim, aggregator_type='lstm')
        })
    
    def forward(self, g, x_dict):
        return self.conv(g, x_dict)

方案2：注意力机制聚合

from dgl.nn.pytorch.softmax import edge_softmax
from dgl.nn.pytorch.utils import Identity

class AttentionAggregation(torch.nn.Module):
    def __init__(self, in_feats, hidden_dim):
        super().__init__()
        self.fc = torch.nn.Linear(in_feats, hidden_dim)
        self.attn_fc = torch.nn.Linear(2 * hidden_dim, 1)
        
    def forward(self, nodes):
        # 获取消息和节点特征
        mail = nodes.mailbox['m']  # (B, N, D)
        h = nodes.data['h']         # (B, D)
        
        # 计算注意力分数
        h_expand = h.unsqueeze(1).expand_as(mail)  # (B, N, D)
        concat = torch.cat([h_expand, mail], dim=2)  # (B, N, 2D)
        attn_scores = self.attn_fc(concat).squeeze(2)  # (B, N)
        attn_scores = edge_softmax(nodes, attn_scores)  # (B, N)
        
        # 加权聚合
        return torch.sum(mail * attn_scores.unsqueeze(-1), dim=1)

方案对比

聚合策略 计算复杂度 适用场景 关键超参数
Mean聚合 O(n) 通用场景，稳定鲁棒 -
Max聚合 O(n) 突出显著特征 -
LSTM聚合 O(n log n) 时序关系数据 隐藏层维度，层数
注意力聚合 O(n²) 关系重要性差异大 注意力温度参数

[!WARNING] 注意力聚合虽然效果好，但计算复杂度高，在包含百万级边的大图上可能导致性能问题。

效果验证

# 聚合策略评估函数
def evaluate_aggregation_strategies(model, g, x_dict, labels, mask):
    model.eval()
    with torch.no_grad():
        logits = model(g, x_dict)
        # 计算各节点类型的准确率
        acc_dict = {}
        for node_type in logits:
            if node_type in labels:
                pred = logits[node_type][mask[node_type]].argmax(1)
                true = labels[node_type][mask[node_type]]
                acc_dict[node_type] = (pred == true).float().mean().item()
        return acc_dict

# 测试不同聚合策略
strategies = ['mean', 'max', 'lstm', 'attention']
results = {}
for strategy in strategies:
    model = create_model(aggregator=strategy)
    train_model(model)
    results[strategy] = evaluate_aggregation_strategies(model, g, x_dict, labels, val_mask)

# 打印结果
print("聚合策略准确率对比:")
for strategy, acc in results.items():
    print(f"{strategy}: {acc}")

3. 分布式训练配置：解决"内存溢出"问题

错误表现

CUDA out of memory. Tried to allocate 2048.00 MiB (GPU 0; 11.76 GiB total capacity; 9.23 GiB already allocated; 1.82 GiB free; 9.45 GiB reserved in total by PyTorch)

当处理包含超过100万节点的异质图时，即使使用12GB显存的GPU也经常出现内存溢出错误，尤其在全图训练时更为严重。

根因分析

异构图包含多种节点和关系类型，传统的全图训练需要同时加载所有节点特征和边信息，导致内存占用急剧增加。分布式训练虽然可以解决这一问题，但异质图的分区和通信比同构图复杂得多。

分布式采样示意图 图2：分布式环境下的邻居采样策略，本地节点和远程节点采用不同的处理方式

解决方案

方案1：分布式图分区

import dgl
from dgl.distributed import DistGraph, partition_graph

# 1. 图分区（预处理步骤）
def partition_hetero_graph(g, num_parts, out_path):
    # 为异构图创建分区
    partition_graph(
        g, 
        graph_name='hetero_graph',
        num_parts=num_parts,
        out_path=out_path,
        part_method='metis',  # 适合异构图的分区算法
        hetero=True  # 启用异构图支持
    )

# 2. 分布式训练代码
def distributed_train():
    # 初始化分布式环境
    dgl.distributed.initialize('ip_config.txt')
    g = DistGraph('hetero_graph')  # 加载分布式图
    
    # 创建分布式数据加载器
    sampler = dgl.dataloading.MultiLayerNeighborSampler([10, 5])
    dataloader = dgl.dataloading.DistNodeDataLoader(
        g,
        g.nodes('user'),  # 用户节点作为输入
        sampler,
        batch_size=1024,
        shuffle=True,
        drop_last=False
    )
    
    # 模型训练（省略模型定义和优化器部分）
    for epoch in range(num_epochs):
        for input_nodes, output_nodes, blocks in dataloader:
            # 前向传播和反向传播
            ...

方案2：邻居采样优化

# 针对异构图的高级采样策略
def create_hetero_sampler():
    # 为不同关系类型设置不同的采样数量
    sampler = dgl.dataloading.HeteroNeighborSampler({
        ('user', 'buy', 'item'): 15,  # 购买关系采样15个邻居
        ('user', 'rate', 'item'): 5,   # 评价关系采样5个邻居
        ('item', 'similar', 'item'): 10 # 相似关系采样10个邻居
    })
    return sampler

# 使用带特征缓存的加载器
dataloader = dgl.dataloading.DataLoader(
    g,
    {'user': train_user_ids},
    sampler,
    batch_size=512,
    shuffle=True,
    drop_last=False,
    num_workers=4,
    device=device,
    # 启用特征缓存减少重复加载
    cache_device='cpu' if torch.cuda.is_available() else 'cpu'
)

方案对比

优化策略 内存节省 通信开销 实现复杂度 适用场景
图分区 高(70-80%) 中 高 超大规模图(>1亿节点)
邻居采样 中(40-60%) 低 中 中等规模图(100万-1亿节点)
特征缓存 低(20-30%) 低 低 特征维度高的场景

[!TIP] 实际应用中，推荐组合使用邻居采样和特征缓存，在中等规模图上可实现60-70%的内存节省，且实现复杂度适中。

效果验证

# 内存使用监控函数
import psutil
import torch

def monitor_memory_usage(model, g, x_dict, batch_size):
    # 记录初始内存使用
    initial_memory = torch.cuda.memory_allocated() / (1024 ** 3)
    
    # 执行一次前向传播
    with torch.no_grad():
        output = model(g, x_dict)
    
    # 记录峰值内存使用
    peak_memory = torch.cuda.max_memory_allocated() / (1024 ** 3)
    torch.cuda.reset_peak_memory_stats()
    
    # 计算每样本内存使用
    total_nodes = sum(v.shape[0] for v in x_dict.values())
    memory_per_sample = (peak_memory - initial_memory) / (total_nodes / batch_size)
    
    return {
        'initial_memory_gb': initial_memory,
        'peak_memory_gb': peak_memory,
        'memory_per_sample_mb': memory_per_sample * 1024
    }

4. 性能调优：解决"训练缓慢"问题

错误表现

在包含5种节点类型和10种关系类型的异构图上，使用默认配置训练时，每个epoch耗时超过30分钟，GPU利用率波动在20-40%之间，远低于硬件潜力。

根因分析

异构图训练性能低下通常源于三个方面：(1)不同关系类型的计算负载不均衡；(2)数据加载成为瓶颈；(3)内存访问模式不佳导致缓存利用率低。这些问题在PyTorch Geometric等框架中尤为突出。

解决方案

方案1：计算图优化

# 使用DGL的计算图优化功能
import dgl
from dgl import optim

def optimize_graph_computation(g, model):
    # 1. 启用边类型批处理
    g = dgl.to_homogeneous(g, ndata=['feat'], edata=['weight'])
    
    # 2. 启用计算图优化
    model = torch.jit.script(model)
    
    # 3. 设置适当的CUDA参数
    torch.backends.cudnn.benchmark = True
    torch.backends.cuda.matmul.allow_tf32 = True  # 启用TF32加速
    
    return model

# 混合精度训练
scaler = torch.cuda.amp.GradScaler()
for epoch in range(num_epochs):
    model.train()
    for input_nodes, output_nodes, blocks in dataloader:
        with torch.cuda.amp.autocast():
            loss = model(blocks, input_features)
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()

方案2：数据加载优化

# 优化数据加载流程
def create_optimized_dataloader(g, batch_size=1024):
    # 1. 使用预取和多线程
    sampler = dgl.dataloading.MultiLayerNeighborSampler([10, 5])
    dataloader = dgl.dataloading.DataLoader(
        g,
        g.nodes('user'),
        sampler,
        batch_size=batch_size,
        shuffle=True,
        drop_last=False,
        num_workers=8,  # 根据CPU核心数调整
        pin_memory=True,  # 固定内存到GPU
        persistent_workers=True  # 保持工作进程
    )
    
    # 2. 数据预加载
    prefetch_queue = torch.utils.data.DataLoader(
        dataloader,
        batch_size=None,
        num_workers=1,
        collate_fn=lambda x: x
    )
    
    return prefetch_queue

方案对比

优化技术 加速比 实现难度 副作用
混合精度训练 1.5-2x 低 需调整学习率
计算图优化 1.2-1.5x 中 调试难度增加
数据加载优化 1.3-2x 低 增加CPU内存使用
分布式训练 接近线性加速 高 通信开销增加

效果验证

# 性能基准测试函数
import time
import numpy as np

def benchmark_performance(model, dataloader, num_epochs=3):
    times = []
    model.eval()
    
    for epoch in range(num_epochs):
        start_time = time.time()
        with torch.no_grad():
            for batch in dataloader:
                input_nodes, output_nodes, blocks = batch
                model(blocks, blocks[0].srcdata['feat'])
        epoch_time = time.time() - start_time
        times.append(epoch_time)
        print(f"Epoch {epoch+1} time: {epoch_time:.2f}s")
    
    avg_time = np.mean(times)
    std_time = np.std(times)
    print(f"Average time: {avg_time:.2f}s ± {std_time:.2f}s")
    return avg_time

# 优化前后对比
baseline_time = benchmark_performance(baseline_model, baseline_dataloader)
optimized_time = benchmark_performance(optimized_model, optimized_dataloader)
speedup = baseline_time / optimized_time
print(f"Performance speedup: {speedup:.2f}x")

5. 环境兼容性：解决"版本依赖"问题

错误表现

ImportError: cannot import name 'HeteroGraphConv' from 'dgl.nn'

或在运行时出现

AttributeError: 'HeteroGraphConv' object has no attribute 'forward'

这些错误通常发生在不同版本的DGL库或PyTorch环境中，尤其在团队协作或代码部署时更为常见。

根因分析

异构图卷积API在DGL的不同版本中变化较大：DGL 0.4版本使用HeteroGraphConv，DGL 0.6版本引入HeteroConv，而DGL 1.0版本又进行了API重构。同时，不同PyTorch版本对CUDA和分布式训练的支持也存在差异。

解决方案

环境兼容性矩阵

DGL版本 PyTorch版本 Python版本 CUDA支持 异构图API
0.4.x 1.4-1.6 3.6-3.8 9.2-11.0 HeteroGraphConv
0.6.x 1.6-1.8 3.6-3.9 10.1-11.1 HeteroConv
1.0.x 1.8-1.10 3.7-3.10 10.2-11.3 HeteroGraphConv
1.1.x 1.10-2.0 3.8-3.10 11.3-11.7 HeteroGraphConv

版本适配代码

# 兼容不同DGL版本的异构图卷积定义
def create_hetero_conv(in_dims, out_dim, dgl_version=None):
    import dgl
    from dgl import nn as dglnn
    
    # 自动检测DGL版本
    if dgl_version is None:
        dgl_version = tuple(map(int, dgl.__version__.split('.')))
    
    conv_dict = {
        ('user', 'buy', 'item'): dglnn.GraphConv(in_dims['user'], out_dim),
        ('item', 'similar', 'item'): dglnn.GraphConv(in_dims['item'], out_dim),
        ('user', 'rate', 'item'): dglnn.GraphConv(in_dims['user'], out_dim)
    }
    
    # 根据版本选择不同的API
    if dgl_version < (0, 6):
        return dglnn.HeteroGraphConv(conv_dict)
    elif dgl_version < (1, 0):
        return dglnn.HeteroConv(conv_dict, aggregate='mean')
    else:
        return dglnn.HeteroGraphConv(conv_dict, aggregate='mean')

[!WARNING] DGL 1.0以上版本虽然恢复了HeteroGraphConv名称，但参数结构与0.4版本不兼容，迁移时需要重新调整卷积层定义。

效果验证

# 环境检查工具
def check_environment_compatibility():
    import dgl
    import torch
    import sys
    
    # 版本信息
    print(f"DGL version: {dgl.__version__}")
    print(f"PyTorch version: {torch.__version__}")
    print(f"Python version: {sys.version.split()[0]}")
    print(f"CUDA available: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        print(f"CUDA version: {torch.version.cuda}")
    
    # 兼容性检查
    try:
        from dgl.nn import HeteroGraphConv
        print("✅ HeteroGraphConv is available")
    except ImportError:
        try:
            from dgl.nn import HeteroConv
            print("✅ HeteroConv is available")
        except ImportError:
            print("❌ Heterogeneous convolution API not found")
            return False
    
    # 功能测试
    try:
        g = dgl.heterograph({
            ('user', 'buy', 'item'): (torch.tensor([0, 1]), torch.tensor([0, 1]))
        })
        print("✅ Heterograph creation succeeded")
        return True
    except Exception as e:
        print(f"❌ Heterograph creation failed: {str(e)}")
        return False

反模式识别：5个最易犯的设计错误

  1. 过度复杂的关系类型：定义超过20种关系类型而不进行分组，导致模型难以训练和调试。

  2. 忽略关系权重：所有关系类型使用相同权重，未考虑不同关系的重要性差异。

  3. 特征维度膨胀：盲目增加特征维度以提高性能，导致内存溢出和计算效率低下。

  4. 忽视小样本节点类型：对出现频率低的节点类型缺乏特殊处理，导致这些类型的预测性能差。

  5. 全图推理：在推理阶段使用全图计算而非批量处理，导致部署时性能问题。

问题排查流程图

  1. 维度错误：检查各节点类型特征维度 → 验证卷积层输入输出维度 → 应用特征对齐方案
  2. 内存溢出：监控各阶段内存使用 → 启用邻居采样 → 考虑分布式训练
  3. 性能低下：分析GPU利用率 → 优化数据加载 → 启用混合精度训练
  4. 精度不佳：检查聚合策略 → 增加关系特异性处理 → 调整正则化参数
  5. 环境问题：核对版本兼容性矩阵 → 更新依赖库 → 使用版本适配代码

验证脚本与效果评估

以下是一个完整的异构图卷积模型验证脚本，可用于评估上述解决方案的效果：

"""
异构图卷积模型综合验证脚本
文件路径: examples/hetero/hetero_validation.py
"""
import dgl
import torch
import numpy as np
import time
from sklearn.metrics import accuracy_score

def main():
    # 1. 创建测试异构图
    g = dgl.heterograph({
        ('user', 'buy', 'item'): (torch.randint(0, 1000, (10000,)), torch.randint(0, 500, (10000,))),
        ('user', 'rate', 'item'): (torch.randint(0, 1000, (5000,)), torch.randint(0, 500, (5000,))),
        ('item', 'similar', 'item'): (torch.randint(0, 500, (8000,)), torch.randint(0, 500, (8000,)))
    })
    
    # 添加随机特征
    g.nodes['user'].data['feat'] = torch.randn(1000, 128)
    g.nodes['item'].data['feat'] = torch.randn(500, 64)
    g.nodes['user'].data['label'] = torch.randint(0, 5, (1000,))
    g.nodes['user'].data['train_mask'] = torch.rand(1000) < 0.6
    
    # 2. 创建模型
    from model import HeteroGNN
    model = HeteroGNN(
        in_dims={'user': 128, 'item': 64},
        hidden_dim=64,
        out_dim=5
    ).to('cuda' if torch.cuda.is_available() else 'cpu')
    g = g.to('cuda' if torch.cuda.is_available() else 'cpu')
    
    # 3. 性能基准测试
    print("=== 性能基准测试 ===")
    start_time = time.time()
    with torch.no_grad():
        for _ in range(10):
            model(g, g.ndata['feat'])
    avg_time = (time.time() - start_time) / 10
    print(f"平均前向传播时间: {avg_time:.4f}秒")
    
    # 4. 训练验证
    print("\n=== 训练验证 ===")
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    criterion = torch.nn.CrossEntropyLoss()
    
    for epoch in range(10):
        model.train()
        optimizer.zero_grad()
        logits = model(g, g.ndata['feat'])
        loss = criterion(
            logits['user'][g.nodes['user'].data['train_mask']],
            g.nodes['user'].data['label'][g.nodes['user'].data['train_mask']]
        )
        loss.backward()
        optimizer.step()
        
        # 评估
        model.eval()
        with torch.no_grad():
            logits = model(g, g.ndata['feat'])
            pred = logits['user'].argmax(1)
            acc = accuracy_score(
                g.nodes['user'].data['label'].cpu().numpy(),
                pred.cpu().numpy()
            )
        print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}, Accuracy: {acc:.4f}")
    
    # 5. 内存使用评估
    print("\n=== 内存使用评估 ===")
    if torch.cuda.is_available():
        mem_used = torch.cuda.max_memory_allocated() / (1024 ** 2)
        print(f"最大GPU内存使用: {mem_used:.2f} MB")

if __name__ == "__main__":
    main()

预期效果评估指标

评估维度 baseline 优化后 提升比例
训练速度 30分钟/epoch 8分钟/epoch 275%
内存使用 9.2GB 3.8GB 142%
准确率 0.65 0.78 20%
代码可维护性 低 高 -

扩展学习资源

  1. 论文：《Heterogeneous Graph Attention Network》(WWW 2019) - 异构图注意力机制的奠基性工作
  2. 官方文档：docs/source/modules/nn.rst - DGL异构图卷积API详细说明
  3. 视频教程：DGL官方教程系列 - 异构图神经网络实战
  4. 工具库：DGL-KE - 专门用于知识图谱嵌入的工具包
  5. 实战项目：examples/hetero/ - 包含多种异构图学习任务的完整示例

通过本文介绍的五个突破点，你应该能够解决异构图卷积中遇到的大多数问题。记住，成功的异构图模型设计需要平衡表达能力、计算效率和实现复杂度，没有放之四海而皆准的解决方案，需要根据具体数据特点和任务需求进行调整。

pytorch_geometric
Graph Neural Network Library for PyTorch
项目地址：https://gitcode.com/GitHub_Trending/py/pytorch_geometric
登录后查看全文
热门项目推荐
相关项目推荐

项目优选

收起
kernelkernel
deepin linux kernel
C
27
12
docsdocs
OpenHarmony documentation | OpenHarmony开发者文档
Dockerfile
602
4.04 K
leetcodeleetcode
🔥LeetCode solutions in any programming language | 多种编程语言实现 LeetCode、《剑指 Offer（第 2 版）》、《程序员面试金典（第 6 版）》题解
Java
69
21
flutter_flutterflutter_flutter
暂无简介
Dart
847
204
RuoYi-Vue3RuoYi-Vue3
🎉 (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统
Vue
1.46 K
826
nop-entropynop-entropy
Nop Platform 2.0是基于可逆计算理论实现的采用面向语言编程范式的新一代低代码开发平台，包含基于全新原理从零开始研发的GraphQL引擎、ORM引擎、工作流引擎、报表引擎、规则引擎、批处理引引擎等完整设计。nop-entropy是它的后端部分，采用java语言实现，可选择集成Spring框架或者Quarkus框架。中小企业可以免费商用
Java
12
1
giteagitea
喝着茶写代码！最易用的自托管一站式代码托管平台，包含Git托管，代码审查，团队协作，软件包和CI/CD。
Go
24
0
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
922
770
RuoYi-Cloud-Vue3RuoYi-Cloud-Vue3
🎉 基于Spring Boot、Spring Cloud & Alibaba、Vue3 & Vite、Element Plus的分布式前后端分离微服务架构权限管理系统
Vue
234
152
MindSpeed-LLMMindSpeed-LLM
昇腾LLM分布式训练框架
Python
130
156