云端世界模型与通用机器人：从Sim2Real到边缘部署的技术解析-平芜编程栈

最近在机器人技术社区，RoboScience 在 WRC 2026 上的一系列演示被开发者们称为“封神操作”。这背后不仅仅是酷炫的机器人动作，更是一套融合了云端世界模型、通用机器人本体与控制算法的完整技术栈的集中展示。对于从事机器人、AI、边缘计算或自动化领域的开发者而言，理解这套技术组合背后的逻辑，远比看热闹更有价值。本文将深入拆解“RoboScience机器科学WRC 2026封神操作”所涉及的核心技术概念、架构设计思路以及潜在的开发启示，无论你是机器人领域的初学者，还是希望将AI模型与实体控制结合起来的进阶开发者，都能从中获得一套系统性的技术认知框架。

1. 背景与核心概念：从单点智能到系统协同

在谈论具体的“操作”之前，我们需要先理解当前机器人技术演进的核心矛盾与破局点。

1.1 传统机器人开发的瓶颈

传统的工业机器人或服务机器人开发，大多属于“任务特定型”和“环境结构化”。开发者需要为每一个具体的任务（如拧螺丝、分拣物品）编写精确的控制程序，并在一个预设的、变化极少的环境中运行。一旦环境出现未预见的干扰，或者任务需要稍作调整，整个系统就可能失效。这种模式开发周期长、泛化能力差、成本高昂。

1.2 新一代机器人的技术范式：云端世界模型 + 通用本体

“RoboScience机器科学”所代表的新范式，旨在解决上述瓶颈。其核心由两大支柱构成：

云端世界模型 (Cloud-based World Model)：
- 是什么：一个部署在云端的、持续学习和演化的数字孪生环境与物理规律模拟器。它不仅仅是一个3D场景，更包含了物体属性（质量、摩擦系数）、动力学规律、以及智能体（机器人）与环境交互的因果逻辑。
- 解决什么问题：
  - 安全试错：机器人可以在虚拟世界中以极快的速度进行数百万次尝试和失败，而无需担心损坏实体硬件或造成安全事故。
  - 数据生成与模型训练：为机器人的感知、决策、控制算法提供近乎无限的训练数据。
  - 仿真到真实 (Sim2Real)：通过域随机化等技术，让在虚拟世界中训练出的策略能够更好地迁移到复杂的真实世界。
轮式仿人形通用机器人 (Wheeled Humanoid General-purpose Robot)：
- 是什么：以 REX G1 为典型代表的一类机器人形态。它结合了轮式底盘的高效移动能力，和仿人形上半身的灵巧操作能力。这种设计旨在平衡移动效率与任务泛用性。
- 解决什么问题：
  - 移动效率：在平坦地面，轮式移动远比双足行走快速、节能且稳定。
  - 操作灵巧性：仿人形的双臂和手部设计，使其能够使用为人类设计的工具和工作空间，执行多种精细操作任务。
  - 通用性：一个本体，通过更换不同的AI“大脑”（策略模型），即可适应搬运、接待、巡检、维修等多种任务，降低硬件成本。

1.3 WRC 2026 “封神操作”的技术实质

在WRC这样的顶级舞台上，RoboScience展示的正是这两大技术支柱深度融合的成果。所谓的“封神操作”，可以理解为：在云端世界模型中预训练出高度适应性和鲁棒性的控制策略，并将其无缝部署到REX G1这样的通用机器人本体上，使其在动态、非结构化的真实环境中，完成一系列复杂、连贯且看似“智能”的任务组合。这标志着机器人技术从“硬编码”迈向了“涌现智能”。

2. 技术架构拆解：核心组件与数据流

理解了这个范式，我们可以将其技术架构拆解为几个关键层次，这对于我们思考如何构建类似系统至关重要。

2.1 感知层 (Perception)

机器人通过激光雷达、深度相机、IMU等传感器获取环境信息。

# 伪代码示例：一个简化的感知数据融合节点（ROS2风格） import rclpy from sensor_msgs.msg import Image, LaserScan from geometry_msgs.msg import Twist class PerceptionNode(Node): def __init__(self): super().__init__('perception_node') # 订阅摄像头和雷达数据 self.camera_sub = self.create_subscription(Image, '/camera/image_raw', self.image_callback, 10) self.lidar_sub = self.create_subscription(LaserScan, '/scan', self.lidar_callback, 10) # 发布融合后的环境状态 self.env_state_pub = self.create_publisher(EnvState, '/env_state', 10) def image_callback(self, msg): # 使用深度学习模型（如YOLO）进行目标检测 # 提取物体类别、位置、姿态等信息 self.detected_objects = detect_objects(msg) def lidar_callback(self, msg): # 处理点云数据，进行障碍物检测和地图构建 self.obstacle_map = process_lidar(msg) def fuse_and_publish(self): # 融合视觉和激光数据，生成统一的环境状态表示 fused_state = fuse(self.detected_objects, self.obstacle_map) self.env_state_pub.publish(fused_state)

关键点：感知层输出的不是原始数据，而是经过处理的、结构化的“环境状态表示”，这是世界模型的输入之一。

2.2 云端世界模型层 (Cloud World Model)

这是系统的“大脑”和“训练场”。它可能包含以下模块：

物理引擎：如NVIDIA Isaac Sim、PyBullet、MuJoCo，用于高保真仿真。
场景库：包含各种室内外场景、物体模型、光照、纹理等。
智能体模型：精确的REX G1机器人数字孪生模型，包括其动力学参数。
强化学习训练框架：如Ray RLlib、Stable-Baselines3，用于训练控制策略。
模型仓库：存储训练好的策略模型、感知模型等。

# 示例：一个强化学习训练任务的配置片段 (Ray RLlib) env: “REX_G1_OfficeEnv” # 自定义仿真环境 framework: “torch” run: “PPO” # 使用PPO算法 model: fcnet_hiddens: [256, 256] # 策略网络结构 env_config: difficulty: “medium” randomize_objects: true # 启用域随机化 stop: timesteps_total: 10000000 # 训练一千万步

关键点：训练是在充满随机性的仿真环境中进行的，以确保学到的策略具有鲁棒性。

2.3 决策与控制层 (Decision & Control)

这一层运行在机器人本体的边缘计算单元（如Jetson AGX Orin）上。

本地策略网络：加载从云端下发的、轻量化的训练好的策略模型。
状态输入：接收来自感知层的实时环境状态。
动作输出：策略网络根据当前状态，直接输出底层控制指令（如关节目标角度、轮子转速）。

# 伪代码示例：边缘设备上的策略执行 import onnxruntime as ort # 使用ONNX Runtime部署训练好的模型 import numpy as np class PolicyExecutor: def __init__(self, model_path): self.session = ort.InferenceSession(model_path) self.action_dim = 12 # 假设REX G1有12个控制自由度 def get_action(self, observation): # observation: 从感知层来的状态向量，如[目标位置，自身姿态，障碍物距离...] obs_array = np.array(observation, dtype=np.float32).reshape(1, -1) # 运行策略网络，得到动作 inputs = {self.session.get_inputs()[0].name: obs_array} action = self.session.run(None, inputs)[0] # 将动作转换为具体的控制指令 control_cmd = self._action_to_control(action) return control_cmd def _action_to_control(self, action): # 将神经网络输出的归一化动作，映射到实际的电机控制命令 # 例如，将[-1, 1]映射到关节的角度范围 joint_targets = ... # 映射计算 return joint_targets

关键点：边缘部署要求模型必须轻量化、低延迟。通常需要将PyTorch/TensorFlow模型转换为ONNX或TensorRT格式。

2.4 本体硬件层 (Hardware)

即REX G1机器人本身，包含：

执行器：高扭矩的关节电机、轮毂电机。
控制器：接收控制指令，驱动执行器，并返回编码器反馈。
电源与管理：为整个系统供电。

3. 从仿真到真实 (Sim2Real) 的核心技术

这是整个系统能否成功的关键，也是“封神操作”得以实现的魔法所在。

3.1 域随机化 (Domain Randomization)

在仿真训练时，随机化各种环境参数，让模型学会忽略无关细节，关注核心物理规律。

视觉外观随机化：物体颜色、纹理、光照强度与角度。
物理参数随机化：摩擦系数、物体质量、电机阻尼、传感器噪声。
场景布局随机化：物体位置、朝向、数量。

# 伪代码：在仿真环境中设置域随机化 def reset_simulation_env(): # 随机化光照 light_intensity = np.random.uniform(0.7, 1.3) set_light(light_intensity) # 随机化物体摩擦 for obj in scene.objects: obj.friction = np.random.uniform(0.5, 1.5) # 随机化摄像头噪声 camera.noise_mean = np.random.uniform(-0.01, 0.01) camera.noise_std = np.random.uniform(0.0, 0.02) # 随机化目标物体位置 target_obj.position = get_random_position_within_bounds()

原理：通过让模型在“无数个可能的世界”中训练，它学到的策略会更侧重于任务本身的物理逻辑（如“推动物体需要施加力”），而非某个特定世界的视觉或物理特征，从而提升在未知真实世界中的泛化能力。

3.2 系统辨识与模型校准

为了让仿真世界尽可能贴近真实，需要对机器人本体进行精确的系统辨识。

动力学参数辨识：通过让机器人执行特定动作并记录数据，来反推其质量、惯性矩、摩擦等真实参数。
传感器标定：校准相机、激光雷达、IMU的内外参数和偏差。
执行器建模：精确建模电机的响应特性、延迟和扭矩-速度曲线。

3.3 在线自适应与微调

即使经过上述步骤，仿真与真实之间仍有差距。因此，系统需要具备在线学习能力。

残差学习：在真实环境中，用一个小的神经网络来学习“仿真策略”与“完美策略”之间的残差，并在线调整。
元学习：让模型学会如何快速适应新的物理特性。
人机协同示范：通过遥操作或示教，收集少量真实世界数据，对策略进行微调。

4. 开发实战：构建一个简易的“云端训练-边缘部署”管道

虽然我们无法复现一个完整的REX G1，但可以搭建一个微型项目来理解这个工作流。我们将用一个简单的二维移动小车（CartPole类似问题）来模拟。

4.1 环境准备与项目结构

操作系统：Ubuntu 20.04/22.04 LTS (推荐，对ROS和AI框架支持好)
Python：3.8+
主要库：
- gym/gymnasium: 创建仿真环境。
- stable-baselines3: 强化学习算法库。
- onnxruntime/libtorch: 模型边缘部署。
- pygame(可选): 简易可视化。
项目结构：

sim2real_demo/ ├── train/ # 云端训练部分 │ ├── train.py # 训练脚本 │ ├── custom_env.py # 自定义仿真环境 │ └── requirements.txt ├── deploy/ # 边缘部署部分 │ ├── inference.py # 边缘推理脚本 │ ├── simple_robot_sim.py # 一个简单的真实环境模拟（代替真实硬件） │ └── requirements.txt └── models/ # 存放训练好的模型 ├── sb3_model.zip └── model.onnx

4.2 步骤一：在云端（本地模拟）训练策略

首先，我们创建一个有随机化元素的环境，并训练一个策略。

文件：train/custom_env.py

import gymnasium as gym from gymnasium import spaces import numpy as np class RandomizedCartPoleEnv(gym.Env): """带域随机化的CartPole环境""" def __init__(self): super().__init__() # 动作空间：向左/向右推 self.action_space = spaces.Discrete(2) # 状态空间：[车位置，车速，杆角度，杆角速度] self.observation_space = spaces.Box(low=-np.inf, high=np.inf, shape=(4,), dtype=np.float32) # 物理参数（将在每次重置时随机化） self.gravity = 9.8 self.masscart = 1.0 self.masspole = 0.1 self.length = 0.5 self.force_mag = 10.0 self.tau = 0.02 # 仿真时间步长 self.state = None self.steps_beyond_terminated = None def reset(self, seed=None, options=None): super().reset(seed=seed) # ！！！域随机化核心：每次重置环境时随机化物理参数！！！ self.masscart = np.random.uniform(0.8, 1.2) # 小车质量随机 self.masspole = np.random.uniform(0.08, 0.12) # 杆质量随机 self.length = np.random.uniform(0.4, 0.6) # 杆长随机 # 状态初始化 self.state = np.array([np.random.uniform(-0.05, 0.05), 0., np.random.uniform(-0.05, 0.05), 0.], dtype=np.float32) self.steps_beyond_terminated = None return self.state, {} def step(self, action): # 标准的CartPole动力学方程（但使用了随机化的参数） x, x_dot, theta, theta_dot = self.state force = self.force_mag if action == 1 else -self.force_mag costheta = np.cos(theta) sintheta = np.sin(theta) # 动力学计算（包含随机化后的参数） temp = (force + self.masspole * self.length * theta_dot**2 * sintheta) / (self.masscart + self.masspole) thetaacc = (self.gravity * sintheta - costheta * temp) / (self.length * (4.0/3.0 - self.masspole * costheta**2 / (self.masscart + self.masspole))) xacc = temp - self.masspole * self.length * thetaacc * costheta / (self.masscart + self.masspole) # 欧拉积分 x = x + self.tau * x_dot x_dot = x_dot + self.tau * xacc theta = theta + self.tau * theta_dot theta_dot = theta_dot + self.tau * thetaacc self.state = np.array([x, x_dot, theta, theta_dot], dtype=np.float32) # 终止条件 terminated = bool( x < -2.4 or x > 2.4 or theta < -0.2 or theta > 0.2 ) reward = 1.0 if not terminated else 0.0 return self.state, reward, terminated, False, {}

文件：train/train.py

from stable_baselines3 import PPO from stable_baselines3.common.env_util import make_vec_env from custom_env import RandomizedCartPoleEnv import os # 1. 创建并行化环境（增加数据采样效率） env = make_vec_env(RandomizedCartPoleEnv, n_envs=4) # 2. 创建PPO模型 model = PPO( "MlpPolicy", env, verbose=1, learning_rate=3e-4, n_steps=2048, batch_size=64, n_epochs=10, gamma=0.99, gae_lambda=0.95, clip_range=0.2, ent_coef=0.0, ) # 3. 训练模型 print("开始训练...") model.learn(total_timesteps=500_000) # 训练50万步 # 4. 保存模型 os.makedirs("../models", exist_ok=True) model.save("../models/sb3_model") print("模型已保存至 ../models/sb3_model.zip") # 5. （可选）测试训练效果 obs = env.reset() for i in range(1000): action, _states = model.predict(obs, deterministic=True) obs, rewards, dones, info = env.step(action) if dones.any(): print(f"Episode finished at step {i}") break env.close()

4.3 步骤二：模型转换与边缘部署

训练好的模型需要转换为适合边缘设备部署的格式。

首先，将 Stable-Baselines3 模型转换为 ONNX 格式：

# 文件：train/export_to_onnx.py import torch from stable_baselines3 import PPO from custom_env import RandomizedCartPoleEnv import onnx import onnxruntime as ort # 加载训练好的模型 model = PPO.load("../models/sb3_model") # 提取PyTorch策略网络 policy = model.policy policy.to('cpu') policy.eval() # 创建一个示例输入 dummy_input = torch.randn(1, 4) # 状态向量维度为4 # 导出为ONNX格式 torch.onnx.export( policy, dummy_input, "../models/policy_model.onnx", input_names=["observation"], output_names=["action"], dynamic_axes={'observation': {0: 'batch_size'}, 'action': {0: 'batch_size'}}, opset_version=12, verbose=True ) print("模型已导出为 ONNX 格式。") # 验证ONNX模型 onnx_model = onnx.load("../models/policy_model.onnx") onnx.checker.check_model(onnx_model) print("ONNX 模型检查通过。") # 使用ONNX Runtime进行简单推理测试 ort_session = ort.InferenceSession("../models/policy_model.onnx") input_name = ort_session.get_inputs()[0].name output_name = ort_session.get_outputs()[0].name test_input = dummy_input.numpy() ort_inputs = {input_name: test_input} ort_output = ort_session.run([output_name], ort_inputs) print(f"测试输入: {test_input}") print(f"ONNX推理输出: {ort_output}")

然后，在边缘设备（这里用另一个Python脚本模拟）上加载并运行模型：文件：deploy/inference.py

import onnxruntime as ort import numpy as np import time class EdgePolicy: def __init__(self, onnx_model_path): # 加载ONNX模型，指定CPU或CUDA执行提供者 providers = ['CPUExecutionProvider'] # 如果是NVIDIA Jetson设备，可以尝试：providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] self.session = ort.InferenceSession(onnx_model_path, providers=providers) self.input_name = self.session.get_inputs()[0].name def predict(self, observation): """根据观测状态，返回动作""" # 确保输入形状正确 [batch_size, obs_dim] obs_array = np.array(observation, dtype=np.float32).reshape(1, -1) # 运行推理 ort_inputs = {self.input_name: obs_array} action_logits = self.session.run(None, ort_inputs)[0] # 输出是动作的概率分布或值 # 对于离散动作空间，取概率最高的动作 action = np.argmax(action_logits[0]) return action # 模拟一个简单的“真实”环境（与仿真环境动力学参数略有不同） class SimpleRealCartPole: def __init__(self): # 注意：这里的“真实”参数与训练环境的默认值/随机范围都不同 self.gravity = 9.81 self.masscart = 1.1 # 与训练时不同 self.masspole = 0.09 # 与训练时不同 self.length = 0.55 # 与训练时不同 self.force_mag = 10.0 self.tau = 0.02 self.state = np.array([0.0, 0.0, 0.05, 0.0], dtype=np.float32) # 初始状态 def step(self, action): # 使用“真实”动力学方程计算下一步（代码与训练环境类似，但参数不同） x, x_dot, theta, theta_dot = self.state force = self.force_mag if action == 1 else -self.force_mag costheta = np.cos(theta) sintheta = np.sin(theta) temp = (force + self.masspole * self.length * theta_dot**2 * sintheta) / (self.masscart + self.masspole) thetaacc = (self.gravity * sintheta - costheta * temp) / (self.length * (4.0/3.0 - self.masspole * costheta**2 / (self.masscart + self.masspole))) xacc = temp - self.masspole * self.length * thetaacc * costheta / (self.masscart + self.masspole) x = x + self.tau * x_dot x_dot = x_dot + self.tau * xacc theta = theta + self.tau * theta_dot theta_dot = theta_dot + self.tau * thetaacc self.state = np.array([x, x_dot, theta, theta_dot], dtype=np.float32) terminated = bool( x < -2.4 or x > 2.4 or theta < -0.2 or theta > 0.2 ) reward = 1.0 if not terminated else 0.0 return self.state, reward, terminated # 主循环：边缘部署与运行 if __name__ == "__main__": print("=== 边缘策略部署与测试 ===") # 1. 加载策略 policy = EdgePolicy("../models/policy_model.onnx") print("ONNX策略模型加载成功。") # 2. 初始化“真实”环境 env = SimpleRealCartPole() state = env.state total_reward = 0 max_steps = 500 # 3. 运行交互循环 for step in range(max_steps): # 感知（这里直接获取状态） observation = state # 决策（边缘推理） action = policy.predict(observation) # 控制（执行动作，并获取新状态） next_state, reward, done = env.step(action) total_reward += reward state = next_state # 简单打印 if step % 50 == 0: print(f"Step {step}: State={state.round(3)}, Action={action}, Reward={reward}") if done: print(f"任务终止于第 {step} 步。") break print(f"测试结束。累计奖励: {total_reward}") print(f"模型在参数不同的‘真实’环境中坚持了 {step} 步。")

4.4 运行与结果分析

在train/目录下运行python train.py，开始训练。你会看到训练日志，最终模型会保存。
运行python export_to_onnx.py，将模型转换为ONNX格式。
切换到deploy/目录，运行python inference.py。
观察输出。尽管“真实”环境的物理参数与训练环境均不相同，且每次训练的环境参数都在随机变化，但经过域随机化训练的模型，依然能在“真实”环境中较好地完成任务（保持杆子不倒）。这直观地演示了Sim2Real的有效性。

结果说明：如果累计奖励接近500（即坚持了500步直到循环结束），说明策略成功泛化到了未见过的物理参数环境。如果很快失败，可以尝试增加训练步数（total_timesteps）或调整域随机化的范围。

5. 常见问题与排查思路

在实际搭建和调试此类系统时，会遇到许多典型问题。

问题现象	可能原因	排查思路与解决方案
仿真训练收敛慢或不收敛	1. 奖励函数设计不合理。 2. 环境随机化强度过大或过小。 3. 神经网络结构或超参数不当。 4. 仿真步长（`tau`）设置不合理，导致数值不稳定。	1.简化问题：先用一个极简的、确定性的环境测试算法是否能收敛。 2.调试奖励：可视化每一步的奖励，确保其与期望行为强相关。 3.调整随机化：逐步增加随机化强度，观察训练曲线。 4.调整超参：系统性地调整学习率、批次大小等，可使用如Optuna等超参优化库。 5.检查动力学：确保仿真物理方程编写正确，单位一致。
仿真表现好，真实世界完全失败	1.Sim2Real Gap过大：仿真与真实物理/感知差异巨大。 2.执行器延迟与噪声：仿真中未建模电机响应延迟、通信延迟或传感器噪声。 3.状态估计误差：仿真中直接获取完美状态，真实世界依赖有噪声的状态估计（如里程计、滤波器）。	1.增强域随机化：在仿真中加入延迟、噪声、动力学参数扰动。 2.系统辨识：精确测量真实机器人的物理参数并更新仿真模型。 3.在环训练：使用真实数据微调仿真模型，或采用残差学习。 4.改进状态估计：在仿真中也使用带噪声的状态输入进行训练。
边缘部署推理速度慢	1. 模型过大或过于复杂。 2. 未使用适合硬件的推理引擎（如TensorRT for NVIDIA, CoreML for Apple）。 3. 数据预处理/后处理耗时。	1.模型轻量化：使用剪枝、量化、知识蒸馏等技术减小模型。 2.转换优化：将ONNX模型进一步转换为针对硬件的优化格式（如TensorRT的`.engine`）。 3.性能剖析：使用工具分析推理各阶段耗时，优化瓶颈。
策略在真实世界不稳定、抖动	1. 控制频率过高或过低。 2. 策略输出动作变化过于剧烈。 3. 未考虑机器人本身的控制带宽和扭矩限制。	1.动作平滑：对策略输出的动作进行低通滤波。 2.在奖励函数中加入平滑项：惩罚大的加速度或力矩变化。 3.仿真建模限制：在仿真中更精确地建模执行器的速度、扭矩极限。

6. 最佳实践与工程建议

基于RoboScience等前沿实践，可以总结出以下工程化建议：

6.1 仿真环境构建

保真度与速度的权衡：无需一味追求图形渲染逼真度，应更关注物理模拟的准确性。对于控制策略训练，有时“白模”+精确物理比高清纹理更有效。
模块化设计：将机器人模型、环境场景、任务定义、传感器模型分离，便于组合和复用。
自动化测试：建立仿真中的自动化测试流水线，定期评估不同版本策略在多种随机化环境下的性能。

6.2 训练流程

课程学习：从简单任务和场景开始训练，逐步增加难度和随机性，可以加速收敛并提高最终性能。
分布式训练：利用云计算资源进行大规模并行采样，这是缩短训练周期的关键。
版本控制：对代码、环境配置、模型检查点、训练日志进行严格的版本控制（如DVC, Weights & Biases, MLflow）。

6.3 部署与运维

A/B测试与灰度发布：在真实机器人上部署新策略时，先在小部分机器上测试，同时保留旧策略作为回滚备份。
健康监控与安全守护：部署“安全策略”或监控模块，实时检测机器人的状态（如关节超限、电量过低、剧烈抖动），一旦异常立即切换为安全模式或停止。
数据回流：建立管道，将真实机器人运行中遇到的新情况、新数据自动回传至云端，用于持续优化世界模型和策略。这是实现终身学习的关键。

6.4 安全与伦理

模拟所有故障模式：在仿真中主动注入各种故障（传感器失效、执行器卡死、网络延迟）进行训练，使策略学会应对。
人类在环：对于关键任务或高风险场景，必须设计人机交互接口，允许人类随时接管或干预。
可解释性：尝试对策略的决策过程进行可视化或归因分析，增加系统的可信度。

从WRC 2026上令人惊叹的演示回到工程现实，构建一个可靠的“云端世界模型+通用机器人”系统依然充满挑战。然而，其技术路径已经清晰：以高保真、可随机化的仿真为训练基础，以强化学习等AI方法为决策核心，以轻量化、低延迟的边缘推理为执行手段，并通过数据闭环实现持续进化。对于开发者而言，可以从本文介绍的简易管道入手，深入掌握仿真环境搭建、强化学习算法、模型转换与边缘部署这一完整工具链。随后，可以逐步尝试更复杂的机器人模型（如用PyBullet或Isaac Sim模拟双足或轮式机器人）和更丰富的任务。这个领域正在快速从实验室走向产业应用，现在正是深入学习和实践的最佳时机。