月级别预训练是千亿 / 百亿参数大模型（如 Llama 3-70B、Qwen3-8B、盘古系列）获得通用能力的核心阶段，依托昇思 MindSpore Transformers（Mcore）与昇腾 NPU 集群，通过万亿级 token 数据、3D 并行分布式架构、长稳训练优化，耗时通常在1-3 个月（依模型规模、算力集群与数据量而定）。该阶段决定模型的语言理解、知识储备与推理上限，需解决海量数据处理、超大规模分布式训练稳定性、算力极致利用三大核心难题，是国产大模型自主化的关键环节。

一、月级别预训练核心内容

（一）训练规模与时间基准

月级别预训练针对 **≥7B 参数的大模型，核心特征是数据量≥万亿 token、训练轮次≥1000 亿 step、集群规模≥32 卡 **，时间分布如下：

• 7B-13B 模型：8-32 卡昇腾 910，1-1.5 个月，数据量 1-2T token；
• 34B-70B 模型：64-128 卡昇腾 910，1.5-2.5 个月，数据量 5-8T token；
• 100B + 模型：256 卡以上集群，2-3 个月，数据量 10-13T token（如盘古 Ultra 135B，13.2T token，近万卡集群训练数月）。

时间消耗主要来自三部分：数据预处理（10%-15%）、核心训练（70%-80%）、断点续训 / 稳定性维护（5%-10%），昇思通过动态 packing、重计算通信掩盖等技术可缩短约 40% 训练周期。

（二）三阶段预训练策略（月级长稳核心）

昇思采用分阶段渐进式训练，保障月级训练的稳定性与能力递进，参考盘古 Ultra 与 Llama 系列实践：

1. 通用能力阶段（第 1 个月，占比 70%）：12T 通用语料（中 / 英文书籍、网页、百科），学习语言语法、基础常识与表达能力，重点优化收敛速度与基础损失，启用基础 3D 并行（数据 + 张量 + 流水线）；
2. 推理强化阶段（第 2 个月，占比 20%）：0.8T 高质量数据（数学、代码、逻辑推理），强化思维链（CoT）与复杂问题解决能力，调整学习率（衰减至 1/10），启用专家并行（MoE）与重计算优化；
3. 退火稳定阶段（第 3 个月，占比 10%）：0.4T 指令数据，巩固知识应用能力，学习率降至 1/100，启用全链路稳定性优化（梯度裁剪、loss 监控、断点自动保存），防止长训练后期性能崩塌。

（三）核心技术支撑（月级训练的关键保障）

1. 昇思 Mcore 训推一体架构：原生支持3D 混合并行（数据 DP + 张量 TP + 流水线 PP + 专家 EP），可将 70B 模型切分至 64 卡，单卡显存占用降至 15GB；集成ZeroBubbleV 流水线并行，降低跨卡通信气泡耗时，长序列训练效率提升 30%；
2. 海量数据处理流水线：支持 TB 级原始数据清洗→去重→分词→格式转换→分片存储全自动化，输出 MindRecord 二进制格式（读取速度提升 5 倍）；采用动态 packing 技术，将短样本拼接为长序列，减少无效 padding，训练吞吐提升 40%；
3. 长稳训练优化体系：内置断点续训（每 1 小时自动保存）、异常检测（loss 突刺 / 梯度爆炸自动回退）、集群容错（单卡故障自动剔除）；通过TinyInit 初始化、DSSN 动态缩放，确保月级训练无中断、无性能崩塌；
4. 算力极致利用：深度适配昇腾 910/310 的Cube 单元与 NEON 指令集，算子全下沉至 Native 层；启用算子融合、KV 缓存优化、混合精度（FP16/BF16），单卡算力利用率达 90%+。

（四）核心配置要点（月级训练的参数基准）

二、月级别预训练核心代码实现

（一）环境准备与依赖安装（昇腾 910 集群）

# 1. 克隆昇思MindFormers（Mcore核心仓库）
git clone https://gitee.com/mindspore/mindformers.git
cd mindformers
# 2. 安装依赖（适配昇腾2.2/CANN 7.0）
pip install mindspore==2.7.0 mindformers==1.6.0
pip install numpy pandas pyarrow sentencepiece
# 3. 编译安装昇腾通信库（多机并行必需）
bash scripts/build_ascend.sh

（二）海量数据预处理脚本（月级数据准备核心）

# tools/dataset/llm_pretrain_data_process.py
import os
import argparse
from mindformers.dataset import build_dataset
from mindformers.tools import logger

def preprocess_pretrain_data(
    raw_data_dir: str,
    output_dir: str,
    tokenizer_path: str,
    seq_length: int = 4096,
    num_shards: int = 32  # 分片数=集群卡数，适配多卡读取
):
    """
    月级预训练数据预处理：原始文本→MindRecord分片
    处理1T数据约12小时，输出32个分片，每个32GB
    """
    os.makedirs(output_dir, exist_ok=True)
    logger.info(f"开始预处理数据，序列长度：{seq_length}，分片数：{num_shards}")

    # 构建数据集（清洗、去重、分词、格式化）
    dataset = build_dataset({
        "type": "LLMPretrainDataset",
        "data_dir": raw_data_dir,
        "tokenizer": {
            "type": "LlamaTokenizer",
            "vocab_file": tokenizer_path
        },
        "seq_length": seq_length,
        "shuffle": True,
        "num_workers": 8
    })

    # 导出为MindRecord分片（二进制格式，读取加速5倍）
    dataset.export(
        output_path=os.path.join(output_dir, "pretrain_data"),
        file_format="mindrecord",
        num_shards=num_shards
    )
    logger.info(f"数据预处理完成，输出目录：{output_dir}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--raw_data_dir", required=True, help="原始文本数据目录")
    parser.add_argument("--output_dir", required=True, help="处理后数据输出目录")
    parser.add_argument("--tokenizer_path", required=True, help="分词器路径")
    parser.add_argument("--seq_length", type=int, default=4096)
    parser.add_argument("--num_shards", type=int, default=32)
    args = parser.parse_args()
    preprocess_pretrain_data(**vars(args))

（三）月级预训练配置文件（70B 模型 64 卡，2 个月周期）

# configs/llama3/pretrain_llama3_70b_64card.yaml
# 1. 基础配置
run_mode: "train"
model_type: "llama3"
model_size: "70b"
seq_length: 8192
batch_size: 64          # 全局批次=微批次×卡数=2×64
micro_batch_size: 2
num_train_epochs: 1      # 按step训练，epoch设为1
max_train_steps: 1200000 # 总step，约2个月（64卡，每秒50步）

# 2. 模型架构配置（Llama3-70B）
model_config:
  hidden_size: 8192
  num_layers: 80
  num_heads: 64
  intermediate_size: 28672
  rms_norm_eps: 1e-5
  use_rope: True
  rope_scaling: 1.0

# 3. 分布式并行配置（64卡：DP=8, TP=4, PP=2）
parallel_config:
  data_parallel: 8
  tensor_parallel: 4
  pipeline_parallel: 2
  expert_parallel: 1
  enable_alltoall: True
  zero_stage: 2          # ZeRO优化，节省显存

# 4. 优化器与学习率（月级长稳核心）
optimizer:
  type: "AdamW"
  learning_rate: 1e-4
  weight_decay: 0.01
  beta1: 0.9
  beta2: 0.999
  lr_scheduler:
    type: "CosineAnnealingLR"
    T_max: 1200000
    eta_min: 1e-6        # 退火阶段最低学习率

# 5. 稳定性配置（月级训练必需）
train_config:
  save_steps: 1000       # 每1000step保存断点（1小时/次）
  log_steps: 100
  eval_steps: 5000
  keep_checkpoint_max: 20 # 保留最新20个断点
  gradient_accumulation_steps: 4
  clip_grad_norm: 1.0    # 梯度裁剪，防止爆炸
  dynamic_loss_scale: True # 动态损失缩放

# 6. 数据路径
train_dataset_dir: "/mnt/pretrain_data/llama3_70b_8192"

（四）月级预训练启动脚本（多机 64 卡，长稳训练）

# scripts/msrun_pretrain_70b.sh
#!/bin/bash
# 多机多卡启动（8节点×8卡=64卡）
export RANK_SIZE=64
export MASTER_ADDR="192.168.1.100"  # 主节点IP
export MASTER_PORT=29500
export CANN_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
export HCCL_CONNECT_TIMEOUT=1200  # 长训练通信超时延长

# 启动msrun分布式训练（月级长稳，后台运行）
nohup bash scripts/msrun_launcher.sh "python run_mindformer.py \
--config configs/llama3/pretrain_llama3_70b_64card.yaml \
--use_parallel True \
--run_mode train \
--auto_resume True" 64 > pretrain_70b.log 2>&1 &

echo "月级预训练已启动，日志：pretrain_70b.log"
echo "训练周期：约2个月，总step：1200000"

（五）核心训练逻辑代码（Mcore 底层，长稳训练核心）

# mindformers/core/llm_trainer.py（简化版，月级训练核心）
import time
import mindspore as ms
from mindspore import nn
from mindformers import Trainer
from mindformers.tools.logger import logger

class LLMPretrainTrainer(Trainer):
    def __init__(self, config):
        super().__init__(config)
        self.model = self.build_model()
        self.optimizer = self.build_optimizer()
        self.dataset = self.build_dataset()
        self.loss_fn = nn.CrossEntropyLoss(label_smoothing=0.1)
        # 月级训练：加载最新断点（自动续训）
        self.load_checkpoint(auto_resume=True)

    def train_step(self, batch_data):
        """单步训练（混合精度+重计算，节省显存）"""
        input_ids, labels = batch_data
        with ms.amp.autocast():
            logits = self.model(input_ids)
            loss = self.loss_fn(logits.view(-1, self.config.vocab_size), labels.view(-1))
        # 反向传播+梯度裁剪
        grads = ms.grad(self.model)(loss)
        grads = ms.clip_by_norm(grads, self.config.clip_grad_norm)
        self.optimizer(grads)
        return loss

    def run(self):
        """月级长稳训练主循环（支持断点续训+异常回退）"""
        logger.info(f"开始月级预训练，总step：{self.config.max_train_steps}")
        self.model.set_train(True)
        start_time = time.time()
        total_loss = 0.0

        for step, batch_data in enumerate(self.dataset):
            if step >= self.config.max_train_steps:
                break
            # 单步训练
            loss = self.train_step(batch_data)
            total_loss += loss.asnumpy()

            # 日志打印（每100步）
            if step % self.config.log_steps == 0:
                avg_loss = total_loss / (step + 1)
                elapsed = (time.time() - start_time) / 3600
                logger.info(f"Step: {step}, Loss: {avg_loss:.4f}, 耗时: {elapsed:.2f}h")

            # 保存断点（每1000步，月级训练关键）
            if step % self.config.save_steps == 0:
                self.save_checkpoint()
                logger.info(f"断点已保存，Step: {step}")

        logger.info("月级预训练完成！")

三、训练监控与稳定性保障（月级训练必备）

1. 实时监控体系：通过MindInsight可视化训练过程，监控 loss 曲线（防止后期突刺）、显存利用率（≥85% 为优）、通信耗时（占比≤10% 为正常）；
2. 异常自动处理：内置loss 阈值监控（连续 10 步 loss 飙升 2 倍自动回退至最近断点）、卡故障检测（单卡无响应自动剔除，训练不中断）；
3. 断点管理策略：每小时自动保存断点，保留最新 20 个，支持跨节点续训，即使集群重启也可无缝恢复，避免月级训练功亏一篑。

四、价值与意义

昇思大模型月级别预训练，依托国产算力 + 自研框架，打破国外技术垄断，实现千亿级大模型训练的自主可控。对产业而言，月级稳定训练能力是大模型商业化落地的基础，可支撑政务、金融、工业等领域的专属大模型开发；对技术而言，通过 3D 并行、长稳优化、动态 packing 等核心技术，将训练周期从 3 个月缩短至 1.5 个月，大幅降低训练成本。