目录

摘要

量子计算正在改变我们处理复杂计算问题的方式。本文从量子计算基础概念出发，深入讲解量子比特、量子门等核心原理，并以IBM开源框架Qiskit为工具，手把手带你实现量子算法。通过本文，你将掌握量子计算的基本原理，学会使用Qiskit构建量子电路，并实现Grover搜索、Deutsch-Jozsa等经典量子算法。无论你是量子计算新手还是希望系统学习Qiskit的开发者，本文都将为你打开量子世界的大门。

1. 引言：为什么需要量子计算？

传统计算机使用比特（bit）作为基本计算单位，每个比特只能处于0或1两种状态之一。然而，随着摩尔定律逐渐失效，传统计算机的性能提升面临瓶颈。在密码破解、药物研发、金融建模等领域，传统计算机往往需要数年甚至数百年才能解决的问题，量子计算机可能只需要几分钟。

量子计算利用量子力学原理，通过量子比特（qubit）的叠加态和纠缠特性，实现指数级的计算加速。2024年，IBM发布了1000+量子比特处理器，谷歌宣称实现"量子霸权"，量子计算正从实验室走向实际应用。

本文将带你：

  • ✅ 理解量子比特、量子门等核心概念
  • ✅ 掌握Qiskit框架的基本使用
  • ✅ 实现Grover搜索、Deutsch-Jozsa等量子算法
  • ✅ 了解量子计算的实际应用场景

2. 量子比特：量子计算的基本单元

2.1 从经典比特到量子比特

经典比特是确定性的，要么是0，要么是1。而量子比特则可以同时处于0和1的叠加态（superposition）。这种特性使得量子计算机能够并行处理大量可能性。

数学上，量子比特的状态可以用布洛赫球（Bloch Sphere）表示：

|ψ⟩ = α|0⟩ + β|1⟩

其中，α和β是复数概率幅，满足 |α|² + |β|² = 1。这意味着测量时，量子比特有 |α|² 的概率坍缩为0，有 |β|² 的概率坍缩为1。

2.2 量子比特的物理实现

量子比特可以通过多种物理系统实现：

物理实现 优点 缺点 代表公司
超导量子比特 可扩展性好、操控精确 需要极低温环境 IBM、Google
离子阱 量子门保真度高 扩展难度大 IonQ、Honeywell
光量子 室温运行、通信方便 存储困难 Xanadu
拓扑量子比特 抗噪声能力强 技术尚未成熟 Microsoft

2.3 量子纠缠：超越经典的关联

量子纠缠是量子计算最神奇的特性之一。当两个量子比特处于纠缠态时，对其中一个的测量会瞬间影响另一个的状态，无论它们相距多远。

最著名的纠缠态是Bell态：

|Φ⁺⟩ = (|00⟩ + |11⟩) / √2

这意味着测量第一个量子比特得到0时，第二个量子比特必然也是0；测量得到1时，第二个也必然是1。这种"超距关联"是量子计算实现指数加速的关键资源之一。

3. 量子门：操控量子比特的艺术

3.1 单量子比特门

量子门是对量子比特进行操作的基本单元。与经典逻辑门不同，量子门是可逆的，可以用酉矩阵（unitary matrix）表示。

Pauli门

Pauli门是最基础的量子门，包括X、Y、Z三个门：

在这里插入图片描述

  • X门：量子版本的NOT门，将|0⟩翻转为|1⟩，|1⟩翻转为|0⟩
  • Z门：给|1⟩态添加相位因子-1，|0⟩态不变
  • Y门：同时实现比特翻转和相位翻转
Hadamard门

Hadamard门（H门）是量子计算中最重要的门之一，它能将量子比特置于叠加态：

H|0⟩ = (|0⟩ + |1⟩) / √2
H|1⟩ = (|0⟩ - |1⟩) / √2

H门是许多量子算法的基础，它让量子比特同时"探索"所有可能的计算路径。

3.2 多量子比特门

CNOT门（受控非门）

CNOT门是最常用的双量子比特门。它有两个输入：控制比特和目标比特。当控制比特为|1⟩时，目标比特被翻转；否则保持不变。

目标比特 控制比特 目标比特 控制比特 CNOT门操作 alt [控制比特 = |1⟩] [控制比特 = |0⟩] 翻转目标比特 保持不变

CNOT门与H门配合，可以创建Bell纠缠态：

|00⟩ --H--> (|0⟩ + |1⟩)|0⟩ / √2 --CNOT--> (|00⟩ + |11⟩) / √2

3.3 量子门的通用性

一个重要的理论结果是：任意n量子比特的酉变换都可以分解为单量子比特门和CNOT门的组合。这意味着这些门构成了"通用量子门集"，足以实现任意量子算法。

通用量子门集

单量子比特门
H, X, Y, Z, T, S

CNOT门

任意酉变换

任意量子算法

4. Qiskit框架介绍

4.1 什么是Qiskit？

Qiskit是IBM开发的开源量子计算框架，提供完整的量子编程工具链：

  • Qiskit Terra：核心组件，用于构建和编译量子电路
  • Qiskit Aer：高性能模拟器，支持噪声模拟
  • Qiskit Runtime：云端量子计算服务
  • Qiskit Nature：量子化学应用
  • Qiskit Machine Learning：量子机器学习

4.2 Qiskit发展历程

年份 里程碑
2017 Qiskit首次发布，支持5量子比特处理器
2019 发布Qiskit 0.10，引入脉冲级控制
2020 推出Qiskit Runtime，实现云端量子计算
2022 发布Qiskit 1.0，API重构优化
2024 支持1000+量子比特处理器

4.3 为什么选择Qiskit？

  • ✅ 开源免费：Apache 2.0许可证，社区活跃
  • ✅ 文档完善：官方教程、API文档齐全
  • ✅ 真机支持：可直接在IBM量子计算机上运行
  • ✅ 生态丰富：与NumPy、Jupyter无缝集成
  • ✅ 持续更新：IBM持续投入研发

5. 环境准备与快速开始

5.1 安装Qiskit

# 创建虚拟环境
python -m venv qiskit-env
source qiskit-env/bin/activate  # Linux/Mac
# qiskit-env\Scripts\activate  # Windows

# 安装Qiskit
pip install qiskit qiskit-aer qiskit-ibm-runtime

# 安装可视化工具
pip install qiskit[visualization]

上述命令创建了一个独立的Python虚拟环境，并安装了Qiskit核心组件。qiskit-aer提供高性能模拟器，qiskit-ibm-runtime用于连接IBM云端量子计算机。

5.2 第一个量子电路

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# 创建一个2量子比特的量子电路
qc = QuantumCircuit(2, 2)

# 在第一个量子比特上应用Hadamard门，创建叠加态
qc.h(0)

# 应用CNOT门，控制比特为0，目标比特为1
# 这将创建Bell纠缠态
qc.cx(0, 1)

# 测量两个量子比特
qc.measure([0, 1], [0, 1])

# 打印电路图
print(qc.draw())

# 使用模拟器运行电路
simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
job = simulator.run(compiled_circuit, shots=1000)
result = job.result()
counts = result.get_counts()

# 输出测量结果
print(f"\n测量结果: {counts}")
# 预期输出: {'00': ~500, '11': ~500}

# 可视化结果
plot_histogram(counts)
plt.savefig('bell_state_result.png')

这段代码创建了一个Bell纠缠态，并测量了1000次。由于Bell态的特性，测量结果应该只有|00⟩和|11⟩两种，且概率各约50%。

代码解释：

  1. QuantumCircuit(2, 2) 创建一个包含2个量子比特和2个经典比特的电路
  2. qc.h(0) 在第0个量子比特上应用Hadamard门
  3. qc.cx(0, 1) 应用CNOT门，第0个量子比特为控制比特
  4. qc.measure() 将量子比特测量结果存储到经典比特
  5. AerSimulator() 使用Qiskit Aer模拟器
  6. shots=1000 表示运行电路1000次

5.3 电路可视化

Qiskit提供多种可视化方式：

# 文本格式电路图
print(qc.draw())

# Matplotlib格式（更美观）
qc.draw('mpl')
plt.savefig('circuit.png')

# LaTeX格式（适合论文）
qc.draw('latex')

6. 核心功能深入

6.1 量子态初始化

除了默认的|0⟩态，Qiskit支持任意量子态初始化：

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
import numpy as np

# 创建一个量子比特
qc = QuantumCircuit(1)

# 初始化为自定义状态 |ψ⟩ = 0.6|0⟩ + 0.8|1⟩
# 注意：概率幅必须归一化
alpha = 0.6
beta = 0.8
norm = np.sqrt(alpha**2 + beta**2)
qc.initialize([alpha/norm, beta/norm], 0)

# 查看初始化后的状态
state = Statevector(qc)
print(f"量子态: {state}")
print(f"测量|0⟩的概率: {abs(state[0])**2:.4f}")
print(f"测量|1⟩的概率: {abs(state[1])**2:.4f}")

这段代码展示了如何将量子比特初始化为任意叠加态。initialize方法接受一个概率幅列表，Qiskit会自动将其归一化。

6.2 量子门组合

复杂量子算法需要组合多个量子门：

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
import math

# 创建一个3量子比特电路
qc = QuantumCircuit(3)

# 创建均匀叠加态（所有量子比特同时处于|0⟩和|1⟩）
qc.h([0, 1, 2])

# 应用相位门
qc.p(math.pi/4, 0)  # T门
qc.p(math.pi/2, 1)  # S门

# 应用受控门
qc.cx(0, 1)  # CNOT
qc.ccx(0, 1, 2)  # Toffoli门（三量子比特门）

# 绘制电路
print(qc.draw('text'))

# 模拟运行
simulator = AerSimulator()
qc.measure_all()
job = simulator.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
print(f"测量结果: {counts}")

这段代码展示了多种量子门的组合使用：

  • qc.h([0,1,2]) 批量应用Hadamard门
  • qc.p(theta, qubit) 应用相位旋转门
  • qc.ccx() 应用Toffoli门，这是一个三量子比特门

6.3 量子电路参数化

Qiskit支持参数化电路，便于变分算法：

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter

# 定义可变参数
theta = Parameter('θ')
phi = Parameter('φ')

# 创建参数化电路
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.rz(theta, 0)  # 参数化Z旋转
qc.ry(phi, 1)    # 参数化Y旋转

print("参数化电路:")
print(qc.draw())

# 绑定参数值
bound_circuit = qc.assign_parameters({theta: math.pi/4, phi: math.pi/2})
print("\n绑定参数后的电路:")
print(bound_circuit.draw())

参数化电路是量子机器学习和变分量子算法的基础。通过调整参数，可以优化量子电路以达到特定目标。

7. 量子算法实战

7.1 Deutsch-Jozsa算法

Deutsch-Jozsa算法是展示量子计算优势的经典例子。给定一个黑盒函数f(x)，判断它是常函数（所有输出相同）还是平衡函数（一半输出0，一半输出1）。

经典算法最坏情况需要2^(n-1)+1次查询，而量子算法只需1次！

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
import numpy as np

def deutsch_jozsa_oracle(n, case='balanced'):
    """
    创建Deutsch-Jozsa预言机
    n: 输入量子比特数
    case: 'balanced' 或 'constant'
    """
    oracle = QuantumCircuit(n + 1)
    
    if case == 'balanced':
        # 平衡函数：输入为奇数时输出1
        for i in range(n):
            oracle.cx(i, n)
    else:
        # 常函数：始终输出1
        oracle.x(n)
    
    return oracle

def deutsch_jozsa_algorithm(n, oracle_case='balanced'):
    """
    完整的Deutsch-Jozsa算法
    """
    # 创建电路：n个输入量子比特 + 1个辅助量子比特
    qc = QuantumCircuit(n + 1, n)
    
    # 初始化辅助量子比特为|1⟩
    qc.x(n)
    
    # 对所有量子比特应用Hadamard门
    qc.h(range(n + 1))
    
    # 添加预言机
    oracle = deutsch_jozsa_oracle(n, oracle_case)
    qc.compose(oracle, inplace=True)
    
    # 再次对输入量子比特应用Hadamard门
    qc.h(range(n))
    
    # 测量输入量子比特
    qc.measure(range(n), range(n))
    
    return qc

# 测试算法
print("=" * 50)
print("Deutsch-Jozsa算法测试")
print("=" * 50)

# 测试平衡函数
qc_balanced = deutsch_jozsa_algorithm(3, 'balanced')
print("\n平衡函数电路:")
print(qc_balanced.draw())

simulator = AerSimulator()
job = simulator.run(transpile(qc_balanced, simulator), shots=1000)
result = job.result().get_counts()
print(f"\n平衡函数测量结果: {result}")
print("解释: 非'000'的结果表明函数是平衡的")

# 测试常函数
qc_constant = deutsch_jozsa_algorithm(3, 'constant')
print("\n常函数电路:")
print(qc_constant.draw())

job = simulator.run(transpile(qc_constant, simulator), shots=1000)
result = job.result().get_counts()
print(f"\n常函数测量结果: {result}")
print("解释: '000'的结果表明函数是常函数")

代码解释：

  1. 预言机（Oracle）实现了黑盒函数f(x)
  2. 平衡函数使用CNOT门实现，常函数使用X门实现
  3. 算法核心是两次Hadamard变换，利用量子干涉放大正确答案
  4. 如果测量结果全为0，函数是常函数；否则是平衡函数

7.2 Grover搜索算法

Grover算法实现了无序数据库的量子搜索，将搜索复杂度从O(N)降低到O(√N)，是量子计算最著名的应用之一。

否

是

初始化: 均匀叠加态

Oracle: 标记目标

Diffusion: 振幅放大

迭代次数足够?

测量: 高概率得到目标

 
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
import math

def grover_oracle(n, target):
    """
    创建Grover搜索的预言机
    标记目标状态（将目标状态的相位翻转）
    n: 量子比特数
    target: 目标状态的二进制字符串，如 '101'
    """
    oracle = QuantumCircuit(n)
    
    # 对目标状态中为0的量子比特应用X门
    # 这样目标状态变成|111⟩
    for i, bit in enumerate(target):
        if bit == '0':
            oracle.x(i)
    
    # 应用多控制Z门（相位翻转）
    # 当所有量子比特为|1⟩时，相位翻转
    oracle.h(n-1)
    if n == 2:
        oracle.cz(0, 1)
    else:
        oracle.mcx(list(range(n-1)), n-1)
    oracle.h(n-1)
    
    # 恢复X门
    for i, bit in enumerate(target):
        if bit == '0':
            oracle.x(i)
    
    return oracle

def diffusion_operator(n):
    """
    Grover扩散算子（振幅放大）
    """
    diffusion = QuantumCircuit(n)
    
    # 应用Hadamard门
    diffusion.h(range(n))
    
    # 应用X门
    diffusion.x(range(n))
    
    # 应用多控制Z门
    diffusion.h(n-1)
    if n == 2:
        diffusion.cz(0, 1)
    else:
        diffusion.mcx(list(range(n-1)), n-1)
    diffusion.h(n-1)
    
    # 恢复X门
    diffusion.x(range(n))
    
    # 恢复Hadamard门
    diffusion.h(range(n))
    
    return diffusion

def grover_search(n, target, iterations=None):
    """
    完整的Grover搜索算法
    n: 量子比特数
    target: 目标状态
    iterations: 迭代次数（默认自动计算）
    """
    if iterations is None:
        # 最优迭代次数 ≈ π/4 * √N
        iterations = int(math.pi / 4 * math.sqrt(2**n))
    
    qc = QuantumCircuit(n, n)
    
    # 初始化：创建均匀叠加态
    qc.h(range(n))
    
    # Grover迭代
    oracle = grover_oracle(n, target)
    diffusion = diffusion_operator(n)
    
    for _ in range(iterations):
        qc.compose(oracle, inplace=True)
        qc.compose(diffusion, inplace=True)
    
    # 测量
    qc.measure(range(n), range(n))
    
    return qc

# 测试Grover搜索
print("=" * 50)
print("Grover搜索算法测试")
print("=" * 50)

n = 3  # 3个量子比特，搜索空间大小为8
target = '101'  # 目标状态

print(f"\n搜索空间大小: {2**n}")
print(f"目标状态: |{target}⟩")
print(f"迭代次数: {int(math.pi/4 * math.sqrt(2**n))}")

qc = grover_search(n, target)
print("\nGrover电路:")
print(qc.draw())

# 运行模拟
simulator = AerSimulator()
job = simulator.run(transpile(qc, simulator), shots=1000)
result = job.result().get_counts()
print(f"\n测量结果: {result}")
print(f"目标状态 |{target}⟩ 的概率: {result.get(target, 0)/1000*100:.1f}%")

代码解释：

  1. 预言机：标记目标状态，将目标状态的相位翻转
  2. 扩散算子：放大目标状态的振幅，减小非目标状态的振幅
  3. 迭代次数：最优次数约为π/4 × √N，过多或过少都会降低成功率
  4. 测量：高概率得到目标状态

7.3 量子傅里叶变换（QFT）

量子傅里叶变换是许多量子算法的核心组件，包括Shor算法：

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.quantum_info import Statevector
import math

def qft(n):
    """
    量子傅里叶变换电路
    n: 量子比特数
    """
    qc = QuantumCircuit(n)
    
    for i in range(n):
        # 对每个量子比特应用Hadamard门
        qc.h(i)
        
        # 应用受控相位旋转
        for j in range(i + 1, n):
            angle = 2 * math.pi / (2 ** (j - i + 1))
            qc.cp(angle, j, i)
    
    # 交换量子比特顺序
    for i in range(n // 2):
        qc.swap(i, n - 1 - i)
    
    return qc

def inverse_qft(n):
    """
    逆量子傅里叶变换
    """
    qc = QuantumCircuit(n)
    
    # 交换量子比特顺序
    for i in range(n // 2):
        qc.swap(i, n - 1 - i)
    
    # 逆变换
    for i in range(n - 1, -1, -1):
        for j in range(n - 1, i, -1):
            angle = -2 * math.pi / (2 ** (j - i + 1))
            qc.cp(angle, j, i)
        qc.h(i)
    
    return qc

# 测试QFT
print("=" * 50)
print("量子傅里叶变换测试")
print("=" * 50)

n = 3
qc = QuantumCircuit(n)

# 初始化为特定状态 |5⟩ = |101⟩
qc.x(0)
qc.x(2)

print("\n初始状态: |101⟩ (|5⟩)")

# 应用QFT
qft_circuit = qft(n)
qc.compose(qft_circuit, inplace=True)

print("\nQFT电路:")
print(qft_circuit.draw())

# 查看变换后的状态
state = Statevector(qc)
print(f"\nQFT后的量子态振幅:")
for i, amp in enumerate(state):
    if abs(amp) > 0.01:
        print(f"  |{i:03b}⟩: {amp:.4f}")

# 应用逆QFT验证
inverse_qft_circuit = inverse_qft(n)
qc.compose(inverse_qft_circuit, inplace=True)

state_final = Statevector(qc)
print(f"\n逆QFT后的状态（应恢复为|101⟩）:")
for i, amp in enumerate(state_final):
    if abs(amp) > 0.01:
        print(f"  |{i:03b}⟩: {amp:.4f}")

8. 在真实量子计算机上运行

8.1 连接IBM Quantum

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit import QuantumCircuit, transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# 保存账户（首次使用）
# QiskitRuntimeService.save_account(
#     channel='ibm_quantum',
#     token='your_ibm_quantum_token',
#     overwrite=True
# )

# 加载账户
service = QiskitRuntimeService()

# 查看可用的量子计算机
print("可用的量子计算机:")
for backend in service.backends():
    print(f"  - {backend.name}: {backend.num_qubits}量子比特, 状态: {backend.status().status_msg}")

# 选择后端
backend = service.least_busy(operational=True, simulator=False)
print(f"\n选择的后端: {backend.name}")

8.2 提交作业到量子计算机

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
from qiskit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# 创建Bell态电路
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# 连接服务
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# 编译电路到目标后端
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
transpiled_qc = pm.run(qc)

# 使用Sampler运行
sampler = Sampler(backend)
job = sampler.run([transpiled_qc], shots=1000)

print(f"作业ID: {job.job_id()}")
print(f"作业状态: {job.status()}")

# 等待结果
result = job.result()
print(f"\n测量结果: {result[0].data.meas.get_counts()}")

8.3 噪声模拟

真实量子计算机存在噪声，Qiskit Aer可以模拟这些噪声：

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel
from qiskit_ibm_runtime import QiskitRuntimeService

# 创建电路
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# 获取真实设备的噪声模型
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")  # 替换为实际可用的后端
noise_model = NoiseModel.from_backend(backend)

# 创建带噪声的模拟器
simulator = AerSimulator(noise_model=noise_model)

# 运行模拟
job = simulator.run(transpile(qc, simulator), shots=1000)
result = job.result().get_counts()

print("带噪声的测量结果:")
print(result)
print(f"\n理想情况应只有'00'和'11'，噪声导致其他状态出现")

9. 量子计算应用场景

9.1 应用领域概览

量子计算应用

密码学
Shor算法破解RSA

化学模拟
药物研发

优化问题
物流/金融

机器学习
量子神经网络

物理模拟
材料科学

量子优势

9.2 当前限制与挑战

挑战 描述 解决方向
量子退相干 量子态容易受环境干扰而坍缩 错误纠正、拓扑量子比特
量子门错误 量子门操作存在误差 优化控制脉冲、改进硬件
量子比特数量 当前量子比特数有限 扩展硬件规模
量子软件 编程范式仍在探索 开发高级编程语言
量子算法 实用量子算法较少 研究新算法

10. 总结

本文从量子计算的基本概念出发，系统介绍了量子比特、量子门等核心原理，并通过Qiskit框架实现了多个经典量子算法。

核心要点回顾

  1. 量子比特：可同时处于|0⟩和|1⟩的叠加态，是量子计算的基本单元
  2. 量子门：包括单量子比特门（H、X、Z等）和多量子比特门（CNOT等），构成通用量子门集
  3. Qiskit框架：IBM开源的量子计算框架，支持模拟和真实量子计算机
  4. 量子算法：Deutsch-Jozsa、Grover搜索展示了量子计算的理论优势

学习建议

  • 🔥 从Qiskit官方教程开始，循序渐进
  • 🔥 多动手实践，在模拟器上运行各种电路
  • 🔥 理解量子干涉原理，这是量子算法加速的核心
  • 🔥 关注量子计算最新进展，领域发展迅速

思考题

  1. 量子计算的"叠加"和"纠缠"特性，如何在实际算法中发挥作用？
  2. 当前量子计算机的主要限制是什么？你认为何时能实现大规模应用？
  3. 除了本文介绍的算法，还有哪些量子算法具有实际应用价值？

参考资料

# 量子计算 # python # 算法
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

【AI】从混沌到精准：LLM 结构化信息抽取的提示词迭代之路

avatar AtomGit开源社区
cover

Tranformer 代码实现3：手搓 FNN 层

avatar AtomGit开源社区
cover

【深度收藏】从“手“到“说明书“，一文看懂AI Agent的Function Calling、MCP和Skills

avatar AtomGit开源社区