# Python小模型开发必须掌握的基础语法详解 基于Python进行小模型开发需要掌握的核心基础语法可以分为以下几个关键模块： ## 1. 基础数据类型和操作 ### 数值类型 ```python # 整数和浮点数操作 a = 10 # 整数 b = 3.14 # 浮点数 c = a + b # 数值运算 d = 2 ** 3 # 幂运算：8 # 布尔类型 is_training = True is_evaluating = False ``` ### 字符串操作 ```python # 字符串处理 model_name = "tiny_llama" version = "1.0" full_name = f"{model_name}_v{version}" # f-string格式化 # 字符串方法 text = " Hello, World! " cleaned = text.strip().lower() # 去除空格并转为小写 ``` ## 2. 数据结构 ### 列表(List) ```python # 列表操作 - 常用于数据批处理 batch_data = [1, 2, 3, 4, 5] batch_data.append(6) # 添加元素 batch_size = len(batch_data) # 获取长度 # 列表推导式 - 数据处理常用 squared = [x**2 for x in batch_data if x > 2] ``` ### 字典(Dict) ```python # 字典 - 用于模型参数配置 model_config = { "hidden_size": 512, "num_layers": 6, "learning_rate": 0.001 } # 访问和修改 hidden_dim = model_config["hidden_size"] model_config["batch_size"] = 32 ``` ### 元组(Tuple) ```python # 元组 - 用于不可变数据 input_shape = (32, 784) # 批大小, 特征维度 output_shape = (32, 10) # 批大小, 类别数 ``` ## 3. 控制流程 ### 条件语句 ```python # if-elif-else 用于训练逻辑控制 if epoch < 10: learning_rate = 0.01 elif epoch < 50: learning_rate = 0.001 else: learning_rate = 0.0001 ``` ### 循环语句 ```python # for循环 - 遍历训练数据 for batch_idx, (inputs, targets) in enumerate(dataloader): outputs = model(inputs) loss = criterion(outputs, targets) if batch_idx % 100 == 0: print(f"Batch {batch_idx}, Loss: {loss.item():.4f}") # while循环 - 训练循环 epoch = 0 while epoch < max_epochs: train_one_epoch() epoch += 1 ``` ## 4. 函数定义和使用 ### 基础函数 ```python def calculate_loss(predictions, targets, reduction='mean'): """ 计算损失函数 Args: predictions: 模型预测值 targets: 真实标签 reduction: 损失缩减方式 Returns: 计算得到的损失值 """ diff = predictions - targets if reduction == 'mean': return diff.mean() elif reduction == 'sum': return diff.sum() else: return diff # 函数调用 loss = calculate_loss(outputs, labels) ``` ### Lambda函数 ```python # 用于简单的转换操作 activation = lambda x: max(0, x) # ReLU激活函数 normalize = lambda x: (x - x.mean()) / x.std() # 标准化 ``` ## 5. 类与面向对象编程 ### 类定义 ```python class SimpleModel: def __init__(self, input_size, hidden_size, output_size): self.input_size = input_size self.hidden_size = hidden_size self.output_size = output_size self.weights = self._initialize_weights() def _initialize_weights(self): """初始化模型权重""" return { 'w1': np.random.randn(self.input_size, self.hidden_size), 'w2': np.random.randn(self.hidden_size, self.output_size) } def forward(self, x): """前向传播""" hidden = np.dot(x, self.weights['w1']) output = np.dot(hidden, self.weights['w2']) return output # 使用类 model = SimpleModel(784, 128, 10) ``` ## 6. 异常处理 ```python try: # 尝试加载模型 model.load_state_dict(torch.load('model.pth')) except FileNotFoundError: print("模型文件不存在，重新初始化模型") model = initialize_model() except Exception as e: print(f"加载模型时发生错误: {e}") raise ``` ## 7. 模块导入 ```python # 标准库导入 import os import json import time # 第三方库导入 - 小模型开发核心 import numpy as np import torch import torch.nn as nn from sklearn.metrics import accuracy_score # 别名导入 import pandas as pd import matplotlib.pyplot as plt ``` ## 8. 文件操作 ```python # 读取配置文件 with open('config.json', 'r') as f: config = json.load(f) # 保存训练结果 training_log = { 'epoch': 100, 'loss': 0.05, 'accuracy': 0.92 } with open('training_log.json', 'w') as f: json.dump(training_log, f, indent=2) ``` ## 9. 生成器和迭代器 ```python # 生成器 - 用于大数据集分批加载 def data_generator(dataset, batch_size=32): """数据生成器""" for i in range(0, len(dataset), batch_size): batch = dataset[i:i + batch_size] yield batch # 使用生成器 for batch in data_generator(training_data): process_batch(batch) ``` ## 10. 装饰器 ```python # 计时装饰器 - 用于性能监控 import time from functools import wraps def timer(func): @wraps(func) def wrapper(*args, **kwargs): start_time = time.time() result = func(*args, **kwargs) end_time = time.time() print(f"{func.__name__} 执行时间: {end_time - start_time:.4f}秒") return result return wrapper @timer def train_epoch(): # 训练逻辑 pass ``` ## 实际应用示例 以下是一个综合运用上述语法的小模型训练脚本示例： ```python import numpy as np import json from typing import Dict, List class TrainingPipeline: def __init__(self, config: Dict): self.config = config self.model = self._build_model() self.optimizer = self._setup_optimizer() self.loss_history = [] def _build_model(self): """构建模型""" # 简化的模型构建逻辑 return {"weights": np.random.randn(10, 5)} def _setup_optimizer(self): """设置优化器""" return {"lr": self.config.get("learning_rate", 0.001)} def train(self, data_loader): """训练循环""" for epoch in range(self.config["epochs"]): epoch_loss = 0 for batch in data_loader: loss = self._process_batch(batch) epoch_loss += loss avg_loss = epoch_loss / len(data_loader) self.loss_history.append(avg_loss) if epoch % 10 == 0: print(f"Epoch {epoch}, Loss: {avg_loss:.4f}") def _process_batch(self, batch): """处理单个批次""" # 简化的处理逻辑 return np.random.random() def save_checkpoint(self, filepath): """保存检查点""" checkpoint = { "model": self.model, "config": self.config, "loss_history": self.loss_history } with open(filepath, 'w') as f: json.dump(checkpoint, f) # 使用示例 if __name__ == "__main__": config = { "learning_rate": 0.01, "epochs": 100, "batch_size": 32 } pipeline = TrainingPipeline(config) # 假设data_loader已定义 # pipeline.train(data_loader) pipeline.save_checkpoint("model_checkpoint.json") ``` 这些基础语法构成了Python小模型开发的基石，熟练掌握它们对于高效开发小型语言模型至关重要[ref_2][ref_3]。在实际开发中，还需要结合具体的深度学习框架（如PyTorch或TensorFlow）来构建和训练模型。