简单fastapi和压测实例

FastAPI与Flask性能压测对比:异步框架在无I/O场景下的真实表现 在Web开发中,异步编程与同步模型是两种核心的并发处理范式。异步编程基于事件循环,通过非阻塞I/O操作处理高并发连接,其原理是在I/O等待期间释放资源以处理其他任务,从而提升系统吞吐量。这项技术的核心价值在于高效管理I/O密集型操作,例如处理大量网络请求或数据库查询。在实际应用场景中,异步框架如FastAPI常被用于构建微服务、实时API等。然而,技术选型需结合具体场景,例如在无I/O阻塞的纯CPU逻辑场景下,同步模型的简单性可能带来更优性能。本次测试围绕**FastAPI**和**Flask**展开,通过 阅读详情

服务器

from fastapi import FastAPI, HTTPException
import pymysql
from dbutils.pooled_db import PooledDB
from pydantic import BaseModel, Field
from typing import List, Optional, Dict

# 1. 初始化FastAPI应用实例
app = FastAPI(
    title="Shop数据库用户管理接口",
    description="支持查询所有用户、插入单条用户数据",
    version="2.0.0"
)

# 2. 配置MySQL连接参数(与原有配置一致)
MYSQL_CONFIG = {
    'host': 'localhost',
    'port': 3306,
    'user': 'root',
    'password': '666',
    'database': 'shop',
    'charset': 'utf8mb4'
}

# 3. 初始化数据库连接池(全局唯一,仅启动时创建一次)
POOL = PooledDB(
    creator=pymysql,  # 指定使用的数据库驱动
    **MYSQL_CONFIG,  # 传入MySQL连接参数
    maxconnections=10,  # 连接池最大连接数(根据业务调整)
    mincached=2,  # 初始化时,连接池中至少创建的空闲连接数
    maxcached=5,  # 连接池中最多缓存的空闲连接数
    maxusage=None,  # 每个连接最多被使用的次数(None表示无限制)
    blocking=True  # 当连接池无可用连接时,是否阻塞等待(True=等待,False=直接报错)
)


# 4. 定义数据模型(请求/响应)
class UserCreateRequest(BaseModel):
    """
    插入用户的请求数据模型(参数校验)
    """
    name: str = Field(..., min_length=1, max_length=50, description="用户名,不能为空,长度1-50")


class UserInfo(BaseModel):
    """
    用户信息响应模型
    """
    id: Optional[int] = None
    name: Optional[str] = None

    class Config:
        orm_mode = True


# 5. 核心工具函数(查询+插入)
def get_all_users_from_mysql() -> List[Dict]:
    """
    从连接池获取连接,查询users表所有数据,返回格式化的字典列表
    """
    conn = None
    cursor = None
    try:
        # 从连接池获取连接
        conn = POOL.connection()
        # 创建游标(指定DictCursor,返回字典格式)
        cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

        # 执行查询
        sql = "SELECT * FROM users;"
        cursor.execute(sql)

        # 获取所有结果
        all_results = cursor.fetchall()

        return all_results

    except pymysql.Error as e:
        raise Exception(f"数据库查询失败:{str(e)}")
    finally:
        # 关闭游标和归还连接
        if cursor:
            cursor.close()
        if conn:
            conn.close()


def insert_one_user_to_mysql(user_name: str) -> Dict:
    """
    从连接池获取连接,插入一条用户数据到users表,返回插入后的用户信息(含自增id)
    开启事务保障,避免数据插入异常
    """
    conn = None
    cursor = None
    try:
        # 从连接池获取连接
        conn = POOL.connection()
        # 创建游标(普通游标,用于获取自增id)
        cursor = conn.cursor()

        # 定义插入SQL(使用参数化查询,避免SQL注入)
        insert_sql = "INSERT INTO users (name) VALUES (%s);"
        # 执行插入(传入参数元组,与SQL中的%s对应)
        affected_rows = cursor.execute(insert_sql, (user_name,))

        # 提交事务(关键:插入/更新/删除操作必须提交事务才会生效)
        conn.commit()

        # 获取插入数据的自增id
        insert_id = cursor.lastrowid
        # 查询插入后的完整用户信息,用于返回
        select_sql = "SELECT * FROM users WHERE id = %s;"
        cursor.execute(select_sql, (insert_id,))
        inserted_user = cursor.fetchone()

        # 转换为字典格式(与查询接口返回格式一致)
        if inserted_user:
            fields = [desc[0] for desc in cursor.description]
            user_dict = dict(zip(fields, inserted_user))
            return user_dict
        else:
            raise Exception("插入成功,但未查询到该用户数据")

    except pymysql.Error as e:
        # 回滚事务(插入失败时,撤销所有未提交的操作)
        if conn:
            conn.rollback()
        raise Exception(f"数据库插入失败:{str(e)}")
    finally:
        # 关闭游标和归还连接
        if cursor:
            cursor.close()
        if conn:
            conn.close()


# 6. 定义FastAPI接口(查询+插入)
@app.get(
    "/api/shop/users",
    summary="查询shop库users表所有数据",
    response_description="返回users表的所有用户信息(含字段名)",
    response_model=List[UserInfo]
)
async def get_all_users():
    try:
        user_list = get_all_users_from_mysql()
        if not user_list:
            return []
        return user_list
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@app.post(
    "/api/shop/users",
    summary="插入一条用户数据到shop库users表",
    response_description="返回插入成功后的用户完整信息(含自增id)",
    response_model=UserInfo,
    status_code=201  # 201 Created:表示资源创建成功,符合RESTful规范
)
async def create_one_user(user_request: UserCreateRequest):
    try:
        # 调用插入工具函数,传入校验后的用户名
        inserted_user = insert_one_user_to_mysql(user_name=user_request.name)
        return inserted_user
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


# 7. 运行服务器
if __name__ == "__main__":
    import uvicorn

    uvicorn.run(
        app="__main__:app",
        host="0.0.0.0",
        port=8000,
        reload=True
    )

压测程序

import requests
import threading
import time
from datetime import datetime
from typing import List, Dict

# ---------------------- 压测配置项(可根据需求修改) ----------------------
TARGET_URL = "http://localhost:8000/api/shop/users"  # 你的FastAPI接口地址
CONCURRENT_THREADS = 5  # 并发线程数(模拟20个同时请求的用户)
TOTAL_REQUESTS_PER_THREAD = 50  # 每个线程发送的请求数
TIMEOUT = 10  # 单个请求超时时间(秒)

# ---------------------- 全局统计变量(线程安全) ----------------------
total_success = 0
total_failure = 0
response_times: List[float] = []
lock = threading.Lock()  # 线程锁,保证统计变量修改的安全性

def send_requests(thread_id: int) -> None:
    """
    单个线程的请求发送逻辑:循环发送指定数量的请求,并记录结果
    """
    global total_success, total_failure, response_times
    session = requests.Session()  # 每个线程创建一个Session,复用连接,提升效率

    for req_id in range(1, TOTAL_REQUESTS_PER_THREAD + 1):
        try:
            # 记录请求开始时间
            start_time = time.perf_counter()
            # 发送GET请求
            response = session.get(
                url=TARGET_URL,
                timeout=TIMEOUT
            )
            # 记录请求结束时间
            end_time = time.perf_counter()
            response_time = (end_time - start_time) * 1000  # 转换为毫秒

            # 验证请求是否成功(响应状态码200)
            if response.status_code == 200:
                with lock:  # 加锁修改全局变量,避免线程冲突
                    total_success += 1
                    response_times.append(response_time)
                print(f"[线程{thread_id}] 请求{req_id} 成功 | 响应时间:{response_time:.2f}ms | 响应状态码:{response.status_code}")
            else:
                with lock:
                    total_failure += 1
                print(f"[线程{thread_id}] 请求{req_id} 失败 | 响应状态码:{response.status_code}")

            print(total_success)
        except Exception as e:
            with lock:
                total_failure += 1
            print(f"[线程{thread_id}] 请求{req_id} 异常 | 错误信息:{str(e)}")

def run_benchmark() -> None:
    """
    启动压测:创建并启动所有线程,等待所有线程执行完成,输出统计结果
    """
    start_time = datetime.now()
    print("=" * 80)
    print(f"压测开始时间:{start_time.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"目标接口:{TARGET_URL}")
    print(f"并发线程数:{CONCURRENT_THREADS}")
    print(f"每个线程请求数:{TOTAL_REQUESTS_PER_THREAD}")
    print(f"总请求数:{CONCURRENT_THREADS * TOTAL_REQUESTS_PER_THREAD}")
    print("=" * 80 + "\n")

    # 创建线程列表
    threads: List[threading.Thread] = []
    for thread_id in range(1, CONCURRENT_THREADS + 1):
        thread = threading.Thread(
            target=send_requests,
            args=(thread_id,),
            name=f"Benchmark-Thread-{thread_id}"
        )
        threads.append(thread)
        thread.start()  # 启动线程

    # 等待所有线程执行完成
    for thread in threads:
        thread.join()

    # 计算统计结果
    end_time = datetime.now()
    total_duration = (end_time - start_time).total_seconds()
    avg_response_time = sum(response_times) / len(response_times) if response_times else 0
    qps = total_success / total_duration if total_duration > 0 else 0  # 每秒查询率(QPS)

    # 输出最终统计结果
    print("\n" + "=" * 80)
    print(f"压测结束时间:{end_time.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"总耗时:{total_duration:.2f} 秒")
    print(f"总请求数:{CONCURRENT_THREADS * TOTAL_REQUESTS_PER_THREAD}")
    print(f"成功请求数:{total_success}")
    print(f"失败请求数:{total_failure}")
    print(f"成功率:{(total_success / (total_success + total_failure) * 100):.2f}%" if (total_success + total_failure) > 0 else "成功率:0%")
    print(f"平均响应时间:{avg_response_time:.2f} ms")
    print(f"QPS(每秒查询率):{qps:.2f}")
    print("=" * 80)

if __name__ == "__main__":
    run_benchmark()

概述

包含两份核心代码的详细说明:FastAPI用户管理接口(后端服务) 和 Python多线程接口压测工具(前端压测),涵盖代码功能、结构解析、使用指南、注意事项等内容,便于开发、测试、运维人员理解和使用。

第一部分:FastAPI用户管理接口(后端服务)

1. 代码核心功能

该代码实现了一个基于FastAPI框架的轻量级用户管理后端服务,依托dbutils连接池操作MySQL数据库shop的users表,提供两大核心接口:

  • GET /api/shop/users:查询users表所有用户数据,返回结构化用户列表
  • POST /api/shop/users:插入一条用户数据到users表,返回插入后的完整用户信息(含自增ID)
  • 附加能力:参数校验、SQL注入防护、事务保障、异常处理、自动生成交互式接口文档

2. 依赖环境说明

依赖库版本要求核心作用
fastapi>=0.95.0构建高性能RESTful API,提供接口路由、响应模型、自动文档等能力
uvicorn>=0.22.0FastAPI官方推荐ASGI服务器,用于运行后端服务
pymysql>=1.0.0MySQL数据库Python驱动,实现数据库连接与SQL执行
dbutils>=3.1.0提供数据库连接池功能,复用连接、提升并发访问效率
pydantic>=2.0.0数据模型定义与参数校验,保障请求数据合法性

3. 代码结构逐段解析

3.1 初始化与配置模块
from fastapi import FastAPI, HTTPException
import pymysql
from dbutils.pooled_db import PooledDB
from pydantic import BaseModel, Field
from typing import List, Optional, Dict

# 1. 初始化FastAPI应用实例
app = FastAPI(
    title="Shop数据库用户管理接口",
    description="支持查询所有用户、插入单条用户数据",
    version="2.0.0"
)

# 2. 配置MySQL连接参数(与原有配置一致)
MYSQL_CONFIG = {
    'host': 'localhost',
    'port': 3306,
    'user': 'root',
    'password': '666',
    'database': 'shop',
    'charset': 'utf8mb4'
}

# 3. 初始化数据库连接池(全局唯一,仅启动时创建一次)
POOL = PooledDB(
    creator=pymysql,  # 指定使用的数据库驱动
    **MYSQL_CONFIG,  # 传入MySQL连接参数
    maxconnections=10,  # 连接池最大连接数(根据业务调整)
    mincached=2,  # 初始化时,连接池中至少创建的空闲连接数
    maxcached=5,  # 连接池中最多缓存的空闲连接数
    maxusage=None,  # 每个连接最多被使用的次数(None表示无限制)
    blocking=True  # 当连接池无可用连接时,是否阻塞等待(True=等待,False=直接报错)
)
  • 核心说明:
    1. FastAPI实例初始化时配置了文档元信息,访问http://localhost:8000/docs可查看交互式接口文档
    2. MYSQL_CONFIG需与实际MySQL环境匹配,charset=utf8mb4支持全量中文与特殊字符
    3. 连接池POOL为全局单例,避免频繁创建/关闭数据库连接,提升并发性能;blocking=True保证高并发下连接获取的稳定性(无可用连接时等待,而非直接报错)
3.2 数据模型定义模块
class UserCreateRequest(BaseModel):
    """
    插入用户的请求数据模型(参数校验)
    """
    name: str = Field(..., min_length=1, max_length=50, description="用户名,不能为空,长度1-50")

class UserInfo(BaseModel):
    """
    用户信息响应模型
    """
    id: Optional[int] = None
    name: Optional[str] = None

    class Config:
        orm_mode = True
  • 核心说明:
    1. UserCreateRequest:用于POST接口的请求体校验,Field约束name为必填、非空、长度1-50,不符合约束时自动返回422错误
    2. UserInfo:用于接口响应数据格式化,统一返回id和name字段;orm_mode=True支持将数据库查询结果(字典/元组)转换为模型实例
    3. 依赖pydantic实现自动校验与序列化,无需手动编写校验逻辑
3.3 数据库操作工具函数
3.3.1 全量用户查询函数 get_all_users_from_mysql
def get_all_users_from_mysql() -> List[Dict]:
    """
    从连接池获取连接,查询users表所有数据,返回格式化的字典列表
    """
    conn = None
    cursor = None
    try:
        # 从连接池获取连接
        conn = POOL.connection()
        # 创建游标(指定DictCursor,返回字典格式)
        cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
        
        # 执行查询
        sql = "SELECT * FROM users;"
        cursor.execute(sql)
        
        # 获取所有结果
        all_results = cursor.fetchall()
        
        return all_results

    except pymysql.Error as e:
        raise Exception(f"数据库查询失败:{str(e)}")
    finally:
        # 关闭游标和归还连接
        if cursor:
            cursor.close()
        if conn:
            conn.close()
  • 核心说明:
    1. 采用try-except-finally结构,保证游标关闭和连接归还(即使查询异常,也不会导致连接泄露)
    2. DictCursor游标返回字典格式结果(含字段名),便于后续接口返回结构化数据
    3. 连接从连接池获取(POOL.connection()),使用完毕后通过conn.close()归还到连接池(非真正关闭连接)
3.3.2 单条用户插入函数 insert_one_user_to_mysql
def insert_one_user_to_mysql(user_name: str) -> Dict:
    """
    从连接池获取连接,插入一条用户数据到users表,返回插入后的用户信息(含自增id)
    开启事务保障,避免数据插入异常
    """
    conn = None
    cursor = None
    try:
        # 从连接池获取连接
        conn = POOL.connection()
        # 创建游标(普通游标,用于获取自增id)
        cursor = conn.cursor()
        
        # 定义插入SQL(使用参数化查询,避免SQL注入)
        insert_sql = "INSERT INTO users (name) VALUES (%s);"
        # 执行插入(传入参数元组,与SQL中的%s对应)
        affected_rows = cursor.execute(insert_sql, (user_name,))
        
        # 提交事务(关键:插入/更新/删除操作必须提交事务才会生效)
        conn.commit()
        
        # 获取插入数据的自增id
        insert_id = cursor.lastrowid
        # 查询插入后的完整用户信息,用于返回
        select_sql = "SELECT * FROM users WHERE id = %s;"
        cursor.execute(select_sql, (insert_id,))
        inserted_user = cursor.fetchone()
        
        # 转换为字典格式(与查询接口返回格式一致)
        if inserted_user:
            fields = [desc[0] for desc in cursor.description]
            user_dict = dict(zip(fields, inserted_user))
            return user_dict
        else:
            raise Exception("插入成功,但未查询到该用户数据")

    except pymysql.Error as e:
        # 回滚事务(插入失败时,撤销所有未提交的操作)
        if conn:
            conn.rollback()
        raise Exception(f"数据库插入失败:{str(e)}")
    finally:
        # 关闭游标和归还连接
        if cursor:
            cursor.close()
        if conn:
            conn.close()
  • 核心说明:
    1. 事务保障:conn.commit()提交事务(插入操作生效),异常时conn.rollback()回滚事务(避免脏数据)
    2. 防SQL注入:采用参数化查询(%s占位符),参数通过元组传入,避免字符串拼接带来的注入风险
    3. cursor.lastrowid获取插入数据的自增ID(要求users表id字段为AUTO_INCREMENT)
    4. 插入后查询完整用户信息,保证返回数据与查询接口格式一致,提升接口易用性
3.4 接口定义模块
3.4.1 全量用户查询接口 GET /api/shop/users
@app.get(
    "/api/shop/users",
    summary="查询shop库users表所有数据",
    response_description="返回users表的所有用户信息(含字段名)",
    response_model=List[UserInfo]
)
async def get_all_users():
    try:
        user_list = get_all_users_from_mysql()
        if not user_list:
            return []
        return user_list
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
  • 核心说明:
    1. @app.get注解定义GET请求路由,response_model=List[UserInfo]约束返回数据格式为UserInfo模型列表
    2. 异常处理:捕获数据库查询异常,返回500状态码和详细错误信息,便于问题排查
    3. 异步函数(async):适配FastAPI的异步架构,提升高并发下的响应性能(实际数据库操作为同步,可后续优化为异步驱动)
3.4.2 单条用户插入接口 POST /api/shop/users
@app.post(
    "/api/shop/users",
    summary="插入一条用户数据到shop库users表",
    response_description="返回插入成功后的用户完整信息(含自增id)",
    response_model=UserInfo,
    status_code=201  # 201 Created:表示资源创建成功,符合RESTful规范
)
async def create_one_user(user_request: UserCreateRequest):
    try:
        # 调用插入工具函数,传入校验后的用户名
        inserted_user = insert_one_user_to_mysql(user_name=user_request.name)
        return inserted_user
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
  • 核心说明:
    1. @app.post注解定义POST请求路由,status_code=201符合RESTful规范(资源创建成功)
    2. user_request: UserCreateRequest自动解析请求体并完成参数校验,校验失败返回422错误
    3. 传入校验后的user_request.name到插入函数,保证数据库接收的是合法数据
3.5 服务运行模块
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        app="__main__:app",
        host="0.0.0.0",
        port=8000,
        reload=True
    )
  • 核心说明:
    1. 采用uvicorn运行FastAPI应用,host="0.0.0.0"允许局域网内其他设备访问,port=8000为服务端口
    2. reload=True开启热重载(开发环境专用),代码修改后自动重启服务,无需手动重启
    3. 生产环境建议关闭reload,并配置workers(多进程)提升并发能力

4. 使用指南

4.1 前置准备
  1. 安装依赖:pip install fastapi uvicorn pymysql dbutils pydantic
  2. 配置MySQL环境:
    • 启动MySQL服务,创建数据库shop:CREATE DATABASE IF NOT EXISTS shop DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
    • 创建users表:
      CREATE TABLE IF NOT EXISTS users (
          id INT PRIMARY KEY AUTO_INCREMENT COMMENT '自增用户ID',
          name VARCHAR(50) NOT NULL COMMENT '用户名',
          create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间'
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户信息表';
      
    • 修改MYSQL_CONFIG中的user、password为实际MySQL账号密码
4.2 启动服务
  1. 将代码保存为user_service.py
  2. 运行命令:python user_service.py(或uvicorn user_service:app --host 0.0.0.0 --port 8000 --reload)
  3. 服务启动成功标志:控制台输出Application startup complete.
4.3 接口调用与调试
方式1:交互式接口文档(推荐)
  • 访问http://localhost:8000/docs,进入FastAPI自动生成的Swagger文档
  • 对于GET /api/shop/users:点击「Try it out」→「Execute」,即可查看响应结果
  • 对于POST /api/shop/users:点击「Try it out」,填写请求体(如{"name": "张三"})→「Execute」,查看插入结果
方式2:curl命令调用
# 查询所有用户
curl -X GET "http://localhost:8000/api/shop/users" -H "Content-Type: application/json"

# 插入一条用户数据
curl -X POST "http://localhost:8000/api/shop/users" -H "Content-Type: application/json" -d "{\"name\": \"李四\"}"
方式3:第三方工具(Postman/Insomnia)
  • 配置请求方法、地址、请求头(Content-Type: application/json)和请求体,发送请求即可

5. 常见问题排查

问题现象可能原因解决方案
服务启动失败,提示“Access denied for user ‘root’@‘localhost’”MySQL账号密码错误修正MYSQL_CONFIG中的user、password
接口返回500,提示“数据库查询失败:1049 (42000): Unknown database ‘shop’”未创建shop数据库执行创建数据库的SQL语句
POST接口返回422,提示“field required”请求体缺少name字段或字段名拼写错误确保请求体包含name字段,字段名拼写正确
POST接口插入成功,但返回无idusers表id字段未设置为自增主键修改users表,将id字段设置为AUTO_INCREMENT
高并发下接口返回500,提示“Too many connections”MySQL最大连接数不足或连接池配置过小1. 增大MySQL最大连接数;2. 调大POOL的maxconnections参数

第二部分:Python多线程接口压测工具

1. 代码核心功能

该代码是一款轻量级的多线程接口压测工具,专门针对GET /api/shop/users接口进行压测,实现以下功能:

  • 模拟多线程并发请求(可配置并发线程数)
  • 每个线程发送指定数量的请求(可配置单线程请求数)
  • 记录请求成功率、失败率、响应时间(毫秒级)
  • 计算并输出压测汇总数据(总耗时、QPS、平均响应时间)
  • 线程安全的统计计数,避免并发修改数据冲突
  • 实时打印单个请求的执行结果,便于实时监控

2. 依赖环境说明

依赖库版本要求核心作用
requests>=2.28.0发送HTTP请求,获取接口响应结果
threading内置模块实现多线程并发,模拟高并发场景
time内置模块记录请求开始/结束时间,计算响应时间
datetime内置模块记录压测开始/结束时间,格式化时间输出
typing内置模块类型注解,提升代码可读性和可维护性

3. 代码结构逐段解析

3.1 压测配置项模块
import requests
import threading
import time
from datetime import datetime
from typing import List, Dict

# ---------------------- 压测配置项(可根据需求修改) ----------------------
TARGET_URL = "http://localhost:8000/api/shop/users"  # 你的FastAPI接口地址
CONCURRENT_THREADS = 5  # 并发线程数(模拟20个同时请求的用户)
TOTAL_REQUESTS_PER_THREAD = 50  # 每个线程发送的请求数
TIMEOUT = 10  # 单个请求超时时间(秒)
  • 核心说明:
    1. 配置项集中管理,便于用户根据实际场景修改,无需改动核心逻辑
    2. TARGET_URL:目标压测接口地址,需与FastAPI服务地址保持一致
    3. CONCURRENT_THREADS:并发线程数,模拟多个用户同时发起请求(建议根据服务器性能调整,避免过度压测)
    4. TOTAL_REQUESTS_PER_THREAD:单个线程发送的请求总数,总请求数=并发线程数×单线程请求数
    5. TIMEOUT:单个请求的超时时间,超过该时间未响应则判定为请求异常
3.2 全局统计变量与线程锁模块
# ---------------------- 全局统计变量(线程安全) ----------------------
total_success = 0
total_failure = 0
response_times: List[float] = []
lock = threading.Lock()  # 线程锁,保证统计变量修改的安全性
  • 核心说明:
    1. 全局统计变量:
      • total_success:成功请求总数(响应状态码200)
      • total_failure:失败请求总数(非200状态码+请求异常)
      • response_times:所有成功请求的响应时间列表(用于计算平均响应时间)
    2. threading.Lock():创建线程锁,解决多线程并发修改全局变量时的数据竞争问题(确保同一时间只有一个线程修改全局变量,避免数据统计错误)
3.3 单个线程请求发送函数 send_requests
def send_requests(thread_id: int) -> None:
    """
    单个线程的请求发送逻辑:循环发送指定数量的请求,并记录结果
    """
    global total_success, total_failure, response_times
    session = requests.Session()  # 每个线程创建一个Session,复用连接,提升效率

    for req_id in range(1, TOTAL_REQUESTS_PER_THREAD + 1):
        try:
            # 记录请求开始时间
            start_time = time.perf_counter()
            # 发送GET请求
            response = session.get(
                url=TARGET_URL,
                timeout=TIMEOUT
            )
            # 记录请求结束时间
            end_time = time.perf_counter()
            response_time = (end_time - start_time) * 1000  # 转换为毫秒

            # 验证请求是否成功(响应状态码200)
            if response.status_code == 200:
                with lock:  # 加锁修改全局变量,避免线程冲突
                    total_success += 1
                    response_times.append(response_time)
                print(f"[线程{thread_id}] 请求{req_id} 成功 | 响应时间:{response_time:.2f}ms | 响应状态码:{response.status_code}")
            else:
                with lock:
                    total_failure += 1
                print(f"[线程{thread_id}] 请求{req_id} 失败 | 响应状态码:{response.status_code}")

            print(total_success)
        except Exception as e:
            with lock:
                total_failure += 1
            print(f"[线程{thread_id}] 请求{req_id} 异常 | 错误信息:{str(e)}")
  • 核心说明:
    1. requests.Session():每个线程创建一个Session对象,复用TCP连接(避免每次请求都创建新连接),大幅提升压测效率
    2. time.perf_counter():高精度时间统计函数,用于计算请求响应时间(转换为毫秒后,精度更高,便于分析接口性能)
    3. 异常处理:捕获请求超时、网络中断、接口报错等异常,统一计入total_failure
    4. with lock:上下文管理器自动加锁/释放锁,修改全局变量时保证线程安全,避免数据统计偏差
    5. 实时打印:输出单个请求的执行结果(成功/失败/异常),便于实时监控压测过程中的接口状态
3.4 压测主函数 run_benchmark
def run_benchmark() -> None:
    """
    启动压测:创建并启动所有线程,等待所有线程执行完成,输出统计结果
    """
    start_time = datetime.now()
    print("=" * 80)
    print(f"压测开始时间:{start_time.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"目标接口:{TARGET_URL}")
    print(f"并发线程数:{CONCURRENT_THREADS}")
    print(f"每个线程请求数:{TOTAL_REQUESTS_PER_THREAD}")
    print(f"总请求数:{CONCURRENT_THREADS * TOTAL_REQUESTS_PER_THREAD}")
    print("=" * 80 + "\n")

    # 创建线程列表
    threads: List[threading.Thread] = []
    for thread_id in range(1, CONCURRENT_THREADS + 1):
        thread = threading.Thread(
            target=send_requests,
            args=(thread_id,),
            name=f"Benchmark-Thread-{thread_id}"
        )
        threads.append(thread)
        thread.start()  # 启动线程

    # 等待所有线程执行完成
    for thread in threads:
        thread.join()

    # 计算统计结果
    end_time = datetime.now()
    total_duration = (end_time - start_time).total_seconds()
    avg_response_time = sum(response_times) / len(response_times) if response_times else 0
    qps = total_success / total_duration if total_duration > 0 else 0  # 每秒查询率(仅统计成功请求)

    # 输出最终统计结果
    print("\n" + "=" * 80)
    print(f"压测结束时间:{end_time.strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"总耗时:{total_duration:.2f} 秒")
    print(f"总请求数:{CONCURRENT_THREADS * TOTAL_REQUESTS_PER_THREAD}")
    print(f"成功请求数:{total_success}")
    print(f"失败请求数:{total_failure}")
    print(f"成功率:{(total_success / (total_success + total_failure) * 100):.2f}%" if (total_success + total_failure) > 0 else "成功率:0%")
    print(f"平均响应时间:{avg_response_time:.2f} ms")
    print(f"QPS(每秒查询率):{qps:.2f}")
    print("=" * 80)
  • 核心说明:
    1. 压测前信息打印:输出压测配置参数,便于确认压测场景是否符合预期
    2. 线程创建与启动:
      • 循环创建指定数量的线程,每个线程绑定send_requests函数,并传入线程ID
      • thread.start()启动线程,所有线程同时开始执行请求发送逻辑
    3. thread.join():等待所有线程执行完成后,再进行统计结果计算,确保统计数据完整
    4. 核心指标计算:
      • total_duration:压测总耗时(从第一个线程启动到最后一个线程结束)
      • avg_response_time:成功请求的平均响应时间(仅统计成功请求,更能反映接口正常性能)
      • qps:每秒查询率(成功请求数/总耗时),衡量接口的并发处理能力
    5. 压测后汇总输出:以清晰格式输出核心统计指标,便于分析接口性能瓶颈
3.5 程序入口
if __name__ == "__main__":
    run_benchmark()
  • 核心说明:程序运行时,自动调用run_benchmark函数,启动完整压测流程

4. 使用指南

4.1 前置准备
  1. 安装依赖:pip install requests
  2. 确保FastAPI用户管理接口服务已正常启动(http://localhost:8000/api/shop/users可正常访问并返回数据)
  3. 根据实际测试需求,修改压测配置项(如调整并发线程数、单线程请求数)
4.2 启动压测
  1. 将代码保存为api_benchmark.py
  2. 运行命令:python api_benchmark.py
  3. 压测启动标志:控制台输出压测配置信息,随后开始实时打印单个请求的执行结果
4.3 压测结果解读
指标名称指标含义解读要点
总耗时整个压测流程的持续时间反映完成所有请求所需的时间,结合总请求数可初步判断接口处理效率
成功请求数/失败请求数压测过程中成功/失败的请求总量失败请求数>0时,需排查接口是否存在性能瓶颈或稳定性问题
成功率成功请求数占总请求数的比例理想状态下成功率应为100%,若低于99%,需重点分析失败原因
平均响应时间所有成功请求的响应时间平均值反映接口的平均处理速度,数值越低,接口性能越好
QPS(每秒查询率)每秒能处理的成功请求数衡量接口并发处理能力的核心指标,数值越高,接口的高并发支撑能力越强

5. 优化建议与注意事项

5.1 压测配置优化建议
  1. 逐步提升并发量:从低并发(如5线程)开始,逐步增加到高并发(如50、100线程),避免一次性高并发压垮服务器
  2. 控制单线程请求数:单线程请求数建议设置为50-200,过多可能导致单个线程运行时间过长,影响压测效率
  3. 合理设置超时时间:根据接口正常响应时间调整TIMEOUT(如接口正常响应时间<1秒,可设置为5秒),避免超时时间过长导致压测结果失真
5.2 线程安全注意事项
  1. 全局变量修改必须加锁:total_success、total_failure、response_times为全局变量,多线程修改时必须通过with lock保证线程安全,否则会出现统计数据错误
  2. 每个线程独立创建requests.Session:避免多个线程共享一个Session对象,导致请求冲突或连接泄露
5.3 压测环境注意事项
  1. 压测环境与生产环境尽量一致:确保硬件配置、MySQL配置、服务部署方式与生产环境一致,压测结果才具有参考价值
  2. 避免在生产环境直接压测:压测会占用大量服务器资源,可能影响生产业务正常运行,建议在测试环境进行压测
  3. 压测前备份数据库:高并发压测可能导致数据库负载过高,甚至出现数据异常,压测前建议备份shop数据库
5.4 功能扩展建议
  1. 支持POST接口压测:添加请求体配置项,修改session.get为session.post,支持对插入接口进行压测
  2. 增加响应数据校验:校验接口返回数据的格式和内容,避免接口返回200但数据异常的情况
  3. 生成压测报告:将压测结果保存为CSV/HTML文件,便于后续分析和归档
  4. 支持自定义请求头:添加请求头配置项,支持携带认证信息、Content-Type等自定义请求头

第三部分:两份代码的联动说明与整体总结

1. 联动流程

  1. 启动FastAPI用户管理接口服务,确保GET /api/shop/users接口可正常访问
  2. 配置压测工具的TARGET_URL与FastAPI接口地址一致
  3. 启动压测工具,模拟多线程并发请求,对接口进行性能测试
  4. 查看压测结果,分析接口成功率、响应时间、QPS等指标
  5. 根据压测结果优化FastAPI服务(如调整连接池配置、优化SQL、开启多进程运行)

2. 整体总结

  1. 两份代码实现了「后端服务搭建」与「接口性能压测」的完整闭环,便于快速验证用户管理接口的功能和性能
  2. FastAPI接口服务具备高可用性、安全性、可扩展性,支持后续功能扩展(如用户更新、删除、分页查询)
  3. 多线程压测工具轻量易用、配置灵活,可快速适配不同接口的压测需求,为接口性能优化提供数据支撑
  4. 核心亮点:
    • 后端服务:连接池复用、参数校验、事务保障、防SQL注入,确保服务稳定安全
    • 压测工具:线程安全、实时监控、核心指标统计,确保压测结果准确可靠
  5. 后续优化方向:
    • 后端:采用异步数据库驱动(asyncmy),提升接口并发处理能力;添加日志模块,便于问题排查
    • 压测工具:支持分布式压测、自定义压测场景,提升压测的覆盖度和专业性
大模型性能压测利器 locust 实战 (FastAPI) 本文介绍了使用Locust进行性能测试的方法,并对比了服务端不同实现方式的性能表现。首先通过pip install locust安装工具,然后编写Python脚本分别实现服务端和客户端代码。服务端提供了三种接口实现:阻塞调用、多进程调用和异步非阻塞调用。测试结果显示:单线程阻塞调用约10 QPS;5进程池实现约50 QPS;而异步非阻塞调用可达1500 QPS,与直接返回结果相当。关键差异在于阻塞机制:time.sleep(0.1)会阻塞整个事件循环,而await asyncio.sleep(0.1)仅挂起 阅读详情

相关推荐

FastAPI与Locust接口压测实战:从场景设计到瓶颈分析与优化

接口压测是保障Web服务稳定性和性能的核心工程实践。其原理在于通过模拟真实用户并发请求,对系统施加可控压力,从而评估其在高负载下的表现,识别性能瓶颈。这项技术的核心价值在于,它能将性能问题暴露在开发或预发阶段,避免线上故障,并为容量规划提供数据支撑。典型的应用场景包括新服务上线前的性能验证、大促活动前的容量评估,以及日常迭代中的性能回归测试。本文将以Python生态中广泛使用的FastAPI框架和Locust压测工具为例,通过构建一个包含缓存、数据库查询和CPU计算等典型操作的Web服务,手把手演示如何设计

weixin_42526166的博客 358

Sanic vs Flask vs FastAPI:Python 三大 Web 框架谁才是王者?

测试实例就用一个简单的json返回进行压测:Sanic测试程序如下: Sanic测试数据如下: Flask的测试代码如下: Flask的测试结果如下: FastAPI的测试程序如下: 请用如下命令启动: fastapi dev fastapitest.py fastAPI的测试数据如下: 谁才是王者? Sanic的QPS:72105.18Flask的QPS:1635.05FastAPI的QPS:4849.82Sanic完美胜出。Sanic:适合高性能API开发,尤其是高并

计算机编程痴迷者的乐园 616

FastAPI + Locust 接口压测实战:从搭建到瓶颈排查

接口性能是系统稳定性的根基,而压测是在流量高峰来临前发现系统短板的关键手段。真正的压测不是简单发大量请求,而是通过可控并发压力量化吞吐量、响应时间、错误率和资源消耗,从而定位系统容量拐点。在Python技术栈中,FastAPI作为高性能异步Web框架,常被用作贴近真实业务的目标服务;Locust则基于协程实现轻量级压测,支持用代码编写复杂用户行为模型,相比传统工具更易维护和扩展。二者结合能快速搭建从接口开发、压测执行到报告解读的完整闭环。通过观察RPS、P99、失败率等核心指标,可以精准识别同步阻塞、数据库

weixin_32228501的博客 209

从Flask到FastAPI的并发迁移实战:同步与异步模型对比

同步阻塞与异步IO是Python Web框架应对并发的两种底层模型。传统WSGI框架如Flask,基于同步worker,一个请求占用一个进程直到处理完毕,在数据库查询或外部API调用等IO等待时,worker空转导致吞吐量受限。而FastAPI基于ASGI规范与事件循环,通过async/await协程调度,在IO等待时自动切换任务,显著提升高并发场景下的资源利用率。理解这两种模型的差异,是进行框架选型与性能调优的基础。在实际工程中,Flask可通过gevent补丁或增加worker数缓解瓶颈,FastAPI

weixin_31292729的博客 222

Python Web框架之FastAPI简单实例

简介 引用FastAPI官网:“FastAPI 是一个用于构建 API 的现代、快速(高性能)的 web 框架,使用 Python 3.6+ 并基于标准的 Python 类型提示。” 官网地址:https://fastapi.tiangolo.com/zh/ 依赖 Python 3.6 及更高版本 安装 pip install fastapi pip install uvicorn 示例 示例可查看官网示例,这里不多赘述。以下示例主要展示FastAPI结合sqlite完成增删改查。废话不多

wl_Honest的博客 4463

FastAPI WebSocket性能对比测试:用Uvicorn压测1000并发下的AI接口响应

本文通过搭建接近生产环境的测试平台,对FastAPI框架下的WebSocket接口与HTTP接口进行了1000并发下的深度性能对比测试。测试结果表明,在实时AI对话等持续交互场景中,WebSocket在吞吐量、延迟和网络效率方面均显著优于HTTP,为AI应用的高性能接口选型与优化提供了数据支撑和实战指南。

weixin_28323057的博客 641

flask,tornado,fastapi 压测比较(web框架)

flask,tornado,fastapi三个都是web框架,前两者都十分流行,后者是一个新框架。 做压测的原因是因为听说fastapi 性能极高,想看看跟其他框架差别多大。 flask是一个轻应用框架,简单好用易扩展。 tornado 是一个非阻塞的异步框架,性能高,并发高。 fastapi是一个入门简单,性能高的框架,据说可比node 和go,仅支持 python3.6及以上 ...

socct_yj的博客 1万+

fastapi 大型应用_FastApi项目实战 - 爱投票管理系统(一)

一、闲来无事,在工作之余自己研究了一下python的异步框架 - fastapi,并写包括1、部门管理2、角色管理3、用户管理4、菜单管理5、登录日志6、操作日志7、添加反爬机制六个基础功能模块,演示链接:https://www.lovevote.cn, 账号:admin,密码:admin由于我的电脑问题,下载的vue依赖包有几个发生了版本冲突,打包部署后偶尔会在点击菜单按钮时发生前端延时(这时表...

weixin_35880510的博客 3072

第25章:FastAPI性能压测与瓶颈定位

摘要 电商大促前性能压测项目面临核心挑战:订单接口需从200 QPS提升至2000 QPS,但初步压测显示系统在500并发时错误率达2.3%,1000并发时P99延迟高达8000ms。项目采用k6压测工具结合四层分析法(Nginx层、应用层、数据库层、代码层)进行科学瓶颈定位,通过阶梯式加压测试和Prometheus、py-spy等监控工具,识别出数据库连接池阻塞、Python GIL限制等关键性能瓶颈。解决方案包括优化数据库连接池配置、重构同步阻塞代码为异步模式,最终使系统成功达到目标性能指标。

davidwang456的专栏 385

FastAPI与Flask性能压测对比:异步框架为何在某些场景下不敌同步框架?

在Web开发领域,性能优化是开发者持续关注的核心议题。从技术原理层面看,异步编程通过事件循环和非阻塞I/O操作,旨在提升高并发场景下的资源利用率,其技术价值在于能够更高效地处理I/O密集型任务。而同步编程模型则依赖于多进程或多线程来处理并发请求。在实际工程实践中,框架的性能表现受到服务器配置、工作器类型、操作系统限制以及应用代码质量的综合影响。例如,通过调整Uvicorn的worker数量或Gunicorn的worker连接数,可以显著优化吞吐量。应用场景方面,异步框架如FastAPI适合处理大量并发连接和

weixin_30527423的博客 355

Python异步框架大战:FastAPI、Sanic、Tornado VS Go 的 Gin

异步编程在构建高性能 Web 应用中起着关键作用,而 FastAPI、Sanic、Tornado 都声称具有卓越的性能。本文将通过性能压测对这些框架与Go的Gin框架进行全面对比,揭示它们之间的差异。

qq_43629857的博客 5435

python接口压测1000并发_Flask、Django、Tornado、FastAPI 之 Python Web 并发测试

目前Python Web生态圈中涌现出许许多多优秀的Web框架,投入生产最多的要属Flask和Django,Tornado有别于上述两种框架,它是Python界的一大异步网络框架,可以支撑上万级的连接,FastAPI则是这几个框架中的一个新秀,它是一款集成了Swagger文档的高性能Web框架。对于这四种不同的Python Web框架,各有特点,一般适用于不同的业务场景。为了进一步了解他们的并发性...

weixin_39581845的博客 853

最全中文停用词表(可直接复制)

最全的停用此表整理 词表名 词表文件 中文停用词表 cn_stopwords.txt 哈工大停用词表 hit_stopwords.txt 百度停用词表 baidu_stopwords.txt 机器智能实验室停用词库 scu_stopwords.txt 以上停用词表链接:https://github.com/goto456/stopwords 以下是我常用的1893个停用词,可直接复制 ! " # $ % & ' ( ) * + , - -- . .. ... ....

dilifish的博客 12万+

FastAPI开启HTTP/3后吞吐量翻倍?真实压测对比报告首次公开

掌握FastAPI的HTTP/3配置,显著提升API性能。本文详述在高并发场景下的配置方法与压测结果,对比HTTP/1.1吞吐量翻倍,延迟降低40%。涵盖部署要点与兼容性处理,真实数据验证性能飞跃,值得收藏。

SimProceed的博客 822

pytorch图像分类篇: 花分类数据集下载和AlexNet网络搭建训练

一、花分类数据集下载 data_setdata_set该文件夹是用来存放训练数据的目录 使用步骤如下: (1)在data_set文件夹下创建新文件夹"flower_data" (2)点击链接下载花分类数据集 (3)解压数据集到flower_data文件夹下 (4)执行"flower_data.py"脚本自动将数据集划分成训练集train和验证集val ├── flower_data ├── flower_photos(解压的数据集文件夹,3670个样本) ...

橙子的博客 8219

手把手教你用OPA运放和MOS管搭建恒流源电路(附完整电路图)

本文详细介绍了如何使用OPA运放和MOS管搭建高精度恒流源电路,涵盖核心元器件选型、电路设计、工作原理及实际搭建步骤。通过负反馈控制机制和MOS管工作区设置技巧,实现稳定的电流输出,适用于LED驱动、电池充电等场景。附完整电路图和调试技巧,助您快速掌握恒流源设计。

weixin_29239279的博客 542

从 0 到 1:一次完整可落地的接口压测实战(FastAPI + Locust)

本文介绍了使用FastAPI搭建本地可压测接口服务,并通过Locust进行性能测试的完整流程。主要内容包括: 环境准备:创建虚拟环境并安装FastAPI、Locust等依赖 接口开发:实现包含登录获取token、订单列表和详情查询的示例API 压测脚本:编写Locust测试脚本,模拟用户登录后带token请求业务接口 测试执行:通过Locust Web界面进行阶梯加压测试(50→100→200→400并发)和稳定性测试 结果分析:关注P95/P99响应时间、RPS和失败率等关键指标 该方案提供了一套完整的W

m0_57021623的博客 1082

GD32F303驱动WS2812B灯带:用TIMER+PWM+DMA解放CPU,实现流畅灯效(附完整代码)

本文详细介绍了基于GD32F303的TIMER+PWM+DMA全自动控制方案,用于高效驱动WS2812B灯带。通过硬件外设协同工作,该方案不仅解放了CPU资源,还能实现复杂的灯光效果,如渐变、流水等。文章提供了完整的代码实现和性能优化技巧,适合嵌入式开发者参考。

weixin_42561143的博客 382

Flask vs FastAPI:TTS服务接口性能压测结果公布

评估维度 | 推荐选择 |追求极致性能与并发快速原型验证| ⚖️ Flask(简单) / FastAPI(规范) |团队熟悉异步编程已有成熟 Flask 生态| ⚠️ 暂留 Flask,逐步迁移 |需自动生成 API 文档纯内网低频调用服务| ✅ Flask 仍适用 |🎯 最终结论对于TTS、ASR、LLM 等长耗时 AI 服务FastAPI 是更优的技术选型。它不仅能显著提升 QPS、降低延迟,还能通过类型系统增强接口可靠性,加速前后端协作。

weixin_34456923的博客 928

ADF4002分频器避坑指南:常见配置错误及解决方案

本文深入解析了ADF4002分频器在实战应用中的常见陷阱与解决方案。内容涵盖寄存器配置逻辑、硬件PCB布局要点、软件驱动时序细节及系统化调试方法,重点阐述了如何避免因配置错误导致芯片无法正常工作的问题,帮助工程师高效完成高精度频率合成系统设计。

weixin_29192141的博客 98

3、深入了解响应式扩展(Reactive Extensions)

本文深入探讨了响应式扩展(Reactive Extensions,Rx)的起源、核心概念及其在客户端和服务器端的应用。从Volta项目谈起,解析了Rx如何解决事件传输问题,并介绍了可观察对象(IObservable)和观察者(IObserver)的设计与实现机制。文章还详细讲解了Rx操作符、弹珠图的使用、拉模型与推模型的对偶性原理,并通过代码示例展示了如何将枚举转换为可观察对象。最后总结了Rx的优势,并展望其在未来软件开发中的广泛应用前景。

m2n3b4v5c6的博客 113

Locust + FastAPI 接口压测实战:从脚本到性能调优

接口性能测试是系统稳定性保障的关键手段。通过模拟真实用户并发访问,可以提前暴露资源瓶颈与容量短板。压测工具众多,Locust凭借Python协程模型和流程编排能力,在Web服务压测中优势显著。本文以FastAPI接口服务为例,从搭建被测服务、设计压测脚本、分析核心指标到定位性能瓶颈,完整演示一套可复现的压测闭环。重点讲解容量评估方法、响应时间百分位解读、连接池与异步化优化,并分享数据污染、超时配置等实际踩坑经验。无论后端开发、测试还是运维,都能据此建立自己的性能基准。

weixin_42546508的博客 83

解锁RK3588:内核模块签名与安全启动配置全攻略

RK3588作为一款高性能嵌入式SoC芯片,其内核模块签名与安全启动配置是保障系统安全的核心机制。本文详细介绍了RK3588的芯片特性,重点阐述了安全启动的硬件信任链原理和内核模块签名的实现方法。通过具体步骤演示了从密钥生成、模块签名到验证加载的完整流程,并深入解析了安全启动配置的硬件连接、软件工具准备、密钥烧录等关键环节。此外,还提出了防御旁路攻击和动态信任链扩展等高级安全策略,为RK3588在工业控制、智能安防等高安全要求场景中的应用提供了全面的安全解决方案。

远程部署调试 运行安装 项目调试 二次开发 项目技术新 持续迭代 部分源码免费分享 351

Python异步框架深度对比(Sanic vs FastAPI性能压测大揭秘)

解决高并发Web开发选型难题,本文深入剖析Python异步Web框架Sanic vs FastAPI性能差异,涵盖基准压测、路由设计、类型提示与部署优化。对比适用场景与开发效率,助你精准选择技术栈,值得收藏。

VarLens的博客 1106

国科大学习资料--人工智能原理与算法-2021年期末考试题解析(学长整理)

国科大学习资料–人工智能原理与算法-2021年期末考试题解析(学长整理) 国科大学习资料–人工智能原理与算法-2021年期末考试题解析(学长整理) 国科大学习资料–人工智能原理与算法-2021年期末考试题解析(学长整理) 根据学弟的反馈,该年的期末题只有5道,且均是作业题(所以大家一定要积极完成作业,考前多做几遍!!!!) 下面解析: 3.25 由于该题,我没有做过,所以只能给你英文版的答案。答案如下,其他的题目答案都是中文版。 5.9 8.10 12.20 15.13 ...

无名何许人的博客 3984

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

k6云原生压测Sonic API网关性能瓶颈

通过k6对Sonic API网关进行云原生压测,发现性能瓶颈不在GPU推理层,而在于Nginx缓冲区和连接池配置。结合参数敏感性与架构优化,实现高并发下稳定服务,验证AI系统稳定性需全链路工程治理。

weixin_29215509的博客 792

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

上一篇: SQL注入
下一篇: async 和 await 详细解析
越甲八千
博客等级 码龄11年 2961粉丝 553原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值