学习顺序说明：本文是AI学习路线的第1篇，建议按顺序学习：
- 01 入门基础（本文）→ 02 机器学习 → 03 深度学习 → 04 NLP基础 → 05 Transformer进阶 → 06 大模型应用 → 07 RAG系统 → 08 AI工具链
人工智能领域的学习需要建立扎实的数学和编程基础。本文将系统性地介绍入门AI所需的核心知识，帮助学习者从零开始构建AI知识体系。
编程基础(Python) → 数学基础 → 机器学习 → 深度学习 → 专项应用
Python是AI领域最主流的编程语言，掌握Python是学习AI的第一步。
变量与数据类型
# 基本数据类型
name = "AI学习者" # 字符串
age = 25 # 整数
score = 95.5 # 浮点数
is_active = True # 布尔值
# 类型转换
num_str = "123"
num_int = int(num_str) # 字符串转整数
控制结构
# 条件判断
score = 85
if score >= 90:
print("优秀")
elif score >= 60:
print("及格")
else:
print("不及格")
# 循环结构
for i in range(5):
print(f"第{i+1}次循环")
# while循环
count = 0
while count < 3:
print(count)
count += 1
函数定义
def calculate_area(radius):
"""计算圆的面积"""
import math
return math.pi * radius ** 2
# 带默认参数的函数
def greet(name, greeting="你好"):
return f"{greeting}, {name}!"
# Lambda表达式
square = lambda x: x ** 2
参考资源：Python官方教程 - Python官方文档是最权威的学习资源
class NeuralNetwork:
"""简单的神经网络类示例"""
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 = None
def initialize_weights(self):
"""初始化权重"""
import numpy as np
self.weights = np.random.randn(self.input_size, self.hidden_size)
return self.weights
def forward(self, x):
"""前向传播"""
if self.weights is None:
self.initialize_weights()
return np.dot(x, self.weights)
# 使用类
nn = NeuralNetwork(10, 5, 2)
# 列表 - 有序可变
numbers = [1, 2, 3, 4, 5]
numbers.append(6) # 添加元素
numbers.pop() # 移除最后一个
numbers[0] # 索引访问
# 元组 - 有序不可变
point = (3, 4)
x, y = point # 解包
# 字典 - 键值对
model_config = {
"learning_rate": 0.001,
"epochs": 100,
"batch_size": 32
}
# 集合 - 无序不重复
unique_numbers = {1, 2, 3, 2, 1} # 结果: {1, 2, 3}
NumPy是Python科学计算的基石，几乎所有AI框架都基于NumPy构建。
import numpy as np
# 创建数组
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2, 3], [4, 5, 6]])
# 数组运算
arr * 2 # 元素乘法
arr + arr # 元素加法
np.dot(arr, arr) # 点积
# 常用函数
np.mean(arr) # 平均值
np.std(arr) # 标准差
np.sum(arr) # 求和
np.max(arr) # 最大值
# 矩阵运算
A = np.random.randn(3, 4)
B = np.random.randn(4, 2)
C = np.dot(A, B) # 矩阵乘法 (3x4) @ (4x2) = (3x2)
# 广播机制
matrix = np.array([[1, 2, 3], [4, 5, 6]])
row = np.array([1, 0, 1])
result = matrix + row # 广播加法
参考资源：NumPy官方文档 - 详细了解数组操作和广播机制
Pandas是数据分析和预处理的利器。
import pandas as pd
# 创建DataFrame
data = {
"name": ["Alice", "Bob", "Charlie"],
"age": [25, 30, 35],
"score": [85.5, 90.0, 78.5]
}
df = pd.DataFrame(data)
# 数据查看
df.head() # 查看前几行
df.info() # 数据类型信息
df.describe() # 统计描述
# 数据选择
df["name"] # 选择列
df.loc[0] # 按标签选择
df.iloc[0:2] # 按位置选择
# 数据处理
df["age_group"] = df["age"].apply(lambda x: "青年" if x < 30 else "中年")
df.dropna() # 删除缺失值
df.fillna(0) # 填充缺失值
df.groupby("age_group").mean() # 分组聚合
参考资源：Pandas官方教程 - 10分钟入门Pandas
import matplotlib.pyplot as plt
import numpy as np
# 折线图
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.figure(figsize=(10, 6))
plt.plot(x, y, label='sin(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.title('正弦函数')
plt.legend()
plt.grid(True)
plt.show()
# 散点图
x = np.random.randn(100)
y = np.random.randn(100)
plt.scatter(x, y, alpha=0.5)
plt.show()
# 直方图
data = np.random.randn(1000)
plt.hist(data, bins=30, edgecolor='black')
plt.show()
参考资源：Matplotlib官方文档 - 完整的绑程和示例
线性代数是深度学习的数学基础，理解矩阵运算是理解神经网络的关键。
向量运算
import numpy as np
# 向量定义
v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])
# 向量加法
v_add = v1 + v2 # [5, 7, 9]
# 向量点积
dot_product = np.dot(v1, v2) # 1*4 + 2*5 + 3*6 = 32
# 向量范数（长度）
l2_norm = np.linalg.norm(v1) # sqrt(1+4+9) = sqrt(14)
# 向量夹角
cos_angle = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
矩阵运算
# 矩阵定义
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
# 矩阵乘法
C = np.dot(A, B) # 或 A @ B
# 矩阵转置
A_T = A.T
# 矩阵求逆
A_inv = np.linalg.inv(A)
# 特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(A)
# 行列式
det = np.linalg.det(A)
核心概念
| 概念 | 说明 | AI中的应用 |
|---|---|---|
| 向量 | 有方向的量 | 数据表示、词向量 |
| 矩阵 | 二维数组 | 权重矩阵、图像表示 |
| 点积 | 向量相似度 | 注意力机制 |
| 特征值 | 矩阵特性 | PCA降维 |
| 矩阵分解 | 分解矩阵 | 推荐系统 |
参考资源：3Blue1Brown线性代数系列 - 直观理解线性代数
导数与梯度
import numpy as np
# 数值导数
def numerical_derivative(f, x):
"""计算函数f在x处的数值导数"""
h = 1e-5 # 很小的增量
return (f(x + h) - f(x - h)) / (2 * h)
# 示例：计算 f(x) = x^2 在 x=3 处的导数
def f(x):
return x ** 2
derivative_at_3 = numerical_derivative(f, 3) # 约 6.0
# 梯度（多元函数的导数）
def numerical_gradient(f, x):
"""计算多元函数的梯度"""
h = 1e-5
grad = np.zeros_like(x)
for i in range(len(x)):
temp = x[i]
x[i] = temp + h
fxh1 = f(x)
x[i] = temp - h
fxh2 = f(x)
grad[i] = (fxh1 - fxh2) / (2 * h)
x[i] = temp
return grad
链式法则
链式法则是反向传播算法的数学基础：
# 复合函数 f(g(x)) 的导数 = f'(g(x)) * g'(x)
# 神经网络中的例子
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
s = sigmoid(x)
return s * (1 - s)
# 多层网络的梯度计算
x = np.array([1.0, 2.0])
w1 = np.array([[0.1, 0.2], [0.3, 0.4]])
w2 = np.array([[0.5], [0.6]])
# 前向传播
h = sigmoid(np.dot(x, w1)) # 隐藏层
y = sigmoid(np.dot(h, w2)) # 输出层
# 反向传播（链式法则）
# dL/dw2 = dL/dy * dy/dh2 * dh2/dw2
# dL/dw1 = dL/dy * dy/dh2 * dh2/dh * dh/dh1 * dh1/dw1
参考资源：3Blue1Brown微积分系列 - 直观理解微积分
基本概念
import numpy as np
from scipy import stats
# 概率分布
# 正态分布
mean, std = 0, 1
x = np.linspace(-5, 5, 100)
pdf = stats.norm.pdf(x, mean, std) # 概率密度函数
# 常用统计量
data = np.random.randn(1000)
print(f"均值: {np.mean(data)}")
print(f"方差: {np.var(data)}")
print(f"标准差: {np.std(data)}")
print(f"中位数: {np.median(data)}")
# 贝叶斯定理
# P(A|B) = P(B|A) * P(A) / P(B)
def bayes_theorem(p_b_given_a, p_a, p_b):
"""计算 P(A|B)"""
return (p_b_given_a * p_a) / p_b
# 示例：医疗诊断
# P(患病|检测阳性) = P(检测阳性|患病) * P(患病) / P(检测阳性)
p_disease = 0.01 # 患病概率
p_positive_given_disease = 0.95 # 患病时检测阳性的概率
p_positive = 0.05 # 检测阳性的总概率
p_disease_given_positive = bayes_theorem(
p_positive_given_disease, p_disease, p_positive
)
信息论基础
# 熵 - 不确定性度量
def entropy(p):
"""计算熵 H(p) = -Σ p(x) * log(p(x))"""
p = p[p > 0] # 避免 log(0)
return -np.sum(p * np.log2(p))
# 交叉熵 - 分类任务常用损失函数
def cross_entropy(p, q):
"""计算交叉熵 H(p, q) = -Σ p(x) * log(q(x))"""
q = np.clip(q, 1e-10, 1) # 避免 log(0)
return -np.sum(p * np.log(q))
# KL散度 - 分布差异度量
def kl_divergence(p, q):
"""KL散度 D_KL(p||q) = Σ p(x) * log(p(x)/q(x))"""
q = np.clip(q, 1e-10, 1)
p = np.clip(p, 1e-10, 1)
return np.sum(p * np.log(p / q))
参考资源：Khan Academy统计学 - 系统学习概率统计
| 模块 | 建议时间 | 学习重点 |
|---|---|---|
| Python基础 | 2-3周 | 语法、数据结构、面向对象 |
| NumPy/Pandas | 2周 | 数组操作、数据处理 |
| 线性代数 | 2-3周 | 向量、矩阵、特征值 |
| 微积分 | 2周 | 导数、梯度、链式法则 |
| 概率统计 | 2周 | 分布、贝叶斯、信息论 |
| 平台 | 课程 | 链接 |
|---|---|---|
| Coursera | Machine Learning - Andrew Ng | 课程链接 |
| fast.ai | Practical Deep Learning | 课程链接 |
| 吴恩达 | 深度学习专项课程 | 课程链接 |
最后更新: 2026年4月10日
本文参考了 learning-Journey-AI 项目和 DeepSeek技术社区 的学习路线整理
欢迎来到AI学习路线！本文档是该系列的总览，帮助你了解完整的学习路径和各文档内容。
_posts/ailearn/
├── 2026-04-10-00-index.md # 本文档（总览索引）
├── 2026-04-10-01-ai-foundation.md # 第1篇：入门基础
├── 2026-04-10-02-machine-learning.md # 第2篇：机器学习
├── 2026-04-10-03-deep-learning.md # 第3篇：深度学习
├── 2026-04-10-04-nlp-basics.md # 第4篇：NLP基础
├── 2026-04-10-05-transformer-advanced.md # 第5篇：Transformer进阶
├── 2026-04-10-06-llm-application.md # 第6篇：大模型应用
├── 2026-04-10-07-rag-system.md # 第7篇：RAG系统
├── 2026-04-10-08-ai-tools.md # 第8篇：AI工具链
├── 2026-04-10-09-computer-vision.md # 第9篇：计算机视觉
├── 2026-04-10-10-multimodal-llm.md # 第10篇：多模态大模型
├── 2026-04-10-11-ai-agent.md # 第11篇：AI Agent
├── 2026-04-10-12-ai-project.md # 第12篇：项目实战
└── 2026-04-10-13-vibe-coding.md # 第13篇：Vibe Coding
本系列共 13篇文档，从零基础到实战应用，系统学习人工智能核心技术：
┌─────────────────────────────────────────────────────────────────────────────┐
│ AI学习路线 (共13篇) │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 01 │ → │ 02 │ → │ 03 │ → │ 04 │ │
│ │ 入门基础 │ │ 机器学习 │ │ 深度学习 │ │ NLP基础 │ │
│ │ 数学+编程│ │ 算法原理 │ │ CNN/RNN │ │ 词向量 │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 05 │ → │ 06 │ → │ 07 │ → │ 08 │ │
│ │Transf.进阶│ │ 大模型 │ │ RAG │ │ AI工具链│ │
│ │ 注意力机制│ │ 微调技术 │ │ 知识库 │ │ 开发环境│ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 09 │ → │ 10 │ → │ 11 │ → │ 12 │ │
│ │ 计算机视觉│ │ 多模态 │ │AI Agent │ │ 项目实战 │ │
│ │ 目标检测 │ │ 图文融合 │ │ 智能体 │ │ 完整应用 │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ │
│ ┌─────────┐ │
│ │ 13 │ │
│ │Vibe Coding│ │
│ │ AI辅助编程│ │
│ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
| 序号 | 文件 | 主题 | 核心内容 | 预计时间 |
|---|---|---|---|---|
| 01 | ai-foundation.md | 入门基础 | Python、NumPy/Pandas、线性代数、微积分 | 6-8周 |
| 02 | machine-learning.md | 机器学习 | 线性回归、决策树、随机森林、SVM、聚类、PCA | 4-6周 |
| 03 | deep-learning.md | 深度学习 | MLP、CNN、RNN/LSTM/GRU、PyTorch实战 | 6-8周 |
| 04 | nlp-basics.md | NLP基础 | 词向量、注意力机制、BERT、GPT、Hugging Face | 4-6周 |
| 05 | transformer-advanced.md | Transformer进阶 | 多头注意力、位置编码(RoPE)、完整实现 | 3-4周 |
| 06 | llm-application.md | 大模型应用 | Prompt工程、LoRA微调、量化推理、vLLM | 4-6周 |
| 07 | rag-system.md | RAG系统 | 向量数据库、LangChain、混合检索、重排序 | 4-5周 |
| 08 | ai-tools.md | AI工具链 | Conda/Docker、Git、Jupyter/Colab、MLflow | 1-2周 |
| 09 | computer-vision.md | 计算机视觉 | OpenCV、图像分类、YOLO、图像分割 | 4-6周 |
| 10 | multimodal-llm.md | 多模态大模型 | CLIP、LLaVA、Stable Diffusion、图文融合 | 3-4周 |
| 11 | ai-agent.md | AI Agent | Function Calling、ReAct、记忆系统、多Agent | 3-4周 |
| 12 | ai-project.md | 项目实战 | FastAPI、RAG服务、Vue前端、Docker部署 | 2-3周 |
| 13 | vibe-coding.md | Vibe Coding | Cursor、Copilot、AI编程最佳实践 | 1-2周 |
适合人群：零基础入门者
主要内容：
学习目标：建立扎实的数学与编程基础，能够进行数据处理和科学计算
前置要求：无
适合人群：有编程基础，想了解机器学习原理
主要内容：
学习目标：理解常用机器学习算法原理，能够使用scikit-learn解决实际问题
前置要求：完成01入门基础
适合人群：有机器学习基础，想深入学习神经网络
主要内容：
学习目标：理解深度学习核心架构，能够用PyTorch搭建和训练模型
前置要求：完成02机器学习基础
适合人群：有深度学习基础，想学习自然语言处理
主要内容：
学习目标：理解NLP核心技术，能够使用预训练模型完成NLP任务
前置要求：完成03深度学习基础
适合人群：有NLP基础，想深入理解Transformer架构
主要内容：
学习目标：深入理解Transformer每个组件的设计原理，能够自己实现Transformer
前置要求：完成04 NLP基础
适合人群：想应用大语言模型解决实际问题
主要内容：
学习目标：掌握大模型应用开发，能够进行Prompt设计和模型微调
前置要求：完成05 Transformer进阶
适合人群：想构建能够利用外部知识的AI应用
主要内容：
学习目标：能够构建完整的RAG应用，实现知识库问答系统
前置要求：完成06大模型应用
适合人群：所有AI学习者
主要内容：
学习目标：掌握AI开发必备工具，建立高效的开发工作流
前置要求：可随时学习，贯穿整个学习过程
适合人群：对图像处理和视觉AI感兴趣
主要内容：
学习目标：掌握计算机视觉核心技术，能够开发视觉AI应用
前置要求：完成03深度学习基础
适合人群：想了解前沿多模态技术
主要内容：
学习目标：掌握多模态模型技术，能够开发图文融合应用
前置要求：完成04 NLP基础、09计算机视觉
适合人群：想构建自主AI系统
主要内容：
学习目标：掌握Agent技术，能够构建自主决策的AI系统
前置要求：完成06大模型应用
适合人群：完成前11篇学习的同学
主要内容：
学习目标：综合运用所学知识，构建完整的AI应用
前置要求：完成前11篇学习
适合人群：所有开发者，想提升编程效率
主要内容：
学习目标：掌握AI辅助编程技术，显著提升开发效率
前置要求：有编程基础即可
| 你的基础 | 建议起点 | 理由 |
|---|---|---|
| 零基础 | 01 入门基础 | 打好数学和编程基础 |
| 有编程基础 | 02 机器学习 | 跳过基础，直接学算法 |
| 有ML基础 | 03 深度学习 | 进入神经网络领域 |
| 想快速应用 | 06 大模型应用 | 快速上手大模型 |
| 目标角色 | 推荐路径 | 重点文档 |
|---|---|---|
| AI入门者 | 01 → 02 → 03 | 基础知识要扎实 |
| NLP工程师 | 01 → 02 → 03 → 04 → 05 | 专注NLP技术栈 |
| LLM应用开发者 | 04 → 05 → 06 → 07 | 大模型应用能力 |
| CV工程师 | 01 → 02 → 03 → 09 | 专注计算机视觉 |
| Agent开发者 | 04 → 05 → 06 → 11 | 智能体开发能力 |
| AI全栈工程师 | 全部13篇 | 全面掌握 |
基础阶段 (01-02): 10-14周
深度学习 (03-04): 10-14周
大模型应用 (05-07): 11-15周
工具实践 (08): 持续使用
前沿方向 (09-11): 10-14周
项目实战 (12): 2-3周
总计: 约43-60周 (10-14个月)
本系列文档参考了以下权威资源：
本系列文档遵循以下规范：
YYYY-MM-DD-序号-主题.md祝你学习顺利！
最后更新: 2026年4月10日
SQLAlchemy 是 Python 中最流行的 ORM 框架之一，提供了完整的 SQL 能力和企业级持久化模式。Alembic 是 SQLAlchemy 作者开发的数据库迁移工具，轻量级且功能强大，类似于 Django 的 migration 或 Ruby on Rails 的 migrations。
pip install sqlalchemy
# 或安装带异步支持的版本
pip install sqlalchemy[asyncio]
from sqlalchemy import create_engine
# SQLite
engine = create_engine('sqlite:///example.db')
# MySQL
engine = create_engine('mysql+pymysql://user:password@localhost:3306/dbname')
# PostgreSQL
engine = create_engine('postgresql://user:password@localhost:5432/dbname')
# 连接池配置
engine = create_engine(
'mysql+pymysql://user:password@localhost:3306/dbname',
pool_size=10, # 连接池大小
max_overflow=5, # 超过pool_size后允许的最大连接数
pool_timeout=30, # 获取连接超时时间
pool_recycle=3600, # 连接回收时间
echo=True # 打印SQL日志
)
from sqlalchemy import Column, Integer, String, DateTime, Text, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from datetime import datetime
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(50), unique=True, nullable=False, comment='用户名')
email = Column(String(100), unique=True, nullable=False, comment='邮箱')
password_hash = Column(String(255), nullable=False)
created_at = Column(DateTime, default=datetime.now, comment='创建时间')
updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now, comment='更新时间')
# 关联关系
posts = relationship('Post', back_populates='author')
def __repr__(self):
return f"<User(id={self.id}, username='{self.username}')>"
class Post(Base):
__tablename__ = 'posts'
id = Column(Integer, primary_key=True)
title = Column(String(200), nullable=False)
content = Column(Text)
user_id = Column(Integer, ForeignKey('users.id'), nullable=False)
created_at = Column(DateTime, default=datetime.now)
# 关联关系
author = relationship('User', back_populates='posts')
from sqlalchemy.orm import sessionmaker, Session
# 创建Session工厂
SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
# 使用上下文管理器
from contextlib import contextmanager
@contextmanager
def get_db():
db = SessionLocal()
try:
yield db
db.commit()
except Exception as e:
db.rollback()
raise e
finally:
db.close()
# CRUD 操作示例
def create_user(db: Session, username: str, email: str, password: str):
user = User(username=username, email=email, password_hash=password)
db.add(user)
db.commit()
db.refresh(user)
return user
def get_user_by_id(db: Session, user_id: int):
return db.query(User).filter(User.id == user_id).first()
def get_users(db: Session, skip: int = 0, limit: int = 100):
return db.query(User).offset(skip).limit(limit).all()
def update_user(db: Session, user_id: int, **kwargs):
user = db.query(User).filter(User.id == user_id).first()
if user:
for key, value in kwargs.items():
setattr(user, key, value)
db.commit()
db.refresh(user)
return user
def delete_user(db: Session, user_id: int):
user = db.query(User).filter(User.id == user_id).first()
if user:
db.delete(user)
db.commit()
return user
from sqlalchemy import or_, and_, func, desc
# 条件查询
users = db.query(User).filter(User.username.like('%test%')).all()
# 多条件组合
users = db.query(User).filter(
and_(
User.username.like('%test%'),
or_(User.email.endswith('@gmail.com'), User.email.endswith('@qq.com'))
)
).all()
# 排序和分页
users = db.query(User).order_by(desc(User.created_at)).offset(10).limit(10).all()
# 聚合查询
from sqlalchemy import func
result = db.query(
User.username,
func.count(Post.id).label('post_count')
).join(Post).group_by(User.id).all()
# 关联查询（JOIN）
posts = db.query(Post).join(User).filter(User.username == 'admin').all()
# 使用 outerjoin
posts = db.query(Post).outerjoin(User).all()
# 子查询
subq = db.query(Post.user_id, func.count('*').label('count')).group_by(Post.user_id).subquery()
result = db.query(User, subq.c.count).outerjoin(subq, User.id == subq.c.user_id).all()
pip install alembic
# 在项目根目录初始化
cd your_project
alembic init alembic
初始化后会生成以下结构：
your_project/
├── alembic/
│ ├── versions/ # 迁移脚本存放目录
│ ├── env.py # Alembic 环境配置
│ ├── script.py.mako # 迁移脚本模板
│ └── README
├── alembic.ini # Alembic 配置文件
└── your_models.py
修改 alembic.ini 文件中的数据库连接：
# alembic.ini
[alembic]
# 迁移脚本存放目录
script_location = alembic
# 数据库连接字符串
sqlalchemy.url = mysql+pymysql://user:password@localhost:3306/dbname
# 也可以使用环境变量
# sqlalchemy.url = driver://user:pass@localhost/dbname
[post_write_hooks]
# 迁移脚本生成后执行的钩子（如格式化代码）
# hooks = black
# black.type = console_scripts
# black.entrypoint = black
# black.options = -q
修改 alembic/env.py，导入你的模型：
# alembic/env.py
from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool
from alembic import context
# 导入你的 Base 和模型
import sys
sys.path.insert(0, '.')
from models import Base # 替换为你的模型路径
# this is the Alembic Config object
config = context.config
# 设置 target_metadata 为你的 Base.metadata
target_metadata = Base.metadata
# 其他配置保持不变...
# 生成迁移脚本（自动检测模型变化）
alembic revision --autogenerate -m "initial tables"
# 手动创建空白迁移脚本
alembic revision -m "add user table"
# 查看当前数据库版本
alembic current
# 查看迁移历史
alembic history
# 升级到最新版本
alembic upgrade head
# 升级到指定版本
alembic upgrade <revision_id>
# 降级一个版本
alembic downgrade -1
# 降级到指定版本
alembic downgrade <revision_id>
# 降级到初始状态
alembic downgrade base
# 查看将要执行的SQL（不实际执行）
alembic upgrade head --sql
# 标记当前版本（不执行迁移）
alembic stamp head
自动生成的迁移脚本示例：
# alembic/versions/123456789abc_initial_tables.py
"""initial tables
Revision ID: 123456789abc
Revises:
Create Date: 2024-01-01 10:00:00.000000
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '123456789abc'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# 创建 users 表
op.create_table(
'users',
sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
sa.Column('username', sa.String(length=50), nullable=False),
sa.Column('email', sa.String(length=100), nullable=False),
sa.Column('password_hash', sa.String(length=255), nullable=False),
sa.Column('created_at', sa.DateTime(), nullable=True),
sa.Column('updated_at', sa.DateTime(), nullable=True),
sa.PrimaryKeyConstraint('id'),
sa.UniqueConstraint('username'),
sa.UniqueConstraint('email')
)
# 创建索引
op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
def downgrade():
# 删除索引
op.drop_index(op.f('ix_users_username'), table_name='users')
# 删除表
op.drop_table('users')
# 添加列
def upgrade():
op.add_column('users', sa.Column('phone', sa.String(20), nullable=True))
def downgrade():
op.drop_column('users', 'phone')
# 删除列
def upgrade():
op.drop_column('users', 'phone')
# 修改列
def upgrade():
op.alter_column('users', 'username',
existing_type=sa.String(50),
type_=sa.String(100),
existing_nullable=False
)
# 添加外键
def upgrade():
op.create_foreign_key(
'fk_posts_user_id',
'posts', 'users',
['user_id'], ['id']
)
def downgrade():
op.drop_constraint('fk_posts_user_id', 'posts', type_='foreignkey')
# 执行原生SQL
def upgrade():
op.execute("UPDATE users SET status = 'active' WHERE status IS NULL")
# 批量操作（适合SQLite等不支持某些操作的数据库）
def upgrade():
with op.batch_alter_table('users') as batch_op:
batch_op.add_column(sa.Column('phone', sa.String(20)))
batch_op.alter_column('username', type_=sa.String(100))
project/
├── app/
│ ├── __init__.py
│ ├── database.py # 数据库连接和Session
│ ├── models/ # 模型定义
│ │ ├── __init__.py
│ │ ├── base.py # Base定义
│ │ ├── user.py
│ │ └── post.py
│ └── schemas/ # Pydantic 模型
├── alembic/
│ ├── versions/
│ ├── env.py
│ └── ...
├── alembic.ini
└── main.py
# database.py
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
from sqlalchemy.orm import declarative_base
DATABASE_URL = "mysql+aiomysql://user:password@localhost/dbname"
engine = create_async_engine(DATABASE_URL, echo=True)
AsyncSessionLocal = async_sessionmaker(
engine, class_=AsyncSession, expire_on_commit=False
)
Base = declarative_base()
# 异步操作示例
async def get_users_async():
async with AsyncSessionLocal() as session:
result = await session.execute(select(User))
return result.scalars().all()
server_default 避免锁表# 安全添加非空列（大数据表）
def upgrade():
op.add_column('users', sa.Column('status', sa.String(20), server_default='active'))
# 后续再分批更新后移除默认值
当多人开发时可能出现版本冲突：
# 合并多个头版本
alembic merge -m "merge branches" head1 head2
确保 env.py 中正确导入所有模型：
# 方式1：显式导入每个模型
from models import Base, User, Post
# 方式2：在 Base 导入后，导入所有模型模块
from models.base import Base
import models.user # noqa
import models.post # noqa
SQLite 默认不启用外键约束，需要在 env.py 中配置：
def run_migrations_online():
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix='sqlalchemy.',
poolclass=pool.NullPool
)
with connectable.connect() as connection:
# 启用外键约束（SQLite）
connection.execute(sa.text('PRAGMA foreign_keys=ON'))
context.configure(
connection=connection,
target_metadata=target_metadata
)
with context.begin_transaction():
context.run_migrations()
bi看板, Superset 4.0.2版本
本指南提供了一个系统性的AI大模型学习路径，从基础概念到高级应用，帮助学习者循序渐进地掌握大语言模型相关技术。
学习目标: 建立对AI和机器学习的基本认知
学习内容:
推荐资源:
时间安排: 2-3周 难度: 初级
学习目标: 掌握AI开发必需的编程技能
学习内容:
推荐资源:
时间安排: 3-4周 难度: 初级
学习目标: 巩固AI所需的数学基础
学习内容:
推荐资源:
时间安排: 2-3周 难度: 中级
学习目标: 理解神经网络和深度学习原理
学习内容:
推荐资源:
时间安排: 4-5周 难度: 中高级
学习目标: 掌握NLP核心概念和传统方法
学习内容:
推荐资源:
时间安排: 3-4周 难度: 中高级
学习目标: 深入理解Transformer模型架构
学习内容:
推荐资源:
时间安排: 3-4周 难度: 高级
学习目标: 学会使用现有的预训练大模型
学习内容:
推荐资源:
实践项目:
时间安排: 4-5周 难度: 中高级
学习目标: 掌握针对特定任务的模型微调方法
学习内容:
推荐资源:
实践项目:
时间安排: 5-6周 难度: 高级
学习目标: 了解大模型训练的基本流程和技术
学习内容:
推荐资源:
实践项目:
时间安排: 6-8周 难度: 高级
学习目标: 深入研究最新的模型架构和优化技术
学习内容:
推荐资源:
时间安排: 持续学习 难度: 专家级
学习目标: 掌握RLHF等高级训练技术
学习内容:
推荐资源:
时间安排: 持续学习 难度: 专家级
学习目标: 构建完整的AI应用系统
学习内容:
推荐资源:
实践项目:
时间安排: 持续学习 难度: 专家级
| 学习阶段 | 精力投入 | 时间分配 | 主要挑战 | 学习重点 |
|---|---|---|---|---|
| 基础入门 | ⭐⭐ | 1-2个月 | 概念理解 | 建立基础认知 |
| 核心理论 | ⭐⭐⭐⭐ | 2-3个月 | 数学原理 | 深入理解机制 |
| 实践应用 | ⭐⭐⭐⭐⭐ | 3-4个月 | 工程实现 | 动手能力培养 |
| 高级进阶 | ⭐⭐⭐⭐⭐ | 持续学习 | 前沿跟踪 | 创新和优化 |
高投入收益点 (⭐⭐⭐⭐⭐):
中等投入点 (⭐⭐⭐):
基础投入点 (⭐⭐):
最后更新: 2025年12月12日
本学习指南会根据AI技术发展持续更新，建议定期查看最新版本。
11434。ollama --version
ollama list
ollama run llama3 "你好，介绍下你自己"
ollama pull llama3
ollama pull qwen2
ollama pull mistral
ollama list
ollama rm llama3
ollama run qwen2
ollama run mistral -p "请用要点解释 Transformer 的注意力机制"
-p 传入 prompt；-m 指定模型；-t 模板相关（在 Modelfile 中更常见）。temperature、top_p、top_k、num_predict、repeat_penalty、mirostat。num_ctx（影响长文能力与内存占用）。POST /api/generate多轮对话：POST /api/chat
curl 示例：curl -X POST http://localhost:11434/api/generate \
-H "Content-Type: application/json" \
-d '{
"model": "llama3",
"prompt": "用三句话解释RAG",
"stream": false
}'
import requests
url = "http://localhost:11434/api/chat"
payload = {
"model": "llama3",
"messages": [
{"role": "user", "content": "给我一个Python生成示例"}
],
"stream": False
}
resp = requests.post(url, json=payload, timeout=60)
print(resp.json())
const fetch = require('node-fetch');
(async () => {
const res = await fetch('http://localhost:11434/api/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ model: 'qwen2', prompt: '列出三条LLM提示工程建议', stream: false })
});
const data = await res.json();
console.log(data);
})();
POST /api/embeddingscurl -X POST http://localhost:11434/api/embeddings \
-H "Content-Type: application/json" \
-d '{
"model": "llama3",
"prompt": "大语言模型是什么"
}'
faiss、pgvector、milvus 等库。Modelfile 在基础模型上添加系统提示、模板、参数等，生成自己的可复用模型。# 文件名: Modelfile
FROM llama3
PARAMETER temperature 0.7
PARAMETER num_ctx 4096
SYSTEM "你是一名资深中文助理，回答要简洁、有条理。"
TEMPLATE "用户：\n助理："
ollama create my-llama -f Modelfile
ollama run my-llama -p "请用要点解释Attention"
keep_alive 设置为如 5m 可提高多次调用的响应速度（模型常驻内存）。Modelfile 配置系统提示、模板、参数，必要时引入 LoRA 适配器，创建个人化模型。Modelfile 是定义自定义模型的核心配置文件，支持以下指令：
FROM <模型名>：指定基础模型（必需）SYSTEM <提示词>：设置系统提示，定义模型角色和行为TEMPLATE <模板字符串>：定义对话模板格式PARAMETER <参数名> <值>：设置模型推理参数ADAPTER <路径>：引入 LoRA 适配器（可选）LICENSE <许可证>：声明模型许可证MESSAGE <角色> <内容>：添加示例对话消息语法：
FROM <模型名>[:<标签>]
说明：
llama3:8b）示例：
FROM llama3 # 使用默认版本
FROM llama3:8b # 使用 8b 版本
FROM qwen2:7b # 使用 qwen2 的 7b 版本
FROM myuser/mymodel # 使用自定义模型
FROM myuser/mymodel:1.0 # 使用自定义模型的特定版本
语法：
SYSTEM "<单行提示词>"
# 或
SYSTEM """多行提示词
可以包含换行
支持多行内容"""
说明：
" 或三引号 """ 包裹示例：
# 单行
SYSTEM "你是一名专业的AI助手。"
# 多行
SYSTEM """你是一名资深软件工程师。
你的职责包括：
1. 编写高质量代码
2. 进行代码审查
3. 提供技术建议"""
# 使用变量（在模板中）
SYSTEM "你是一个编程专家。"
语法：
TEMPLATE "<模板字符串>"
# 或
TEMPLATE """多行模板
支持换行"""
说明：
模板语法：
...：条件判断......：条件判断（带 else）\n：换行符\t：制表符示例：
# 简单模板
TEMPLATE "用户：\n助手："
# 条件模板
TEMPLATE """系统：
用户：
助手："""
# 复杂模板（多轮对话格式）
TEMPLATE """<|system|>
<|end|>
<|user|>
<|end|>
<|assistant|>
"""
常见模型模板格式：
# ChatML 格式（OpenAI 风格）
TEMPLATE """<|im_start|>system
<|im_end|>
<|im_start|>user
<|im_end|>
<|im_start|>assistant
"""
# Alpaca 格式
TEMPLATE """Below is an instruction that describes a task. Write a response that appropriately completes the request.
### Instruction:
### Response:
"""
# Vicuna 格式
TEMPLATE """USER:
ASSISTANT: """
语法：
PARAMETER <参数名> <值>
说明：
常用参数列表：
| 参数名 | 类型 | 默认值 | 说明 | 取值范围 |
|---|---|---|---|---|
temperature |
float | 0.8 | 采样温度，控制随机性 | 0.0-2.0 |
top_p |
float | 0.9 | 核采样参数 | 0.0-1.0 |
top_k |
int | 40 | Top-K 采样，限制候选词数 | 1-100 |
num_ctx |
int | 2048 | 上下文窗口大小（token数） | 512-32768 |
num_predict |
int | -1 | 最大生成 token 数（-1 表示无限制） | -1 或正整数 |
repeat_penalty |
float | 1.1 | 重复惩罚系数 | 0.0-2.0 |
repeat_last_n |
int | 64 | 考虑重复惩罚的最近 token 数 | 0-2048 |
seed |
int | -1 | 随机种子（-1 表示随机） | -1 或非负整数 |
numa |
bool | false | 是否使用 NUMA | true/false |
num_thread |
int | 自动 | CPU 线程数 | 正整数 |
num_gpu |
int | 自动 | GPU 层数 | 非负整数 |
main_gpu |
int | 0 | 主 GPU 索引 | 非负整数 |
low_vram |
bool | false | 低显存模式 | true/false |
f16_kv |
bool | true | 使用 FP16 存储 KV 缓存 | true/false |
logits_all |
bool | false | 返回所有 token 的 logits | true/false |
vocab_only |
bool | false | 仅加载词汇表 | true/false |
use_mmap |
bool | true | 使用内存映射 | true/false |
use_mlock |
bool | false | 锁定内存 | true/false |
embedding_only |
bool | false | 仅用于 embeddings | true/false |
mirostat |
int | 0 | Mirostat 采样算法（0=禁用，1=Mirostat，2=Mirostat 2.0） | 0/1/2 |
mirostat_lr |
float | 0.1 | Mirostat 学习率 | 0.0-1.0 |
mirostat_eta |
float | 0.1 | Mirostat eta 参数 | 0.0-1.0 |
penalize_newline |
bool | true | 惩罚换行符 | true/false |
stop |
string | - | 停止序列（可多次使用） | 字符串 |
示例：
# 基础参数
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 40
# 上下文和生成长度
PARAMETER num_ctx 4096
PARAMETER num_predict 2048
# 重复控制
PARAMETER repeat_penalty 1.1
PARAMETER repeat_last_n 64
# 随机种子（用于可复现性）
PARAMETER seed 42
# 停止序列（可多次使用）
PARAMETER stop "用户："
PARAMETER stop "Human:"
PARAMETER stop "\n\n\n"
# GPU 配置
PARAMETER num_gpu 2
PARAMETER main_gpu 0
PARAMETER low_vram true
# 采样算法
PARAMETER mirostat 2
PARAMETER mirostat_lr 0.1
PARAMETER mirostat_eta 0.1
语法：
MESSAGE <角色> "<内容>"
# 或
MESSAGE <角色> """多行内容
支持换行"""
说明：
user 或 assistant示例：
# 单轮对话示例
MESSAGE user "什么是 Python？"
MESSAGE assistant "Python 是一种高级编程语言，以简洁和可读性著称。"
# 多轮对话示例
MESSAGE user "如何学习编程？"
MESSAGE assistant "学习编程可以从以下几个方面入手：\n1. 选择一门语言\n2. 练习基础语法\n3. 做项目实践"
MESSAGE user "推荐一些学习资源"
MESSAGE assistant "推荐资源：\n- 官方文档\n- 在线教程\n- 编程练习平台"
# 复杂格式示例
MESSAGE user """请帮我写一个 Python 函数，计算斐波那契数列的第 n 项。"""
MESSAGE assistant """```python
def fibonacci(n):
if n <= 1:
return n
a, b = 0, 1
for _ in range(2, n + 1):
a, b = b, a + b
return b
```"""
语法：
ADAPTER <路径>
说明：
示例：
# 相对路径
ADAPTER ./lora_adapter
ADAPTER ./adapters/code_assistant
# 绝对路径
ADAPTER /home/user/adapters/my_adapter
ADAPTER C:\Users\user\adapters\my_adapter
语法：
LICENSE "<许可证名称>"
# 或
LICENSE """多行许可证文本
可以包含完整的许可证内容"""
说明：
示例：
# 许可证名称
LICENSE "MIT"
LICENSE "Apache-2.0"
LICENSE "CC-BY-4.0"
# 完整许可证文本
LICENSE """MIT License
Copyright (c) 2024
Permission is hereby granted...
"""
语法：
# 单行注释
# 这是注释内容
说明：
# 开头表示注释示例：
# 这是一个代码助手模型
FROM llama3:8b
# 系统提示：定义模型角色
SYSTEM "你是一名专业的代码助手。"
# 推理参数：平衡创造性和准确性
PARAMETER temperature 0.7 # 适中的随机性
PARAMETER top_p 0.9 # 核采样
语法：
# 使用三引号
"""多行内容
可以包含换行
保留格式"""
说明：
""" 包裹多行内容示例：
SYSTEM """你是一名专业助手。
你的回答需要：
1. 准确
2. 详细
3. 有条理"""
TEMPLATE """系统：
用户：
助手："""
推荐顺序：
FROM（必需，放在最前）ADAPTER（如果有）SYSTEMTEMPLATEPARAMETER（可以多个）MESSAGE（可以多个）LICENSE优先级规则：
PARAMETER 可以多次使用设置不同参数MESSAGE 按顺序累积，形成对话历史示例：
# 正确的顺序示例
FROM llama3:8b
ADAPTER ./my_adapter
SYSTEM "你是一名助手。"
TEMPLATE "用户：\n助手："
PARAMETER temperature 0.7
PARAMETER num_ctx 4096
MESSAGE user "示例1"
MESSAGE assistant "回复1"
MESSAGE user "示例2"
MESSAGE assistant "回复2"
LICENSE "MIT"
常用转义字符：
\n：换行符\t：制表符\"：双引号\\：反斜杠\r：回车符示例：
# 在单引号字符串中使用转义
TEMPLATE "用户：\n助手："
# 在多行字符串中也可以使用
SYSTEM "第一行\n第二行\n第三行"
# 文件名: Modelfile
# 基于 llama3 创建专业代码助手
FROM llama3:8b
# 系统提示：定义模型角色
SYSTEM """你是一名资深的软件工程师和代码审查专家。
你的回答需要：
1. 代码示例清晰、可运行
2. 解释简洁、有条理
3. 提供最佳实践建议
4. 指出潜在问题和改进方向"""
# 对话模板：定义用户和助手的交互格式
TEMPLATE """系统：
用户：
助手："""
# 推理参数配置
PARAMETER temperature 0.7 # 创造性（0-1，越高越随机）
PARAMETER top_p 0.9 # 核采样参数
PARAMETER top_k 40 # Top-K 采样
PARAMETER num_ctx 4096 # 上下文窗口大小
PARAMETER num_predict 2048 # 最大生成 token 数
PARAMETER repeat_penalty 1.1 # 重复惩罚（>1 减少重复）
PARAMETER seed 42 # 随机种子（固定可复现）
# 示例对话（few-shot learning）
MESSAGE user "如何优化 Python 列表查找性能？"
MESSAGE assistant """对于频繁查找，可以使用集合（set）替代列表：
```python
# 慢：O(n)
if item in my_list:
pass
# 快：O(1)
if item in my_set:
pass
对于有序数据，使用二分查找（bisect 模块）。”””
LICENSE “MIT”
#### 不同场景的 Modelfile 示例
**示例 1：中文对话助手**
```dockerfile
FROM qwen2:7b
SYSTEM "你是一个友好、专业的中文AI助手。回答要自然、易懂，适当使用表情符号。"
TEMPLATE "用户：\n\n助手："
PARAMETER temperature 0.8
PARAMETER num_ctx 8192
示例 2：技术文档生成器
FROM mistral:7b
SYSTEM """你是一个技术文档编写专家。
输出格式要求：
- 使用 Markdown 格式
- 代码块包含语言标识
- 提供清晰的步骤说明
- 包含注意事项和最佳实践"""
TEMPLATE "\n\n请按照上述要求生成文档：\n\n"
PARAMETER temperature 0.3
PARAMETER num_predict 4096
示例 3：数据分析助手
FROM llama3:8b
SYSTEM "你擅长数据分析和统计。回答时提供具体的数据处理步骤、代码示例和可视化建议。"
PARAMETER temperature 0.5
PARAMETER num_ctx 16384
# 1. 准备 Modelfile（在当前目录创建 Modelfile 文件）
cat > Modelfile << 'EOF'
FROM llama3
SYSTEM "你是一名专业助理。"
PARAMETER temperature 0.7
EOF
# 2. 创建模型
ollama create mymodel -f Modelfile
# 3. 测试模型
ollama run mymodel -p "介绍一下你自己"
# 不同量化等级（从高到低质量，从大到小体积）
ollama create mymodel -f Modelfile --quantize q8_0 # 8位量化，质量最高
ollama create mymodel -f Modelfile --quantize q6_K # 6位量化，平衡选择
ollama create mymodel -f Modelfile --quantize q4_K_M # 4位量化，推荐
ollama create mymodel -f Modelfile --quantize q4_0 # 4位量化，最小体积
量化等级说明：
q8_0：8位量化，接近原始质量，体积较大q6_K：6位量化，质量与体积的平衡点q4_K_M：4位量化（中等），推荐用于大多数场景q4_0：4位量化（基础），体积最小但质量略低# 查看模型详细信息
ollama show mymodel
# 查看模型的 Modelfile 配置
ollama show mymodel --modelfile
# 列出所有模型
ollama list
# 复制模型（用于创建变体）
ollama cp mymodel mymodel-v2
# 删除模型
ollama rm mymodel
LoRA（Low-Rank Adaptation）是一种参数高效的微调方法，可以在不修改基础模型的情况下添加特定能力。
# LoRA 适配器通常是一个目录，包含适配器权重文件
# 目录结构示例：
# adapter_dir/
# ├── adapter_config.json
# └── adapter_model.bin
FROM llama3:8b
ADAPTER ./adapter_dir
SYSTEM "你是一名经过专业领域训练的AI助手。"
PARAMETER temperature 0.7
# 确保 adapter_dir 目录存在且包含适配器文件
ollama create mymodel-lora -f Modelfile
注意事项：
# 查看本机的公钥
ollama key
# 或查看公钥文件位置（通常在 ~/.ollama/id_ed25519.pub）
步骤 1：命名模型（使用命名空间）
模型名称必须遵循 <用户名>/<模型名> 的格式：
# 如果模型已存在，需要复制并重命名
ollama cp mymodel <你的用户名>/mymodel
# 或者创建时直接使用命名空间
ollama create <你的用户名>/mymodel -f Modelfile
示例（假设用户名为 john）：
ollama cp mymodel john/code-assistant
步骤 2：验证模型
推送前建议先本地测试：
# 测试模型功能
ollama run <你的用户名>/mymodel -p "测试提示"
# 查看模型信息
ollama show <你的用户名>/mymodel
步骤 3：推送模型
# 推送模型到 Ollama 模型库
ollama push <你的用户名>/mymodel
推送过程会显示进度：
pushing manifest
pushing 2/2 layers (100%)
pushed successfully
步骤 4：验证推送结果
curl https://ollama.com/api/tags | grep "<你的用户名>/mymodel"
使用标签管理模型版本，便于迭代和回滚：
# 创建带版本标签的模型
ollama cp <你的用户名>/mymodel <你的用户名>/mymodel:1.0
ollama cp <你的用户名>/mymodel <你的用户名>/mymodel:latest
# 推送特定版本
ollama push <你的用户名>/mymodel:1.0
ollama push <你的用户名>/mymodel:latest
# 更新模型后创建新版本
ollama cp <你的用户名>/mymodel <你的用户名>/mymodel:2.0
ollama push <你的用户名>/mymodel:2.0
版本命名建议：
latest：最新稳定版1.0、1.1、2.0：语义化版本号dev、beta：开发/测试版本2024-12-01：日期版本推送成功后，其他人可以通过以下方式使用：
# 拉取模型
ollama pull <你的用户名>/mymodel
# 或拉取特定版本
ollama pull <你的用户名>/mymodel:1.0
# 运行模型
ollama run <你的用户名>/mymodel -p "你好"
症状：
Error: unauthorized
解决方案：
# 删除旧密钥（谨慎操作）
rm ~/.ollama/id_ed25519*
# Ollama 会在下次操作时自动生成新密钥
ollama key # 查看新公钥
症状：
Error: timeout
解决方案：
export HTTP_PROXY=http://proxy:port
export HTTPS_PROXY=http://proxy:port
ollama push <你的用户名>/mymodel
症状：
Error: invalid model name
解决方案：
<用户名>/<模型名>原因与优化：
# 1. 修改 Modelfile
vim Modelfile
# 2. 重新创建模型（使用相同名称）
ollama create <你的用户名>/mymodel -f Modelfile
# 3. 推送更新
ollama push <你的用户名>/mymodel
# 注意：删除操作需要谨慎，可能影响其他用户
# 在 Ollama 网站上进行删除操作更安全
在推送模型时，建议：
# 基于已有自定义模型创建新模型
FROM <你的用户名>/mymodel
SYSTEM "在原有基础上，你还需要擅长数据分析。"
PARAMETER temperature 0.6
TEMPLATE """系统指令：
用户：
助手："""
MESSAGE user "什么是 RAG？"
MESSAGE assistant "RAG（Retrieval-Augmented Generation）是一种结合检索和生成的技术..."
MESSAGE user "它有什么优势？"
MESSAGE assistant "RAG 的主要优势包括：1. 可以访问最新信息 2. 减少幻觉..."
num_ctx：增大可处理更长文本，但显著提升内存与算力需求。num_predict：限制最大输出 token 数，避免响应过长。stream: true 可边生成边传输，提升交互体验。/api/embeddings）。/api/chat 作为系统/用户提示。llama3、qwen2、mistral、phi3 等。llava 需要额外输入；参考：https://ollama.com/docs/models11434 未被占用；或通过环境变量更改端口。q4）；降低 num_ctx。# 拉取/运行
ollama pull llama3
ollama run llama3 -p "用5点说明提示工程"
# 查看模型
ollama list
# 删除模型
ollama rm llama3
# 创建自定义模型
ollama create my-llama -f Modelfile
ollama run my-llama -p "测试"
# 生成向量
curl -s http://localhost:11434/api/embeddings -d '{"model":"llama3","prompt":"示例"}'