调用大语言模型

注意 api key 不能放到 github 上，可以用环境变量传入。
macos 上本地模型有针对 apple m 芯片优化。

使用命令行

ollama 可以给予命令后使用
openai api 可以用curl调用

命令行调用 ollama

ollama run qwen2.5:3b "hello"

echo "hello" | ollama run qwen2.5:3b

命令使用 curl 也可以，这样方便切到 chatgpt

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer 你的OPENAI_API_KEY" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [{"role": "user", "content": "你好，介绍一下自己"}]
  }'

使用 OpenAI API

调用 ollama

from openai import OpenAI

# 初始化客户端
client = OpenAI(
    base_url="http://localhost:11434/v1", # 用的默认端口号
    api_key="ollama"  # API key 可以是任意值
)

# 调用模型
response = client.chat.completions.create(
    model="qwen2.5:3b",
    messages=[
        {"role": "system", "content": "你是一个有帮助的助手"},
        {"role": "user", "content": "请解释什么是大语言模型"}
    ]
)

print(response.choices[0].message.content)

调用 deepseek api

.env 文件

DEEPSEEK_API_KEY=...

#!pip3 install openai
import os
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()


client = OpenAI(
    api_key=os.environ['DEEPSEEK_API_KEY'],
    base_url="https://api.deepseek.com")

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Hello"},
    ],
    stream=False
)

print(response.choices[0].message.content)

简单扩展

多轮对话

多轮对话需要手动保持对话历史。

流式返回

调用工具

常用的工具，比如 联网搜索，计算器，维基百科。

• 计算器可以用 numexpr 或者 sympy （支持符号计算）

使用 OpenAI API

import openai
import json
import re
import os
from typing import Dict, Any
from dotenv import load_dotenv
load_dotenv()
# -------------------------- 配置部分 --------------------------
# 替换为你的 DeepSeek API Key
DEEPSEEK_API_KEY = os.environ['DEEPSEEK_API_KEY']
# DeepSeek API 基础地址
DEEPSEEK_BASE_URL = "https://api.deepseek.com/v1"
# 要使用的模型名称
MODEL_NAME = "deepseek-chat"

# -------------------------- 初始化客户端 --------------------------
client = openai.OpenAI(
    api_key=DEEPSEEK_API_KEY,
    base_url=DEEPSEEK_BASE_URL
)

# -------------------------- 工具定义 --------------------------
# 定义计算器工具
def calculator_tool(expression: str) -> str:
    try:
        if not re.match(r'^[\d\+\-\*\/\(\)\.\s]+$', expression):
            return f"无效的表达式：仅支持数字和 +-*/() 运算符，输入内容：{expression}"
        result = eval(expression, {"__builtins__": None}, {})
        return f"计算结果：{expression} = {result}"
    except Exception as e:
        return f"计算失败：{str(e)}，表达式：{expression}"

# 定义工具列表（可扩展更多工具）
tools = [
    {
        "type": "function",
        "function": {
            "name": "calculator_tool",
            "description": "用于执行数学计算的工具，支持加减乘除和括号运算",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "需要计算的数学表达式，例如 '100+200*3' 或 '(50-20)/5'"
                    }
                },
                "required": ["expression"],
                "additionalProperties": False
            }
        }
    }
]

# 工具映射：将工具名称映射到实际函数
tool_functions = {
    "calculator_tool": calculator_tool
}

# -------------------------- 核心对话函数 --------------------------
def chat_with_tools(user_message: str) -> str:
    """
    与 DeepSeek 模型对话，并自动调用工具
    :param user_message: 用户输入
    :return: 最终回复
    """
    # 1. 发送用户消息，请求模型判断是否需要调用工具
    response = client.chat.completions.create(
        model=MODEL_NAME,
        messages=[{"role": "user", "content": user_message}],
        tools=tools,
        tool_choice="auto",  # 让模型自动决定是否调用工具
        temperature=0.1      # 降低随机性，保证工具调用的准确性
    )

    assistant_message = response.choices[0].message
    final_response = ""

    # 2. 检查模型是否要求调用工具
    if assistant_message.tool_calls:
        # 收集工具调用结果
        tool_results = []
        
        # 遍历所有工具调用请求
        for tool_call in assistant_message.tool_calls:
            tool_name = tool_call.function.name
            tool_args = json.loads(tool_call.function.arguments)
            
            # 执行工具调用
            if tool_name in tool_functions:
                tool_result = tool_functions[tool_name](**tool_args)
                tool_results.append({
                    "tool_call_id": tool_call.id,
                    "role": "tool",
                    "name": tool_name,
                    "content": tool_result
                })
            else:
                tool_results.append({
                    "tool_call_id": tool_call.id,
                    "role": "tool",
                    "name": tool_name,
                    "content": f"未知工具：{tool_name}"
                })
        
        # 3. 将工具调用结果返回给模型，生成最终回复
        messages = [
            {"role": "user", "content": user_message},
            assistant_message,  # 模型的工具调用请求
            # 添加工具调用结果
            *[
                {
                    "role": "tool",
                    "tool_call_id": res["tool_call_id"],
                    "name": res["name"],
                    "content": res["content"]
                }
                for res in tool_results
            ]
        ]

        # 重新调用模型，结合工具结果生成回复
        final_response = client.chat.completions.create(
            model=MODEL_NAME,
            messages=messages,
            temperature=0.7
        ).choices[0].message.content
    else:
        # 不需要调用工具，直接返回模型回复
        final_response = assistant_message.content

    return final_response

# -------------------------- 测试示例 --------------------------
if __name__ == "__main__":
    # 测试用例1：需要调用计算器
    print("测试1（需要计算）：")
    user_input1 = "请帮我计算 (100 - 25) * 8 + 150 的结果"
    response1 = chat_with_tools(user_input1)
    print(f"用户：{user_input1}")
    print(f"模型：{response1}\n")

    # 测试用例2：不需要调用工具
    print("测试2（普通对话）：")
    user_input2 = "请介绍一下人工智能的发展历程"
    response2 = chat_with_tools(user_input2)
    print(f"用户：{user_input2}")
    print(f"模型：{response2}\n")

    # 测试用例3：复杂计算
    print("测试3（复杂计算）：")
    user_input3 = "我有500元，每天花15元，每周额外花50元，请问能坚持多少天？（计算到剩余金额不足一天花费为止）"
    response3 = chat_with_tools(user_input3)
    print(f"用户：{user_input3}")
    print(f"模型：{response3}")

LangChain

使用 langchain

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

# 加载环境变量
load_dotenv()

# 初始化模型
llm = ChatOpenAI(
    model="qwen2.5:3b",
    base_url="http://localhost:11434/v1",
    api_key=""
)

# 定义提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有帮助的助手"),
    ("user", "{input}")
])

# 构建链
chain = prompt | llm

# 测试
if __name__ == "__main__":
    # 测试普通对话
    response = chain.invoke({"input": "请介绍一下DeepSeek模型"})
    print(f"结果: {response.content}")

调用工具

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    model="gpt-5",
    temperature=0.1,
    max_tokens=1000,
    timeout=3
)
agent = create_agent(model, tools=tools)
result = agent.invoke( {"messages": [HumanMessage("Analyze the major themes in 'Pride and Prejudice'.")]} )

TODO：这个代码有问题 create_tool_calling_agent, create_react_agent

比如可以支持联网搜索。

from langchain_core.tools import tool  # 导入tool装饰器
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub
import sympy

# --------------------------
# 1. 使用@tool装饰器定义工具（注解方式）
# --------------------------
@tool 
def calculate_expression(expression: str) -> str:
    """
    高级计算工具，支持解析字符串形式的数学表达式（如"128*45"、"(5+8)*2"）
    Args:
        expression: 数学表达式字符串，支持加减乘除、括号、幂运算等
    Returns:
        计算结果的字符串描述
    """
    try:
        clean_expr = expression.replace("×", "*").replace("÷", "/").replace(" ", "")
        result = sympy.sympify(clean_expr)
        numeric_result = float(result.evalf())
        if numeric_result.is_integer():
            numeric_result = int(numeric_result)
        return f"表达式 '{expression}' 的计算结果是：{numeric_result}"
    except ZeroDivisionError:
        return f"错误：表达式 '{expression}' 中包含除以0的运算"
    except Exception as e:
        return f"计算出错：无法解析表达式 '{expression}'，错误信息：{str(e)}"

@tool 
def get_weather(city: str) -> str:
    """
    模拟获取天气的工具（实际场景可替换为真实API调用）
    Args:
        city: 城市名称
    Returns:
        该城市的模拟天气信息
    """
    weather_data = {
        "北京": "晴，温度 15-25℃，微风",
        "上海": "多云，温度 18-28℃，东风3级",
        "广州": "雷阵雨，温度 22-30℃，南风2级",
        "深圳": "阴，温度 23-29℃，北风1级"
    }
    return weather_data.get(city.strip(), f"暂无{city}的天气数据")

# --------------------------
# 2. 直接使用装饰后的函数作为tools列表
# --------------------------
# 装饰后的函数本质上是Tool对象，可直接放入列表
tools = [calculate_expression, get_weather]

# --------------------------
# 3. 后续逻辑与之前一致（省略重复部分）
# --------------------------
llm = ChatOpenAI(
    model="qwen2.5:3b",
    temperature=0.1,
    openai_api_base="http://localhost:11434/v1",
    openai_api_key="ollama",
    max_tokens=2048
)

prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm=llm, tools=tools, prompt=prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    handle_parsing_errors=True,
    max_iterations=5
)

# 测试调用
if __name__ == "__main__":
    print("===== 测试注解式Tool：天气查询 =====")
    result1 = agent_executor.invoke({"input": "请问北京今天的天气怎么样？"})
    print("最终回答：", result1["output"])

    print("\n===== 测试注解式Tool：复杂计算 =====")
    result2 = agent_executor.invoke({"input": "计算(80+20)*3-150/3的结果是多少？"})
    print("最终回答：", result2["output"])

微调 Qwen

能用提示词的就不要去微调。很多时候差异并不明显。通常 Prompt > RAG > 高效微调（如LoRA）> 全参数微调。

下面是在 Colab 上微调，不同环境可以需要改动代码。

构建微调数据集，问答对。
LoRA 低秩
量化需要 cuda
选一个较小的模型演示 “Qwen/Qwen2.5-0.5B-Instruct”
huggingface 有封装好的么？

TODO：这个代码有问题

依赖

pip3 install -q transformers peft accelerate datasets bitsandbytes trl sentencepiece protobuf
pip3 install -q torch torchvision torchaudio

代码

# ======================== 1. 环境准备 ========================
!pip install -U transformers accelerate peft trl datasets bitsandbytes torch sentencepiece

import torch
import warnings
warnings.filterwarnings("ignore")

# 检查 GPU
!nvidia-smi
print(f"GPU 可用: {torch.cuda.is_available()}")
print(f"GPU 名称: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else '无'}")

# ======================== 2. 加载模型与Tokenizer (4bit量化) ========================
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
    Trainer,
    DataCollatorForLanguageModeling
)
from peft import LoraConfig, get_peft_model, PeftModel
from datasets import Dataset
import numpy as np

# 4bit量化配置（核心：省显存，T4必开）
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

# 加载模型和Tokenizer
model_name = "Qwen/Qwen2.5-0.5B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(
    model_name,
    trust_remote_code=True,
    padding_side="right"  # 推理时避免警告
)
# Qwen系列需要手动设置pad_token
tokenizer.pad_token = tokenizer.eos_token
tokenizer.pad_token_id = tokenizer.eos_token_id
tokenizer.padding = "max_length"  # 强制padding到固定长度

# 加载量化后的模型
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
    torch_dtype=torch.bfloat16
)
# 训练时关闭缓存和并行配置
model.config.use_cache = False
model.config.pretraining_tp = 1

# ======================== 3. 准备微调数据 (修复padding/truncation) ========================
# 示例数据：Python编程助手指令集（可替换为任意符合格式的数据集）
train_data = [
    {
        "system": "你是一个专业的Python编程助手，简洁、准确地回答代码问题，只输出代码和必要注释。",
        "instruction": "写一个Python函数，计算列表中所有偶数的和。",
        "output": "def sum_even_numbers(lst):\n    \"\"\"计算列表中偶数的和\"\"\"\n    return sum(num for num in lst if num % 2 == 0)"
    },
    {
        "system": "你是一个专业的Python编程助手，简洁、准确地回答代码问题，只输出代码和必要注释。",
        "instruction": "用Python读取CSV文件并打印前5行。",
        "output": "import pandas as pd\n\ndef read_csv_sample(file_path):\n    \"\"\"读取CSV文件并打印前5行\"\"\"\n    df = pd.read_csv(file_path)\n    print(df.head())\n\n# 调用示例\n# read_csv_sample('data.csv')"
    },
    {
        "system": "你是一个专业的Python编程助手，简洁、准确地回答代码问题，只输出代码和必要注释。",
        "instruction": "写一个Python函数，判断一个数是否为质数。",
        "output": "def is_prime(n):\n    \"\"\"判断一个数是否为质数\"\"\"\n    if n <= 1:\n        return False\n    for i in range(2, int(n**0.5) + 1):\n        if n % i == 0:\n            return False\n    return True"
    },
    {
        "system": "你是一个专业的Python编程助手，简洁、准确地回答代码问题，只输出代码和必要注释。",
        "instruction": "用Python实现冒泡排序。",
        "output": "def bubble_sort(lst):\n    \"\"\"冒泡排序实现\"\"\"\n    arr = lst.copy()\n    n = len(arr)\n    for i in range(n):\n        for j in range(0, n-i-1):\n            if arr[j] > arr[j+1]:\n                arr[j], arr[j+1] = arr[j+1], arr[j]\n    return arr"
    },
    {
        "system": "你是一个专业的Python编程助手，简洁、准确地回答代码问题，只输出代码和必要注释。",
        "instruction": "Python如何遍历字典的键值对？",
        "output": "# 方法1：items()（推荐）\nmy_dict = {'a': 1, 'b': 2, 'c': 3}\nfor key, value in my_dict.items():\n    print(f\"键：{key}，值：{value}\")\n\n# 方法2：遍历键再取值\nfor key in my_dict:\n    print(f\"键：{key}，值：{my_dict[key]}\")"
    }
]

# 第一步：格式化数据为Qwen官方对话模板
def format_dataset(example):
    """将单条数据转为Qwen的chat模板格式"""
    messages = [
        {"role": "system", "content": example["system"]},
        {"role": "user", "content": example["instruction"]},
        {"role": "assistant", "content": example["output"]}
    ]
    example["text"] = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=False,
        padding=False
    )
    return example

# 第二步：手动Tokenize数据（🔥 核心修复：统一长度）
def tokenize_function(examples):
    """手动编码文本，强制统一长度"""
    # 🔥 关键修复：开启padding和truncation，统一到512长度
    tokenized = tokenizer(
        examples["text"],
        truncation=True,                # 截断超长文本
        max_length=512,                 # 固定最大长度
        padding="max_length",           # 不足补pad_token
        return_overflowing_tokens=False,
        return_tensors=None             # 返回list而非tensor，避免批次问题
    )
    # 语言模型训练需要labels（与input_ids一致）
    tokenized["labels"] = tokenized["input_ids"].copy()
    
    # 🔥 重要：将labels中pad_token的位置设为-100（训练时忽略）
    tokenized["labels"] = [
        [-100 if token == tokenizer.pad_token_id else token for token in label]
        for label in tokenized["labels"]
    ]
    
    return tokenized

# 构建Dataset并处理
dataset = Dataset.from_list(train_data)
dataset = dataset.map(format_dataset)  # 格式化文本
dataset = dataset.map(
    tokenize_function,
    batched=True,  # 批量处理更快
    remove_columns=dataset.column_names,  # 移除原始列
    desc="Tokenizing dataset"
)

# 转换为数组（避免list嵌套问题）
dataset.set_format(type="torch", columns=["input_ids", "attention_mask", "labels"])

# 查看处理后的数据样例
print("=== 处理后的数据样例 ===")
print(f"input_ids形状: {dataset[0]['input_ids'].shape}")
print(f"labels形状: {dataset[0]['labels'].shape}")
print(f"padding位置label值: {dataset[0]['labels'][-10:]}")  # 验证pad位置是否为-100

# ======================== 4. 配置LoRA (低秩适配) ========================
lora_config = LoraConfig(
    r=64,                    # 秩：0.5B模型推荐64，小数据集可降为32
    lora_alpha=16,           # 缩放因子，通常为r的1/4
    target_modules=["q_proj", "v_proj"],  # Qwen核心可训练层
    lora_dropout=0.05,       # dropout防止过拟合
    bias="none",             # 不训练bias参数
    task_type="CAUSAL_LM"    # 因果语言模型任务
)

# 包装模型为LoRA模型
model = get_peft_model(model, lora_config)
# 打印可训练参数占比（0.5B模型约0.1%，极省显存）
print("\n=== 可训练参数 ===")
model.print_trainable_parameters()

# 🔥 修复数据整理器：禁用自动padding（已手动处理）
data_collator = DataCollatorForLanguageModeling(
    tokenizer=tokenizer,
    mlm=False,  # 因果语言模型用False
    pad_to_multiple_of=None,  # 禁用自动padding
)

# ======================== 5. 配置训练参数并启动训练 ========================
training_args = TrainingArguments(
    output_dir="./qwen2.5-0.5b-finetune",  # 训练结果保存路径
    per_device_train_batch_size=2,         # 单卡batch size（T4最大4）
    gradient_accumulation_steps=4,         # 梯度累积，等效batch=8
    learning_rate=2e-4,                    # 学习率（LoRA常用2e-4）
    num_train_epochs=3,                    # 训练轮数（小数据3-5足够）
    logging_steps=1,                       # 每1步打印一次日志
    save_strategy="epoch",                 # 每轮保存一次模型
    fp16=True,                             # 混合精度训练（T4支持）
    optim="paged_adamw_8bit",              # 8bit优化器（省显存）
    report_to="none",                      # 关闭wandb日志
    gradient_checkpointing=True,           # 梯度检查点（进一步省显存）
    disable_tqdm=False,                    # 显示进度条
    # 🔥 新增：禁用自动发现长度
    auto_find_batch_size=False,
    dataloader_pin_memory=False,
)

# 初始化Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    data_collator=data_collator,  # 处理batch的padding
)

# 开始训练
print("\n=== 开始训练 ===")
trainer.train()

# 保存最终LoRA模型（仅几十MB）
trainer.model.save_pretrained("./qwen2.5-0.5b-lora-final")
tokenizer.save_pretrained("./qwen2.5-0.5b-lora-final")
print("\n=== 训练完成，模型已保存 ===")

# ======================== 6. 推理测试（加载微调后的模型） ========================
def generate_response(prompt):
    """
    生成回答函数
    :param prompt: 用户提问
    :param system_prompt: 系统提示词
    :return: 模型回答
    """
    # 构造对话模板
    messages = [
        {"role": "system", "content": "你是一个专业的Python编程助手，简洁、准确地回答代码问题。"},
        {"role": "user", "content": prompt}
    ]
    
    # 编码输入
    inputs = tokenizer.apply_chat_template(
        messages,
        tokenize=True,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to("cuda")
    
    # 生成回答
    outputs = model.generate(
        **inputs,
        max_new_tokens=256,    # 最大生成长度
        temperature=0.7,       # 随机性（0-1，越小越确定）
        top_p=0.9,             # 核采样
        do_sample=True,        # 采样生成
        num_return_sequences=1,
        pad_token_id=tokenizer.pad_token_id,
        eos_token_id=tokenizer.eos_token_id
    )
    
    # 解码并返回结果
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # 提取助手回答部分
    assistant_response = response.split("assistant\n")[-1].strip()
    return assistant_response

# 测试案例
print("\n=== 推理测试 ===")
test_prompts = [
    "写一个Python函数，计算列表中所有奇数的和。",
    "如何用Python实现快速排序？"
]

for prompt in test_prompts:
    print(f"\n用户提问：{prompt}")
    response = generate_response(prompt)
    print(f"模型回答：\n{response}")

 

提示词工程

提示词工程 https://www.promptingguide.ai/

平时能用提示词的就不要去微调。Prompt → RAG → 高效微调（如LoRA）→ 全参数微调

生成 SQL
使用工具

提示词工程

• 思维链 CoT 可以要求按步骤写出过程，也可以给一个思维链的示例,这样可以按照某种特定的方式引导。
• 示例 Example 给几个示例。

拆解任务
RAG
优化提示词的工具，通过在任务上评估。

Agent

记忆，通过总结来实现。记忆，压缩状态。

ReAct

协议
MCP Skill.md

调用工具 -, 调用自定义工具（天气、计算器、数据库、API…） -, 联网搜索实时信息 -, 自动判断什么时候用工具 -, 多轮工具调用

• 工具： - 文件读写 - 联网搜索 - Excel/CSV/JSON 解析与写入， - 天气 - 计算器 - 数据库 - 执行 Python 代码 -, 文件读写（txt/md）, Excel / CSV / JSON 全解析, 联网搜索, 文件夹遍历, 运行 Python 代码（安全沙盒）, 读取图片/OCR, 系统信息查询, 命令行多轮对话- 运行Python代码 - 数据库查询 - 文件夹遍历、 - 图片读取
• 可以实现以下任务： - 读取 Excel： 帮我读一下 data.xlsx 里面的内容 - 读取 CSV： 帮我分析 data.csv - 生成表格： 帮我创建一个学生名单.csv，包含姓名、年龄、班级 - 生成 JSON： 把用户信息保存到 user.json - 搜索 + 保存： 搜索2026手机销量，保存到 report.csv - 读取后总结： 帮我读 data.json 并总结 - 帮我列出当前文件夹所有文件 - 读一下 test.xlsx 并分析 - 把 2026 年手机销量数据存成 data.csv - 识别这张图片 img.png 的文字 - 写一段 Python 代码计算 1 到 100 的和 - 查我的电脑 CPU 占用 - 搜索 2026 年 AI 趋势并保存为 report.md - 读取 info.json 并帮我总结

加载 Skill.md

def load_skill_md(skill_path="Skill.md"):
"""加载并解析 Skill.md 技能手册"""
try:
with open(skill_path, "r", encoding="utf-8") as f:
content = f.read()

# 提取元数据与技能描述
meta_match = re.search(r'---\n(.*?)\n---', content, re.DOTALL)
meta = {}
if meta_match:
meta_lines = meta_match.group(1).splitlines()
for line in meta_lines:
if ":" in line:
k, v = line.split(":", 1)
meta[k.strip()] = v.strip()

skill_body = content.replace(meta_match.group(0), "") if meta_match else content
return f"""
【已加载技能：{meta.get('name', '默认技能')}】
描述：{meta.get('description', '无')}
---
{skill_body}
"""
except:
return "未加载 Skill.md 或文件不存在"

相关论文

ReAct（Reason + Act，2022，ICLR） 通过提示词实现，可以参考 langchain 中的实现。

DeepSeek

• DeepMath
• DeepSeek R1 使用合成数据
• DeepProver 使用

那该怎么学习数学呢？以我的经验来说，虽然我也不算擅长，而且经验可能有好有坏，毕竟应该还有更好的方法，但我还是想说说我的方法。首先要找一些问题，不用先想着有什么知识，把问题梳理一遍，对问题进行分解。然后看看解决步骤是怎样的，搞清楚每一步有什么特征。这时候不用急着做题，就是看答案给出的解题过程，而且要仔细看，看到每一步是针对哪个问题的特征进行操作的，而且这一步操作会用到什么假设。这里说的假设可以理解为某种知识，只是现在可能还不知道，就先把它当成假设。把每一步的问题特征和对应的假设找张纸写下来，这样看完一个问题的答案后，就能把涉及到的内容都记下来。之后再多看几道题，会发现有些问题有相似或重复的地方，它们所依据的前提和假设是一致的。

还有一个问题，就是很多人觉得数学里的东西都是名人说的，或者是被天才证明出来的。但是其实不是这样，数学里很多内容实际上都来自经验和直觉。就是从现实中观察到某种现象，当这种现象具有普遍性时，就变成了定理之类的。证明定理其实是在发现知识之间的关系，就像我们刚才分析问题找前提一样，也是看一个问题，再到更小的问题，这才是证明要做的。不能反过来理解，觉得知识是被证明出来的，证明其实是一个分析的过程，是从我们观察到的具有广泛性的事实中，寻找前提和适用条件。这样才能更好地运用它，这才是我们要去证明的原因。

把这些都写下来之后，就可以进行下一步了。之前都是看着答案写的，接下来就不看答案，看看刚才记录的东西能不能解决问题，能不能符合问题的要求。先不管怎么解决，就看刚才写下的问题特征，新问题下来后，是否符合这些特征。如果符合，刚才记录的对应解决方案能不能用上。如果很有用，就要重点注意这一点；如果有欠缺，就重新补充到记录里。记录的时候，还要把问题中分解出来的小问题化解成非常简单的问题，不要记那些很抽象的东西，要记具体的小问题以及对应的解决方法，把大问题分解成小问题记录下来。当然，只记重要的、有必要的，别什么都记，免得记成一堆琐碎的内容，要有所挑选。

以上就是我对数学学习的看法。之前写过一个帖子，感觉太抽象，所以这里想找更具体的例子来说明。其实这种方法不仅局限于数学，很多问题都可以通过分解来解决，从一个例子可以引申到其他例子。关键是不要急于抽象化，不要把问题想得太抽象，也不要认为一切可以直接用已有的知识去推导，这都是不对的。要假设在知识都不存在的情况下思考如何解决问题，核心还是学习经验，而不是局限于某些概念或内容，毕竟我们的目的是解决问题。

树的遍历

很多搜索问题可以转化为树，二叉树是最基本的情况。

# 二叉树节点定义
class TreeNode
  attr_accessor :val, :left, :right
  def initialize(val, left = nil, right = nil)
    @val = val
    @left = left
    @right = right
  end
end

# 二叉树的遍历（DFS）前序遍历（根 → 左 → 右）

# 递归版本
def preorder_recursive(root, res = [])
  return res if root.nil?
  res << root.val
  preorder_recursive(root.left, res)
  preorder_recursive(root.right, res)
  res
end

# 非递归（栈）版本
def preorder_iterative(root)
  return [] if root.nil?
  res = []
  stack = [root]
  while !stack.empty?
    node = stack.pop
    res << node.val
    # 先右后左入栈，保证出栈时左先遍历
    stack << node.right if node.right
    stack << node.left if node.left
  end
  res
end

# 测试二叉树遍历
root = TreeNode.new(1)
root.right = TreeNode.new(2)
root.right.left = TreeNode.new(3)

puts "前序递归: #{preorder_recursive(root)}"   # [1, 2, 3]
puts "前序非递归: #{preorder_iterative(root)}" # [1, 2, 3]

图的遍历

深度优先遍历

广度优先遍历

在树的基础上，有环。

# 图的遍历（DFS）

# 图的表示：邻接表（哈希，key 为节点，value 为相邻节点数组）
# 示例无向图
graph = {
  0 => [1, 2],
  1 => [0, 3, 4],
  2 => [0, 5],
  3 => [1],
  4 => [1, 5],
  5 => [2, 4]
}

# 递归 DFS
def dfs_recursive(graph, start, visited = Set.new, result = [])
  return result if start.nil?
  visited.add(start)
  result << start
  # 遍历邻居
  graph[start].each do |neighbor|
    unless visited.include?(neighbor)
      dfs_recursive(graph, neighbor, visited, result)
    end
  end
  result
end

# 非递归 DFS（栈实现）
def dfs_iterative(graph, start)
  return [] if start.nil?
  visited = Set.new
  stack = [start]
  result = []
  while !stack.empty?
    node = stack.pop
    next if visited.include?(node)
    visited.add(node)
    result << node
    # 逆序入栈，保证遍历顺序与递归一致（可选）
    graph[node].reverse_each do |neighbor|
      stack.push(neighbor) unless visited.include?(neighbor)
    end
  end
  result
end

# 图的广度优先遍历

# TODO

# 测试图遍历
require 'set'
puts "图递归 DFS: #{dfs_recursive(graph, 0)}"   # [0, 1, 3, 4, 5, 2]
puts "图非递归 DFS: #{dfs_iterative(graph, 0)}" # [0, 1, 3, 4, 5, 2]

线性规划

自行实现比较麻烦，建议调库。

前缀和后缀比较固定，改变单词原有的意思。词根则反映单词的意思。

词缀

affix

前缀 prefix

• 方向前缀： dis-=away 离开/分离, ex-=out 向外/出, in-=into 进入/向内, re-=back 向后/返回, sub-=under 在……之下/向下, com/con/col-=with/together 共同/一起, pro-=forward 向前/支持
• 数量前缀： uni-=one 单一, bi-=two 双/二, tri-=three 三, multi-=many 多, semi-=half 半
• 否定前缀： un-=not 不/非, in-=not 不/无，变体 il-/im-/ir- dis-=not 否定/相反, non-=not 非/不, anti-=against 反对/抗

后缀 suffix

• 名词后缀
  • 表人/职业, -er ……者/从事……的人, -or ……者/执行者, -ist ……主义者/专家, -ian ……领域的人, -ee 受动者/被……的人
  • 表物, -ment 具体事物/工具, -tion 事物/结果, -er 工具/物品
  • 表抽象概念/状态, -tion/-ation 动作/状态, -ment 行为/结果, -ness 性质/状态, -ity 性质/状态, -hood 状态/时期
• 动词后缀： -ize/-ise=make 使……化, -ate=make/do 使……/做……, -en=make 使……变得, -ify/-fy=make 使……具……性质
• 形容词后缀： -ful=full of 充满……的, -less=without 无……的, -able/-ible=able to 能……的, -ous/-ious=having 具……性质的, -y=characterized by 带……特征的, -ive=tending to 具……倾向的
• 副词后缀： -ly=way 以……方式, -ward/-wards=direction 朝……方向, -wise=manner/aspect 以……方式/方面

词根

这里详细列举一下，串记单词。

动作/器官相关

• man/manu=hand 手: manual 手册/手动的，manufacture 制造，manuscript 手稿，manipulate 操作
• ped=foot 脚: pedestrian 行人，pedal 踏板，centipede 蜈蚣，expedition 远征
• port=carry 搬运: transport 运输，import 进口，portable 便携的，support 支持
• struct=build 建造: construct 建造，structure 结构，destruction 破坏，instruction 指示
• act/ag=do/drive 做/驱动: action 行动，agent 代理人，react 反应，agenda 议程
• ced/ceed/cess=go 走: proceed 进行，succeed 成功，process 过程，access 进入
• stat=stand 站立: station 车站，status 地位，statue 雕像，statistics 统计学
• dict=say/speak 说: dictionary 字典，predict 预测，dictate 口述，contradict 反驳
• log/loqu=speak 说: dialogue 对话，apology 道歉，eloquent 雄辩的，logic 逻辑
• scrib/script=write 写: describe 描述，prescription 处方，manuscript 手稿，subscribe 订阅
• graph/gram=write/draw 写/画: photograph 照片，autograph 亲笔签名，telegram 电报，grammar 语法
• mot/mob=move 移动: motion 运动， promote 促进， mobile 移动的， automobile 汽车
• ject=throw 投掷: project 投射， reject 拒绝， inject 注射， eject 弹出
• vert/vers=turn 转: convert 转换， reverse 反转， advertise 广告， diverse 多样的
• tract=draw, pull 拉: attract 吸引， contract 合同， tractor 拖拉机， extract 提取
• pos/pon=put, place 放置: position 位置， postpone 推迟， compose 组成， expose 暴露
• claim/clam=shout, cry out 呼喊: exclaim 惊呼， proclaim 宣布， clamor 喧闹， acclaim 称赞

感知相关

• vis/vid=see 看：visible 可见的、vision 视力/视野、video 视频、evidence 证据、obvious、
• aud=hear 听：audio 音频、audience 观众/听众
• sci=know 知道：science 科学、conscious 有意识的、conscience 良心
• cogn=know 知道：recognize 认出、cognitive 认知的、cognition 认知
• sent/sens=feel 感觉: sensitive 敏感的， sentiment 情感， consensus 共识， nonsense 废话

自然相关

• bio=life 生命：biology 生物学、biography 传记
• geo=earth 大地：geography 地理学、geology 地质学、geometry 几何学
• aqua/hydr=water 水: aquarium 水族馆， aquatic 水生的， hydrate 补水， hydroelectric 水力发电的
• ign=fire 火: ignite 点燃， ignition 点火， igneous 火成的
• photo/luc=light 光: photograph 照片， photon 光子， lucid 清晰的， translucent 半透明的
• viv=live, life 活: vivid 生动的， survive 幸存， revive 复活， vital 至关重要的
• astr/aster=star 星星: astronaut 宇航员， astronomy 天文学， disaster 灾难（原意：星位不正）
• chron=time 时间: chronic 慢性的， chronology 年表， synchronize 同步
• phon=sound 声音: telephone 电话， symphony 交响乐， microphone 麦克风

学科/研究相关

• logy=study of ……学：biology 生物学、psychology 心理学、geology 地质学
• techno=art, skill 技术: technology 技术， technician 技师
• philia=love 爱: philosophy 哲学（爱智慧），

参考资料

• 《》

读音

音标

音标是用来记录发音的

• 元音字母有固定的发音，区分开音节（元音字母结尾，长，字母本身读音）、闭音节（元音字母后接辅音，短）、重读、弱读（/ə/），长短。
• 音节划分：按元音，前后有辅音，从后往前划分。重音，双音节词重音，名词在前'object ，动词在后ob'ject 。有些固定后缀在倒数第三个音节（如-tion）。

元音字母的发音

• a: 开音节 /eɪ/ cake, 闭音节 /æ/ cat, 在 ss/st/sk/th/f/n 前 /ɑː/ ask, 非重读音节 /ə/ about, .
• e: 开音节 /iː/ she, 闭音节 /e/ pen, 非重读音节, /ə/ open /ɪ/ begin.
• i: 开音节 /aɪ/ like, 闭音节 /ɪ/ , 特殊情况 /iː/ machine, 非重读音节 /ə/ possible, .
• o: 开音节 /əʊ/ /oʊ/ no, home, 闭音节 /ɒ/ /ɑː/ hot, dog, 在 m/n/v/th 前 /ʌ/ come, 在 st/ld 前 /uː/ most, cold, 非重读音节 /ə/ photo, .
• u: 开音节 /juː/ use, 闭音节 /ʌ/ bus ,在 l/r/j 后 /uː/ blue ,部分单词 /ʊ/ put, 非重读音节 /ə/ minute, autumn, difficult.
• 半元音 y: 词尾开音节 /aɪ/ my, 词中闭音节 /ɪ/ gym, 非重读音节词尾 /iː/ baby, 词首作辅音 /j/ yes,.

双元音，元音字母组合的发音

• ai/ay /eɪ/ rain, day,
• ea /iː/ eat, 闭音节 /e/ head, /eɪ/ great,
• ee /iː/ see,
• ei/ey /eɪ/ eight, they,
• er // version
• oo 长音 /uː/ moon, 短音 /ʊ/ book,
• ou, /aʊ/ out, /uː/ soup, /ʌ/ touch,

辅音字母的发音

• c： 清辅音 /k/在 a/o/u 前 cat /kæt/、cup /kʌp/，清辅音 /s/ 在 e/i/y 前 city /ˈsɪti/、nice /naɪs/
• g： 浊辅音 /ɡ/ 在 a/o/u 前 go /ɡəʊ/，浊辅音 /dʒ/ 在 e/i/y 前 age /eɪdʒ/
• j： 浊辅音 /dʒ/ jump
• y：浊辅音 /j/ yes
• s： 清辅音 /s/ 在词首或清辅音后 sun /sʌn/、desk /desk/，浊辅音/z/ 在元音后或词尾浊音后 rose /rəʊz/、has /hæz/，/ʃ/ 在 /ʃ//tʃ/ 前发 /ʃ/ sure /ʃʊə(r)/
• th: 清辅音 /θ/ think /θɪŋk/ ，浊辅音 /ð/ this /ðɪs/、
• ch: 浊辅音 /tʃ/ chair, 清辅音 /k/：school /skuːl/、清辅音 /ʃ/：machine /məˈʃiːn/
• sh：始终发 /ʃ/“she” 。

固定组合，前缀，后缀的发音

• -er 名词后缀，动词变名词（表 “人 / 工具”），形容词变比较级 /ə(r)/ teacher， 重读 /ɜː(r)/ her
• -tion：名词后缀 /ʃn/ action /ˈækʃn/、 重音通常在 -tion 前倒数第三个音节
• -sion：名词后缀 /ʒn/ 或 /ʒən/ 名词 decision /dɪˈsɪʒn/、television /ˈtelɪvɪʒn/
• -ment： /mənt/ 名词 development /dɪˈveləpmənt/、movement /ˈmuːvmənt/
• -ing： /ɪŋ/ 动名词 / 现在分词 running /ˈrʌnɪŋ/、thinking /ˈθɪŋkɪŋ/
• -ed： /t/（在清辅音后） 动词过去式 过去分词 worked /wɜːkt/、washed /wɒʃt/ ,， /d/（在浊辅音 / 元音后） played /pleɪd/、called /kɔːld/ ， /ɪd/（在t/d 后） wanted /ˈwɒntɪd/、needed /ˈniːdɪd/
• -en

音标

连读，按照短语，
辅音+元音连读，辅音+辅音，失去爆破。听力的时候格外要注意。

重音

断句

参考资料

• 《》
• 自然拼读

而事实上，只有现实中发生的现象才是真实存在的，那些所谓的“知识”并不是天然存在，它们只是人们脑海中形成的印记。思考本应从现实中的现象、从观察出发，而不是从一些默认存在、被假设存在的知识出发。

无论情况如何，我们都可以利用笔记来记录观察和整理思路。

1. 记笔记的时候，每一条都要是一个独立完整的句子，不要做成树形结构，不要依赖上下文。每条笔记单独一行，看上去都是针对特定问题的独立、完整的内容。可以作为思维的提纲，从中看到涉及的要点，或者作为实现特定的功能和目标的回应。

2. 可以用一张白纸，专门记录想法片段，这些片段不需要完整，只要是看到的内容、或是想到的内容就行，一定要是具体简单的内容，收集在一起。之后可以把这些片段合并到新的笔记里，或者根据新看到的内容来调整之前的笔记。

3. 有的时候，还需要记录做事的过程，一步一步把可复现的流程记下来。之后可以梳理这个流程，只记录流程里实际做过的部分，只保留必要的内容就可以。也可以去看别人记录的流程，用讨论的心态去看待这些流程性记录，这样就能从中获得启示。

总而言之，有很多方法可以帮助我们填补这个缺失的过程。

目前这里数学公式显示有点问题。

数学笔记1

本文假设已经知道微积分的内容，并着重复习一下数学分析的部分核心知识和方法。

数学分数通常作为微积分的后置课程，因为微积分的结论是符合现实的并具有使用价值，而数学分析是尝试对已有结论做形式化和公理化。

定义定理

极限

• 极限的定义: $\forall \varepsilon>0,\ \exists N\in\mathbb{N}^*,\ \text{s.t. } n>N \Rightarrow

  x_n - A

  <\varepsilon$。

• 常见的极限：$\lim_{n\to\infty} \frac{1}{n} = 0$。
• 极限的运算：lim a + lim b = lim (a+b)
• 三明治定理 Sandwich/Squeeze Theorem：若对充分大的 n，有xn​≤yn​≤zn​且limn→∞​xn​=limn→∞​zn​=L则limn→∞​yn​=L,例如 lim x→0​ x^2 sin(1/x)=0

实数

• 实数完备性：实数域关于极限运算封闭，即实数列的极限仍为实数。
• 确界存在定理：非空有上界数集必有上确界。
• 单调有界定理: 单调有界数列必收敛。
• 区间套定理：满足区间套条件的所有闭区间有唯一公共点，且左右端点都收敛于这个点。
• 聚点定理：实轴上任意有界无限点集至少有一个聚点。
• 有限覆盖定理：闭区间 $[a,b]$ 的任意开覆盖必有有限子覆盖。
• Bolzano–Weierstrass 定理：任何有界实数列必有收敛子列。
• 柯西收敛定理：柯西列 $\iff$ 收敛

连续（以及闭区间上连续函数的性质）

• 连续的定义: $\displaystyle\lim_{x\to x_0} f(x)=f(x_0) \iff \forall\varepsilon>0,\exists\delta>0,$ 当 $

  x-x_0

  <\delta$ 时，有 $

  f(x)-f(x_0)

  <\varepsilon$。

• 有界性定理 Boundedness Theorem：闭区间上的连续函数必有界。
• 最值定理 Extreme Value Theorem：闭区间上的连续函数必能取到最大值和最小值。
• 零点定理 Bolzano’s Theorem：若 $f\in C[a,b]$ 且 $f(a)f(b)<0$，则 $\exists\xi\in(a,b)$ 使得 $f(\xi)=0$。
• 介值定理 Intermediate Value Theorem：若 $f\in C[a,b]$，则 $f$ 可取到介于 $f(a)$ 与 $f(b)$ 之间的一切值。
• 一致连续：

微分

• 费马引理 Fermat’s Theorem：若 $f$ 在 $x_0$ 可导且在 $x_0$ 取极值，则 $f’(x_0)=0$。
• 罗尔定理 Rolle’s Theorem: 若 $f\in [a,b]$，在 $(a,b)$ 内可导，且 $f(a)=f(b)$，则 $\exists\xi\in(a,b)$ 使得 $f’(\xi)=0$。
• 拉格朗日中值定理 Lagrange Mean Value Theorem: 若 $f\in [a,b]$，在 $(a,b)$ 内可导，则 $\exists\xi\in(a,b)$ 使得
  $f(b)-f(a)=f’(\xi)(b-a)$。

积分

• 黎曼积分: $\displaystyle\int_a^b f(x)dx=\lim_{\lambda\to 0}\sum_{i=1}^n f(\xi_i)\Delta x_i$。

向量空间和拓扑中的极限

• 极限（向量空间），用范数（距离）定义接近。
  $\displaystyle\lim_{x\to x_0} f(x)=a \iff \forall\varepsilon>0,\ \exists\delta>0,\ 0<|x-x_0|<\delta\Rightarrow|f(x)-a|<\varepsilon$
• 极限（拓扑空间），只用开集定义接近，不需要距离。
  For every open set $U$ containing $x$, there exists $N$ such that $x_n\in U$ for all $n\ge N$.
  即 $x_n\to x \iff \forall\ \text{open } U\ni x,\ \exists N,\ n\ge N\Rightarrow x_n\in U$

说明

• 文字描述利用定义来翻译。定义出现在条件中时可以展开，出现在结论中时需要构造。
• 语言描述也可以转化为符号描述。

证明

这里选择一部分定理来证明。证明思路如下：

• 极限
  • 三明治定义 <- 极限定义
• 实数
  • 单调有界 <- 确界存在定理
  • 闭区间套 <- 单调有界
  • BW定理 <- 闭区间套 或者 单调有界
• 连续
  • 有界性 <- BW定理（反证法）
  • 最值定理 <- 有界性定理 + BW定理（反证法）
  • 零点定理 <- 闭区间套定理（或确界存在定理）
• 微分
  • 费马引理 <- 函数极限的保号性 + 导数定义
  • 罗尔定理 <- 最值定理 + 费马引理
  • 拉格朗日中值定理 <- 罗尔定理（构造辅助函数）
• 积分

注意定理是因为符合现实而正确，证明只是在寻找成立的条件。

极限

极限的定义

数列极限

• 若∀ε>0, ∃N∈N,n>N⟹∣xn​−a∣<ε则 n→∞lim​xn​=a。

函数极限（x→x₀）

• 设 f(x) 在 x0​ 某去心邻域有定义，若∀ε>0, ∃δ>0,0<∣x−x0​∣<δ⟹∣f(x)−A∣<ε 则 x→x0​lim​f(x)=A。

常见的极限

利用极限的定义，构造对应的表达式。先根据结果反推需要的取值，在书写证明。

证明：n→∞lim​n1​=0
要证：∀ε>0, ∃N, n>N⇒​n1​−0​<ε。
任给 ε>0。
要n1​<ε⟺n>ε1​
取N=⌈ε1​⌉
当 n>N 时，必有 n>ε1​，从而​n1​−0​=n1​<ε
故 n→∞lim​n1​=0。

证明：n→∞lim​n+1n​=1
估计：​n+1n​−1​=​n+1−1​​=n+11​<n1​
任给 ε>0。
要 n1​<ε⇒n>ε1​。
取 N=⌈ε1​⌉。
当 n>N，​n+1n​−1​<n1​<ε
故 n→∞lim​n+1n​=1。

证明：∣q∣<1 时 n→∞lim​qn=0
只证 0<q<1（负的可加绝对值）。令 q=1+a1​, a>0，则qn=(1+a)n1​<1+na1​<na1​
任给 ε>0。
要na1​<ε⟺n>aε1​
取 N=⌈aε1​⌉。
当 n>N，∣qn−0∣=qn<na1​<ε
故 n→∞lim​qn=0 (∣q∣<1)。

极限的运算

定理：若 x→x0​lim​f(x)=A，x→x0​lim​g(x)=B，则limx→x0​​[f(x)+g(x)]=A+B

证明：对任意 ε>0，
由 x→x0​lim​f(x)=A，存在 δ1​>0，当0<∣x−x0​∣<δ1​时，有∣f(x)−A∣<2ε​
由 x→x0​lim​g(x)=B，存在 δ2​>0，当0<∣x−x0​∣<δ2​时，有∣g(x)−B∣<2ε​
取 δ=min{δ1​,δ2​}，则当0<∣x−x0​∣<δ时，​[f(x)+g(x)]−(A+B)​=​[f(x)−A]+[g(x)−B]​≤∣f(x)−A∣+∣g(x)−B∣<2ε​+2ε​=ε
故limx→x0​​[f(x)+g(x)]=A+B

三明治定理（夹逼准则）

定理：若 $y_n\le x_n\le z_n$，且 $\lim y_n=\lim z_n=A$，则 $\lim x_n=A$。

证明
对任意 $\varepsilon>0$，当 $n$ 足够大时：
$A-\varepsilon < y_n,\quad z_n < A+\varepsilon$
于是
$A-\varepsilon < y_n\le x_n\le z_n < A+\varepsilon$
即 $|x_n-A|<\varepsilon$，故 $\lim x_n=A$。

实数

确界原理

通常作为公理使用。也可以从实数定义推导。

单调有界定理

定理

若数列 ${x_n}$ 满足：

1. 单调递增：$x_1 \le x_2 \le \dots \le x_n \le \cdots$
2. 有上界：$\exists M,\ \forall n,\ x_n \le M$
   则 ${x_n}$ 收敛，且 $\lim_{n\to\infty}x_n = \sup{x_n}$

证明

1. 由确界原理： 非空有上界数集必有上确界，记 $\xi = \sup{x_n}$
2. 由上确界定义： $\forall n,\ x_n \le \xi$ ； $\forall \varepsilon>0,\ \exists N,\ x_N > \xi - \varepsilon$

3. 因 ${x_n}$ 单调递增： 当 $n>N$ 时， $\xi - \varepsilon < x_N \le x_n \le \xi < \xi + \varepsilon$ 即 $

   x_n - \xi

   < \varepsilon$

4. 由极限定义： $\lim_{n\to\infty}x_n = \xi$

递减情形（一句话）
单调递减有下界 $\implies$ 必有下确界 $\eta = \inf{x_n}$，同理可证

$\lim_{n\to\infty}x_n = \eta$

闭区间套定理

满足区间套条件的所有闭区间有唯一公共点，且左右端点都收敛于这个点。

定理

设闭区间列 ${[a_n,b_n]}$ 满足：

1. 区间套条件：$[a_1,b_1] \supset [a_2,b_2] \supset \dots \supset [a_n,b_n] \supset \cdots$
   即： $a_1 \le a_2 \le \dots \le a_n \le \dots \le b_n \le \dots \le b_2 \le b_1$
2. 长度趋于 0：$\displaystyle\lim_{n\to\infty}(b_n-a_n)=0$
   则存在唯一的实数 $\xi$，使得$\xi \in \bigcap_{n=1}^{\infty} [a_n,b_n]$ 且 $\lim_{n\to\infty}a_n=\lim_{n\to\infty}b_n=\xi$

证明（用确界原理证明）

存在性

由区间套条件：

• 数列 ${a_n}$ 单调递增且有上界（任一 $b_n$ 都是上界）；
• 数列 ${b_n}$ 单调递减且有下界（任一 $a_n$ 都是下界）。

根据单调有界定理（由确界原理推出）： ${a_n}$ 收敛，记 $\displaystyle\lim_{n\to\infty}a_n = \xi$。

又 $\lim_{n\to\infty}b_n = \lim_{n\to\infty}\big[(b_n-a_n)+a_n\big] = 0 + \xi = \xi$

对任意 $n$： $a_n \le \xi \le b_n$ 故 $\xi \in \bigcap_{n=1}^{\infty}[a_n,b_n]$

唯一性

唯一性得证。

Bolzano–Weierstrass 定理

定理：有界数列必有收敛子列。

证明1（用区间套定理）：
设 ${x_n}\subset[a,b]$，不断二等分区间，每次选含无穷多项的一半，得闭区间套
\([a_1,b_1]\supset[a_2,b_2]\supset\cdots,\quad b_n-a_n\to0.\)
由区间套定理，$\exists\xi\in\bigcap[a_n,b_n]$，且 $\lim a_n=\lim b_n=\xi$。
在第 $k$ 个区间内取 $x_{n_k}$（下标严格递增），由夹逼准则：
\(\lim_{k\to\infty}x_{n_k}=\xi.\)
故 ${x_{n_k}}$ 是收敛子列。

证明2（用单调有界定理）：
称 $x_n$ 为巨项，若对所有 $m>n$ 有 $x_n\ge x_m$。

1. 若有无穷多巨项 $\Rightarrow$ 可取出单调递减子列；
2. 若只有有限个巨项 $\Rightarrow$ 从某项后可取出单调递增子列。

总之，任一数列必有单调子列。
又原数列有界，故此单调子列单调有界。
由单调有界定理，该子列必收敛。

连续

连续的定义

对任意 ε>0，存在 δ>0，当∣x−x0​∣<δ时，有∣f(x)−f(x0​)∣<ε 则称 f(x) 在点 x0​ 连续。

很多常见函数都是连续的，且运算之后也是连续的。这里证明略过。

连续函数在闭区间上的性质

有界性定理 Boundedness Theorem

定理：若 $f(x)$ 在 $[a,b]$ 连续，则 $f(x)$ 在 $[a,b]$ 有界。

证明（用BW定理，反证法）：
反证。假设 $f$ 无界，则 $\forall n,\ \exists x_n\in[a,b],\ |f(x_n)|>n$。
${x_n}$ 有界，由致密性定理，存在子列 $x_{n_k}\to x_0\in[a,b]$。
由连续性：$\lim\limits_{k\to\infty}f(x_{n_k})=f(x_0)$，
与 $|f(x_{n_k})|>n_k\to\infty$ 矛盾。
故 $f$ 在 $[a,b]$ 有界。

最值定理 Extreme Value Theorem

定理：若 $f(x)$ 在 $[a,b]$ 连续，则 $f$ 可取到最大值、最小值。

证明：
由有界性，设 $M=\sup\limits_{[a,b]}f(x)$。
则 $\forall n,\ \exists x_n\in[a,b],\ M-\dfrac1n<f(x_n)\le M$。
${x_n}$ 有子列 $x_{n_k}\to \xi_1\in[a,b]$。
由连续性：$\lim\limits_{k\to\infty}f(x_{n_k})=f(\xi_1)=M$。
即 $f(\xi_1)=\max f$。同理可证最小值。

介值定理 Intermediate Value Theorem

定理：$f\in C[a,b]$，$\mu$ 介于 $f(a),f(b)$ 之间，则 $\exists\xi\in(a,b),\ f(\xi)=\mu$。

证明（用闭区间套定理）：
令 $F(x)=f(x)-\mu$，不妨 $F(a)<0,F(b)>0$。
用二分法构造闭区间套 $[a_n,b_n]$，满足：
$F(a_n)<0,\ F(b_n)>0,\ b_n-a_n\to0.$
由闭区间套定理，$\exists\xi\in\bigcap[a_n,b_n]$，且 $a_n\to\xi,\ b_n\to\xi$。
由连续性：
$F(\xi)=\lim F(a_n)\le0,\quad F(\xi)=\lim F(b_n)\ge0 \Rightarrow F(\xi)=0\Rightarrow f(\xi)=\mu.$

零点存在定理 Bolzano’s Theorem

定理：$f\in C[a,b]$，$f(a)f(b)<0$，则 $\exists\xi\in(a,b),\ f(\xi)=0$。

证明（介值定理的特殊情况）：
在介值定理中取 $\mu=0$，
由 $f(a),f(b)$ 异号，$0$ 介于两者之间，
故 $\exists\xi\in(a,b)$，使 $f(\xi)=0$。

微分

导数的定义

费马引理 Fermat’s Theorem

条件 $f(x)$ 在 $x_0$ 处可导，且在 $x_0$ 取极值。 结论 $f’(x_0)=0$

证明（利用导数定义）

• 不妨设 $x_0$ 为极大值点，则 $\frac{f(x_0+\Delta x)-f(x_0)}{\Delta x} \begin{cases} \ge 0,\ \Delta x<0\ \le 0,\ \Delta x>0 \end{cases}$
• 取极限 $\Delta x\to0$：$f’(x_0)\ge 0,\quad f’(x_0)\le 0 \Rightarrow f’(x_0)=0$

罗尔定理 Rolle’s Theorem

条件

1. $f(x)$ 在 $[a,b]$ 连续
2. $f(x)$ 在 $(a,b)$ 可导
3. $f(a)=f(b)$

结论
$\exists\ \xi\in(a,b)$，使 $f’(\xi)=0$

证明（利用最值定理+费马引理）

• $f$ 在 $[a,b]$ 连续 ，由最值定理，有最大值 $M$、最小值 $m$。
• 若 $M=m$，则 $f$ 为常数，$f’\equiv0$，任取 ξ∈(a,b) 即可。
• 若 $M>m$，因 f(a)=f(b)，故 M 或 m 必在内部某点 ξ∈(a,b) 取得。
• 内部最值点必为极值点，由费马引理：$f’(\xi)=0$。

拉格朗日中值定理

条件

1. $f(x)$ 在 $[a,b]$ 连续
2. $f(x)$ 在 $(a,b)$ 可导

结论
$f(b)-f(a)=f’(\xi)(b-a)$

证明（利用罗尔定理）

• 构造辅助函数：$\varphi(x)=f(x)-f(a)-\frac{f(b)-f(a)}{b-a}(x-a)$
• 则$\varphi(a)=\varphi(b)=0$
• 由罗尔定理，$\exists\ \xi\in(a,b)$ 使 $\varphi’(\xi)=0$，即$f’(\xi)=\frac{f(b)-f(a)}{b-a}$

柯西中值定理

条件

1. $f,g$ 在 $[a,b]$ 连续
2. $f,g$ 在 $(a,b)$ 可导
3. $g’(x)\neq 0$

结论

$\frac{f(b)-f(a)}{g(b)-g(a)}=\frac{f’(\xi)}{g’(\xi)}$

证明

• 构造： $\varphi(x)=f(x)-f(a)-\frac{f(b)-f(a)}{g(b)-g(a)}\big(g(x)-g(a)\big)$
• 则 $\varphi(a)=\varphi(b)=0$
• 由罗尔定理，$\exists\ \xi$ 使 $\varphi’(\xi)=0$，整理即得。

附录

逻辑

量词、量词的否定、量词的嵌套。

• ∀ε>0, ∃δ>0, ∀x (0<∣x−a∣<δ⇒∣f(x)−A∣<ε)
• 不收敛，上面的否定命题是∃ε>0, ∀δ>0, ∃x (0<∣x−a∣<δ 且 ∣f(x)−A∣≥ε)，即找到这样的反例就不收敛。即存在一个正数 ε0​，无论你取多小的 δ>0，都至少存在一个点 ** x 满足：x 在 a 的 δ 邻域内，但 f(x) 离 A 仍然不小于 ε0​。

代数

向量（矢量）的定义：

• 既有大小，又有方向的量。
• 满足加法交换律、结合律、有零元、有负元，数乘满足四条分配与结合律、1 乘不变的集合元素，就是向量。通过运算来定义。
• 通过数组来定义。

统计

大数定律：样本量越大，样本均值依概率收敛到总体均值。

• 对任意 ε>0，limn→∞​P(∣Xˉn​−μ∣<ε)=1
• 强大数定律 ⇒ 弱大数定律

参考资料

• 《数学分析原理》（Principles of Mathematical Analysis， Rudin 著）
• 《》

快速排序

# 快速排序的 Ruby 实现

def quick_sort(arr, left = 0, right = arr.length - 1)
  return arr if left >= right
  
  pivot_index = partition(arr, left, right)
  quick_sort(arr, left, pivot_index - 1)
  quick_sort(arr, pivot_index + 1, right)
  
  arr
end

def partition(arr, left, right)
  # 选择最右边的元素作为基准
  pivot = arr[right]
  i = left - 1
  
  (left...right).each do |j|
    if arr[j] <= pivot
      i += 1
      arr[i], arr[j] = arr[j], arr[i]
    end
  end
  
  # 将基准放到正确位置
  arr[i + 1], arr[right] = arr[right], arr[i + 1]
  i + 1
end

二分查找

注意边界条件，很容易弄错。

# 二分查找的 Ruby 实现

def binary_search(arr, target)
  left = 0
  right = arr.length - 1
  
  while left <= right
    mid = left + (right - left) / 2  # 避免溢出
    
    if arr[mid] == target
      return mid  # 找到目标，返回索引
    elsif arr[mid] < target
      left = mid + 1  # 目标在右半部分
    else
      right = mid - 1  # 目标在左半部分
    end
  end
  
  -1  # 未找到
end

最小生成树

最短距离

数值算法

附录

参考资料

• Project Euler
• LeetCode

这里也是记录，把用来的东西记录下来。

基本用法

最基本的用法首先是输入文本，然后调整格式。

常见元素用法如下：

1. 文本样式有 粗体 \textbf{} 斜体 \textit{} 作为书名 [下划线]{.underline} \underline{} 引文 \verb|...|。
2. 注释行用 %
3. 段落用空行（两个换行）表示，一个换行会被吃掉。英文标点 ``引号''前后是不同符号 。这样，输入一些符号需要反斜杠\ 转义。
4. 数学公式环境，行内使用 $ $ 公式块使用 \[ \]，效果如 $f(x)=\sin(x)$。某些环境给公式带编号用然后引用。
5. 章节用 \section{} 以及 \subsection{}。会自动编号，用来生成对应的目录显示为 ` ` 或者 pdf 文附带件的大纲。
6. 列表 用 \begin{itemize} 编号列表（会自动按前后顺序编号）用 \begin{enumerate} ，其中的列表项目用 \item 。
7. 图片用 \includegraphics{}。论文中通常放在 \begin{figure} 位置跟随页面在顶端居中并包含标题 \caption{...}，不随跟随文本位置，然后通过交叉引用来指明。
8. 表格（含线） \begin{tabular}{|c|c|c|}\hline 用 & 和 \\ 分隔列和行。线条样式常用三线表。表格位置可以类似图片放在 \begin{table} 中跟随页面，并通过引用来使用。
9. 代码块 用 \begin{verbatim} 行内用 \verb||，如需伪代码或代码高亮可以用其他的包。通常位置类似图片。
10. 交叉引用 使用 \ref{label:1}（显示为数字编号），用来引用章节、图片（以及页码、公式）。在被引用对象后面添加 \label{label:1}。例如当前是在第 [label1]{reference-type=”ref” reference=”label1”} 节、第 页。
11. 参考文献用BibTeX 把文献列表放在 .bib 文件中，然后 \cite{...} 引用.需要文档最后放上 \bibliography{bib文件名}，并多编译几次，就不显示为问号了。这里显示为[@einstein]。通常习惯取名为作者+年份+短标题。注意 tex 和 latex 不一样。
12. 多文件项目用 \include{...} 作为段落 以及 \input{...} 用来嵌入文本。合理利用以加速编译。
13. 中文文档使用 \usepackage{ctex} 并用 XeLaTeX 编译（有时要加参数 -shell-escape），这样每段段首会空两格。如果仅需中文显示，只用 \usepackage{xeCJK}。

说明：

• 以下是在建好文档后基本的文本格式操作。对于某一些非视觉的文本的效果，可以直接编辑文本也可以用一些已有的指令自动创建。
• 对于论文中出现的非文本元素，如图表、表格和伪代码，以如下方式插入。这些元素可以出现在文本中，也通常浮动float在论文页面的固定位置。
• 相比以上直接输入内容和调整格式，以下的操作的会在格式上和编号上都有自动生成的内容。
• 首先是会自动编号的层次型结构。
• 然后是编号的前后引用。
• 为了在当前论文的不同位置或元素之间，以及相关文档之间建立链接，并由系统自动维护编号，可以使用交叉引用和参考文献功能。
• 编辑tex文件，直接使用任何常用的文本编辑器都是可以的。一些综合的原文件的例子，见这个文档的后面的内容。编译文档到PDF文件可以使用命令行，或者选择让IDE自动进行。
• 参考文献和交叉引用需要多次编译才能正确显示编号。

其他用法

• 浮动元素：图片、表格和伪代码通常放置为页面上元素，不随跟随文本位置，然后通过交叉引用来指明。
• 图片：图片宽度，图片分栏，
• 标题（包含作者、日期）、目录\tableofcontents
• 双栏文档
• 演示文稿 Beamer frame section
• 示意图 tikz 配合编辑器的预览功能使用
• 代码块用 verbatim 语法高亮用额外的包 listings
• 伪代码的格式效果可以使用 algorithm - 包提供的环境放置浮动位置，然后加上使用 algpseudocode 包提供的 - algorithmic 环境（用来代替之前的 algorithmic 包，并提供兼容用的 - algcompatible 包） 。或者使用 algorithm2e - 包书写伪代码。注意这是两种不同的书写格式，且一个文档里只使用一种包。
  • :::: algorithm
  • ::: algorithmic

	
% 参考文献。应放在\backmatter之前。
% 推荐使用BibTeX，若不使用BibTeX时注释掉下面一句。
%\nocite{*}
\bibliography{sample}


% 附录，必须放在参考文献后，backmatter前
\appendix
%\begin{lstlisting}[language=C]
%int main()
%{
%   return 0;
%}
%\end{lstlisting}

%\chapter{算法}
%
%\begin{algorithm}[htbp]
%  \caption{算法名字}
%  \label{alg:alg1}
%  \begin{algorithmic}[1]
%        \REQUIRE 这是输入
%        \ENSURE 这是输出
%        \WHILE {flag}
%             \STATE 这是语句
%        \ENDWHILE
%  \end{algorithmic}
%\end{algorithm}
%
%\chapter{实验验证}
%
%\begin{figure}[htbp]
%  \centering
%  \includegraphics[width=0.6\linewidth]{./figure/github.jpg}
%  \caption{单图示例}
%  \label{fig:system}
%\end{figure}
%
%实验硬件设备如图\ref{img:1}所示。
%\begin{figure}[htbp]
%\begin{minipage}[t]{0.5\textwidth}
%\centering
%\includegraphics[width=0.8\textwidth]{./figure/github.jpg}
%\caption{实验硬件设备总览}
%\label{img:1}
%\end{minipage}
%\begin{minipage}[t]{0.5\textwidth}
%\centering
%\includegraphics[width=0.8\textwidth]{./figure/github.jpg}
%\caption{实验测量示意图}
%\label{img:2}
%\end{minipage}
%\end{figure}
%
%图\ref{fig:sub}所示子图\ref{subfig:a}和子图\ref{subfig:b}。
%\begin{figure}[H]
%   \begin{subfigure}{.5\textwidth}
%       \centering
%       \includegraphics[width=0.8\textwidth]{./figure/github.jpg}
%       \caption{子图}
%       \label{subfig:a}
%   \end{subfigure}
%   \begin{subfigure}{.5\textwidth}
%       \centering
%       \includegraphics[width=0.8\textwidth]{./figure/github.jpg}
%       \caption{子图}
%       \label{subfig:b}
%   \end{subfigure}
%\caption{子图样例}
%\label{fig:sub}
%\end{figure}

%\section{章节}\label{subsec:mptcp_conges}

%\chapter{绪论}\label{chapter_introduction}
%\section{研究背景}
%使用.bib文件管理参考文献引用，引用示例：\cite{BHR12}.\par

新建文档

空白文档示例

\documentclass[10pt,letterpaper]{article}
\usepackage[utf8]{inputenc} % 文件编码，默认 utf-8
% \usepackage{ctex} % 中文版式

\title{LaTeX 的使用}
\author{...}
\date{...}
\begin{document}
\maketitle
% 正文在这里
\end{document}

浮动图表

页面浮动元素，可以是插图，表格，伪代码。

图片

\begin{figure}[hbt!]
\centering
\includegraphics[width=0.3\linewidth]{lion-logo.png}
\caption{This image will be referenced below}
\label{fig:lion}
\end{figure}
You can reference images, for instance, figure \ref{fig:lion} shows 
the logo of the red lion logo.

多图

表格

Table \ref{table:data} is an example of referenced \LaTeX{} elements.

\begin{table}[h!]
\centering
\begin{tabular}{||c c c c||} 
\hline
Col1 & Col2 & Col2 & Col3 \\ [0.5ex] 
\hline\hline
1 & 6 & 87837 & 787 \\ 
2 & 7 & 78 & 5415 \\
3 & 545 & 778 & 7507 \\
4 & 545 & 18744 & 7560 \\
5 & 88 & 788 & 6344 \\ [1ex] 
\hline
\end{tabular}
\caption{Table to test captions and labels}
\label{table:data}
\end{table}

流程图

伪代码

数学公式

1. 数学公式编号用 \begin{equation}
2. 多行对齐用 \begin{align}
3. 引用数学公式的自动编号用
4. 矩阵 $\begin{bmatrix}
   1 & 2 \
   3 & 4 \
   \end{bmatrix}$
5. 分段函数

定理
公式编号 用 label
微积分，泰勒级数
矩阵，
概率，大数定理
定理证明
定义

::: theorem
定理 1. Let $f$ be a function whose derivative exists in every
point, then $f$ is a continuous function.
:::

::: lemma
Lemma 2. Given two line segments whose lengths are $a$ and $b$
respectively there is a real number $r$ such that $b=ra$.
:::

To prove it by contradiction try and assume that the statement is false,
proceed from there and at some point you will arrive to a contradiction.

演示文稿

书籍排版

章节

目录

数据整理

使用 Excel 整理数据

Excel 是一个很直观和方便的数据展示和处理工具，有需要时也可以用 matlab 或 python 脚本。

表格的基本操作

1. csv文件导出。
2. 数据透视表用来对原始数据进行分类汇总，也用来长表转宽表。

可视化分析

线性回归

线性回归可以扩展到回归分析，进而到一些机器学习的方法，例如建立多分类模型

假设验证

规划求解

读取数据，可以从 csv 文件读取

导出表格，导出图片

可视化

线性回归

统计分析可以直接用公式或者在插件中开启专门的工具。

常用的如 pair t test 一组不同的实验对象，用两种待比较的方法得到每个实验对象在两种情况下的结果，可以用成对t检验判断方法造成的差异是否显著。

显著性水平双侧取 $\alpha=$ 单侧取 $\alpha=$，计算 $p<\alpha$

假设 $x_i-y_i \sim N$

单变量求解 即 单变量等式求根.

一个单元格表示需要求解的变量 $x$
，另一个是单元格的内容是引用这个变量的公式 $f(x)$ ，解方程 $f(x)=0$ 。

规划求解（需要在插件中开启）

每个变量占一个相邻的单元格，目标函数=公式的形式写在单元格了，然后在求解器对话框中执行是哪些单元格。
约束条件的表达式也以公式的形式写在单元格内，相邻单元格可以同时添加到求解器的对话框中。
常用有线性规划，整数线性规划，非线性规划。

对于常见线性规划线性目标和线性约束，标准型是小于等于约束。且能保证最快多项式时间找到全局最优解.

预测工作表功能用于多时间序列数据基于历史值对未来值进行预测。

交互

在 LibreOffice Calc（一个开源的 Excel 实现）上， 统计 Tools 菜单下 Goal Seek 和 Solver.

使用 MatLab 整理数据

也可以使用 Octave 或者 Python

读取数据

从文本中读取矩阵可以用 load
，此时以非数字作为分割符，注意每行元素个数相等.

画图

figure plot hold on title

x = -10*pi:0.1:10*pi
y1 = sin(x)
y2 = cos(x)
plot(x,y1)
plot(x,y2)

统计分析

load

[h,p] = ttest(x,y) 其中 x,y 是向量，返回 h=1 表示拒绝零假设。

默认双侧 alpha 取 0.05

处理图片

matlab可以通过矩阵的形式处理图像数据。

图像的读写与显示 imread、imshow、imsave

二值化，通过阈值或者其他的分割方法

特征提取，图片的特征，以及局部的特征。

科技论文写作

参考书 Writing scientific articles strategy and steps (Cargill, Margaret
O’Connor, Patrick)

结构

structures: AIMRaD (Abstract, Introduction, Materials and methods,
Results, and Discussion)

语言表达

词汇句子

附录

安装 latex 环境 windows 使用 texlive 或 MiKTeX ubuntu 使用 texlive
中文安装 texlive-chinese

编辑器 TeXStudio Lyx 提供了所见即所得的界面（比如编辑公式的时候） VSCode
有专门的插件（使用XeLaTeX要配置一下编译命令）

工具 字典/同义词 在线网址 自动缩进 latexindent.py? 拼写检查 languagetool
grammarly
有个 perl 写的自动编译工具

相关教程和书籍

overleaf 的帮助文档，提供的常用的用法。

相关工具

• 编译环境
• 编辑器
• 语法检查
• 教程手册
• https://www.codecogs.com/latex/eqneditor.php
• 注意一些包使用创建特定的效果的，只是为了带来方便，有时候也可以有不同的选择。