Python类型检查避坑指南:mypy+typing最佳实践

Python学习之-typing详解 Python的typing模块自Python 3.5开始引入,提供了类型系统的扩展,能够帮助程序员定义变量、函数的参数和返回值类型等。这使得代码更易于理解和检查,也方便了IDE和一些工具进行类型检查,提升了代码的质量。typing 模块是 Python 标准库中用于支持类型提示的模块。它提供了一系列的类型和类型相关的工具,帮助开发者在代码中添加类型提示,以提高代码的可读性和可靠性。"""# @File :"""print(stack.pop()) # 输出1。 阅读详情

Python类型检查避坑指南:mypy+typing最佳实践

最近在重构一个中型Python项目时,我遇到了一个典型问题:代码库逐渐膨胀,不同模块间的接口调用越来越频繁,一个看似简单的函数参数类型不匹配,竟然导致了线上服务间歇性报错。调试过程像在迷宫里打转,耗费了大半天时间。这件事让我下定决心,必须把项目的类型检查体系彻底规范起来。对于已经初步接触过typing模块,但在实际项目中踩过坑、或者希望提升团队代码质量的开发者来说,仅仅知道List[int]和Optional[str]的写法是远远不够的。真正的挑战在于如何让类型提示(Type Hints)与强大的静态类型检查工具mypy协同工作,规避那些隐蔽的陷阱,从而让类型系统从“装饰品”变为“安全网”。

这篇文章不会重复typing模块的基础语法,而是聚焦于实战。我们将深入探讨在项目迁移、团队协作、库开发等真实场景中,如何结合mypy制定高效的类型检查策略,解决诸如泛型方差、循环导入、第三方库存根(stub)处理、以及性能与严格性平衡等高级问题。目标是让你不仅能写出带类型提示的代码,更能写出能让mypy“心悦诚服”、真正提升工程效率的代码。

1. 超越基础:构建稳健的mypy检查环境

很多团队在引入mypy时,往往直接在命令行运行mypy .,然后被海量的错误信息淹没,最终不了了之。一个成功的类型检查实践,始于一个精心配置的检查环境。

1.1 项目级配置:mypy.ini的学问

mypy的强大之处在于其高度可配置性。在项目根目录创建一个mypy.ini(或pyproject.toml的[tool.mypy]部分)是第一步。这个配置文件的核心是平衡严格性与实用性。一个激进的全严格模式可能让项目寸步难行,而一个过于宽松的配置又失去了检查的意义。

下面是一个适用于中型项目、鼓励渐进式迁移的配置示例:

[mypy]
python_version = 3.9
warn_return_any = True
warn_unused_configs = True
disallow_untyped_defs = False
disallow_incomplete_defs = True
check_untyped_defs = True
disallow_untyped_decorators = False
no_implicit_optional = True
warn_redundant_casts = True
warn_unused_ignores = True

注意:disallow_untyped_defs = False是一个关键折衷。它允许项目中暂时存在无类型注解的函数,为逐步迁移留出空间,但同时开启check_untyped_defs = True,让mypy仍能对函数内部代码进行一定程度的推理检查。

对于大型项目,可以采用模块级差异化配置。例如,对核心业务模块施加最严格的检查,而对一些遗留代码或实验性模块则放宽要求。

[mypy-my_project.core.*]
disallow_untyped_defs = True
disallow_any_generics = True

[mypy-my_project.legacy.*]
ignore_errors = True  # 暂时完全忽略,待后续重构

[mypy-my_project.experimental.*]
disallow_untyped_defs = False

1.2 依赖与存根(Stubs)管理:填补第三方库的空白

使用mypy检查项目时,最常遇到的障碍之一是第三方库缺乏类型提示。mypy会将这些库中的对象视为Any类型,导致类型信息链断裂。解决方案是使用类型存根(Type Stubs)。

1. 优先使用官方或社区维护的存根包:许多流行库在PyPI上提供了-stubs后缀的包,例如types-requests、types-pyyaml。你可以通过pip install types-requests来安装,mypy会自动识别它们。

2. 为内部或暂无存根的库创建自定义存根:在项目内建立一个stubs/目录,并在mypy.ini中配置路径:

[mypy]
mypy_path = stubs

假设你内部使用了一个名为internal_lib的库,你可以在stubs/internal_lib/__init__.pyi中为其编写存根。.pyi文件只包含类型声明,不包含实现。

# stubs/internal_lib/__init__.pyi
def fetch_data(api_endpoint: str) -> dict[str, object]: ...
class ConfigManager:
    timeout: int
    def get_setting(self, key: str) -> str | None: ...

3. 谨慎使用ignore_missing_imports:在配置中为特定模块设置ignore_missing_imports = True可以快速消除错误,但这会完全放弃对该模块的类型检查。应将其作为临时手段,而非长期方案。

2. 攻克高级类型陷阱:从知道到精通

掌握了环境配置,我们直面代码中的复杂情况。以下是一些容易出错但至关重要的高级主题。

2.1 泛型方差(Variance)的微妙之处

当你定义自己的泛型类时,mypy对类型替换的规则由型变(Variance) 控制。理解TypeVar的参数covariant和contravariant是避免深层类型错误的关键。

  • 不变(Invariant):默认情况。Container[SubType]不是Container[SuperType]的子类型,反之亦然。这适用于大多数可变容器。
  • 协变(Covariant):如果SubType是SuperType的子类型,那么Container[SubType]也是Container[SuperType]的子类型。这适用于“只读”或“产出”场景,例如Iterator。
  • 逆变(Contravariant):与协变相反。如果SubType是SuperType的子类型,那么Container[SuperType]是Container[SubType]的子类型。这适用于“只写”或“消费”场景,例如Callable的参数。

考虑一个自定义的只读数据加载器:

from typing import TypeVar, Generic

T_co = TypeVar("T_co", covariant=True)  # 协变类型变量

class DataLoader(Generic[T_co]):
    def __init__(self, source: str) -> None:
        self.source = source
    def load(self) -> T_co:  # 方法返回协变类型
        ... # 实现省略

class Animal: ...
class Dog(Animal): ...

def process_animal(loader: DataLoader[Animal]) -> Animal:
    return loader.load()

dog_loader: DataLoader[Dog] = DataLoader("dogs.json")
# 由于DataLoader是协变的,DataLoader[Dog]可视为DataLoader[Animal]的子类型
# 因此下面这行类型检查通过,这是安全且符合直觉的。
result: Animal = process_animal(dog_loader)

如果这里将T_co定义为默认的不变类型,mypy就会报错,因为DataLoader[Dog]无法赋值给DataLoader[Animal]。理解方差能帮助你设计出类型更安全、更灵活的泛型API。

2.2 循环导入与TYPE_CHECKING常量

在添加类型提示时,模块间的循环导入是一个常见难题。例如,class A的方法需要返回class B,而class B又需要引用class A。解决方法是用typing模块中的TYPE_CHECKING常量和字符串字面量。

# model_a.py
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    # 仅在类型检查时导入,运行时不会执行,从而打破循环依赖
    from .model_b import B

class A:
    def get_partner(self) -> "B | None":  # 使用字符串前向引用
        ...

# model_b.py
from typing import TYPE_CHECKING
from .model_a import A  # 这里可以正常导入,因为A已经定义

class B:
    def __init__(self, owner: A) -> None:  # 这里使用真实的A类
        self.owner = owner

mypy能够理解字符串形式的类型注解(如"B"),并在检查时解析它。从Python 3.7开始,你可以使用from __future__ import annotations来让所有注解在运行时都自动变成字符串,从而彻底避免因注解导致的运行时导入问题。

2.3 Any与object:知道何时说“不”

Any是类型系统的“逃生舱口”,它关闭了mypy的所有检查。滥用Any会让类型提示形同虚设。一个更安全的选择是使用object。object是所有类的基类,但mypy会对它进行保守检查。

类型含义mypy检查典型用法
Any动态类型,任意操作都允许完全无检查与无类型旧代码交互,或确实无法确定类型时
object任何Python对象仅允许所有对象共有的操作(如str(obj)),不允许特定方法调用需要容纳任意类型但后续会进行类型判断(如isinstance)
from typing import Any

def dangerous_func(data: Any) -> None:
    data.some_method()  # mypy: 通过 (但运行时可能崩溃!)
    data + 10           # mypy: 通过

def safer_func(data: object) -> None:
    data.some_method()  # mypy: 错误!"object"没有属性"some_method"
    if isinstance(data, int):
        data + 10       # mypy: 通过,因为类型守卫缩小了类型范围

最佳实践是:将Any的使用视为“技术债务”,并在代码中标记出来,以便后续重构。

from typing import Any, cast

# 情况1:暂时无法标注的第三方库回调
callback: Callable[[Any], Any]  # TODO: 细化参数和返回类型

# 情况2:在确信类型安全时进行强制转换
raw_data: object = get_data()
# 我们通过代码逻辑确信它是字典
data = cast(dict[str, int], raw_data)  # 告诉mypy:相信我,它是这个类型

3. 团队协作与CI集成:让类型检查成为习惯

个人实践固然重要,但在团队中推行类型检查需要流程和工具的支持。

3.1 制定团队类型注解规范

一份简单的团队规范能极大减少分歧。规范可以包括:

  • 强制与推荐:哪些场景必须加类型注解(如公共API、接口),哪些场景推荐加。
  • Any使用审批:任何添加新Any的地方是否需要同行评审。
  • 存根维护责任:谁负责为团队共用的内部库维护类型存根。
  • 代码风格:统一使用Optional[T]还是T | None(Python 3.10+),是否使用from __future__ import annotations。

3.2 将mypy集成到CI/CD流水线

自动化检查是保证规范落地的关键。在Git仓库的预提交钩子(pre-commit)和持续集成(CI)中集成mypy。

使用pre-commit钩子:创建.pre-commit-config.yaml文件,在每次提交前自动运行检查,防止有类型错误的代码进入仓库。

repos:
  - repo: https://github.com/pre-commit/mirrors-mypy
    rev: v1.10.0  # 使用具体的mypy版本
    hooks:
      - id: mypy
        # 可以指定额外的参数或配置文件
        args: [--config-file=./mypy.ini]
        # 只检查已暂存的文件,提高速度
        stages: [commit]

在CI中运行:在GitHub Actions、GitLab CI等配置中增加一个mypy检查步骤。

# .github/workflows/ci.yml 示例片段
jobs:
  type-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.9'
      - run: pip install mypy types-requests  # 安装mypy和必要的存根
      - run: mypy . --config-file mypy.ini

3.3 处理遗留代码:渐进式迁移策略

面对一个庞大的无类型代码库,全部一次性添加类型提示是不现实的。一个有效的策略是**“由外及内,由新到旧”**。

  1. 从边界开始:先为最外层的API接口(如Web框架的视图函数、CLI命令入口)添加完整的类型注解。这能最快地建立起类型检查的边界。
  2. 新代码零容忍:在团队规范中规定,所有新增的代码文件和函数必须带有完整的类型提示。
  3. 在修改时改进:当开发者需要修改或重构某个旧函数时,要求他同时为该函数及其直接调用链添加类型提示。这被称为“童子军规则”——离开时让代码比你来时更干净。
  4. 利用# type: ignore注释:对于暂时无法解决的复杂错误,可以使用行尾的# type: ignore[error-code]注释来精确地忽略特定错误,并附上TODO说明。
def legacy_complex_function(x):
    # TODO(#123): 重构此函数并添加类型提示
    result = some_untyped_operation(x)  # type: ignore[no-untyped-call]
    return result

4. 性能、调试与高级技巧

4.1 提升mypy检查速度

对于大型项目,mypy检查可能变得缓慢。以下方法可以提速:

  • 增量缓存:使用mypy --incremental或在mypy.ini中设置cache_dir = .mypy_cache。mypy会缓存已分析模块的结果,只重新检查更改过的部分。
  • 并行检查:使用mypy -j 4(或你的CPU核心数)进行并行检查。
  • 范围限定:在开发时,可以只检查正在修改的特定模块或目录,而不是整个项目。

4.2 解读与调试复杂的mypy错误信息

mypy的错误信息有时很冗长。学会解读它们是高效解决问题的关键。一个常见的复杂错误涉及泛型和不匹配的类型。

假设你遇到这样一个错误:

error: Argument 1 to "append_all" has incompatible type "List[Child]"; expected "List[Parent]"

这可能是因为你定义了一个函数def append_all(target: List[Parent], items: Iterable[Parent]),并尝试传入一个List[Child]作为items。由于List是不变的,List[Child]不能赋值给List[Parent],即使Child是Parent的子类。解决方案可能是:

  1. 修改函数签名,使用Iterable[Parent]接收参数,因为Iterable是协变的。
  2. 如果确定逻辑安全,使用cast(List[Parent], child_list)或# type: ignore(不推荐)。

4.3 探索typing_extensions和Python新版本特性

typing_extensions模块是获取最新类型提示特性的宝库,即使在较旧的Python版本中也能使用。例如:

  • TypedDict(Python 3.8引入):为字典提供结构化的类型提示。
  • Literal(Python 3.8引入):表示只能取特定值的类型。
  • Protocol(Python 3.8引入):我们之前提到的结构化子类型。
  • Self类型(Python 3.11引入,通过typing_extensions向后移植):用于注解返回实例自身类型的方法,在构建流畅接口或工厂方法时非常有用。
# 使用typing_extensions中的Self
from typing_extensions import Self

class Builder:
    def with_option(self, value: str) -> Self:
        self.some_option = value
        return self  # 返回self,类型精确地是Builder的子类型

class SubBuilder(Builder):
    def with_extra(self) -> Self:
        return self

builder = SubBuilder().with_option("test").with_extra()  # mypy能正确推断链式调用类型

将typing_extensions加入项目依赖,并鼓励团队成员探索和使用这些更精确的类型工具,可以极大地提升代码的表达能力和类型安全性。

类型检查不是Python编程的枷锁,而是一副经过精心调校的护甲。它可能会在开始时让你感觉有些束缚,但一旦适应,它就能在代码复杂度不断增长的过程中,为你抵御大量的低级错误,提升代码的可读性和可维护性。从我自己的经验来看,最大的回报不是运行mypy时没有错误,而是在几个月后回过头来修改代码,或者新同事接手模块时,类型注解所提供的清晰上下文所能节省的认知成本和沟通时间。不妨从下一个新功能模块开始,尝试应用本文中的一些配置和技巧,亲自体会这种差异。

Python类型注解 在Python中,类型注解是一种在变量、函数参数和函数返回值中指定类型的方法。类型注解不会影响程序的运行,但可以提供有关变量和函数预期类型的信息,可以帮助开发者更好地理解代码,并提供给IDE(集成开发环境)工具更好的代码补全和错误检查。类型注解可以用于函数参数和返回值,也可以用于变量。可以使用多种类型,如str、int、bool、list、dict等。类型注解还可以与特殊的类和类型提示库一起使用,以更详细地指定变量和参数的类型信息。 阅读详情

相关推荐

python高级用法之typing类型提示

typing是 Python 的一个标准库模块,用于支持类型提示(Type Hints)。类型提示允许你在代码中显式地声明变量、函数参数和返回值的类型,从而提高代码的可读性和可维护性。虽然 Python 是一种动态类型语言,但类型提示可以帮助开发人员更好地理解代码,并且可以被静态类型检查工具(如mypy)用来检查代码中的潜在错误。1.1. typing的优势优势提高代码可读性类型提示可以让其他开发者更快的理解你的代码,知道函数函数参数和返回值的类型。# 有类型提示# 业务逻辑提供更好的IDE支持。

weixin_42083481的博客 1417

Python类型注解必备利器:typing模块解读指南

typing模块为Python带来了类型提示和类型检查的能力。它允许开发者在代码中添加类型注解,提高代码的可读性和可维护性。尽管Python是一种动态类型语言,但类型注解能让开发者更清晰地了解函数和变量的预期类型。typing模块为Python添加了静态类型注解的能力,提高了代码的可读性和维护性。本文介绍了类型注解的基本概念、常见类型和高级类型,以及类型检查工具的使用。希望读者可以更好地应用类型注解,改善Python代码的质量。

2301_82000445的博客 7288

Python画好看的雷达图,全网开源代码最好看的

【代码】Python画好看的雷达图,全网开源代码最好看的。

大模型天花板 2286

Python 静态类型系统(typing、mypy、PEP 系列)详解总结

本文全面解析Python静态类型系统,从设计理念到实战应用。主要内容包括:1)typing模块详解 - 涵盖基础类型、泛型容器、Optional/Union、Protocol等高级类型;2)mypy工具 - 安装配置与严格检查模式;3)关键PEP提案 - 类型系统演进历程;4)实战示例 - 泛型类、TypedDict等最佳实践。通过类型注解提升代码可维护性,适用于大型项目开发与代码审查参考。

破烂PAN 的博客 1197

Python小白也能玩转迅投QMT量化交易?手把手教你从安装到第一个策略

本文为零基础Python用户提供了上手迅投QMT量化交易平台的完整指南。从Python 3.6环境配置、QMT客户端获取安装,到核心概念讲解,并手把手教你编写并回测一个经典的双均线交易策略,帮助初学者快速迈出量化交易的第一步。

weixin_29103191的博客 766

OpenRubrics:自动化评估工具优化LLM对齐效果

在大型语言模型(LLM)应用中,模型输出与人类价值观的对齐是关键挑战。传统人工反馈强化学习(RLHF)依赖大量标注,成本高且一致性差。OpenRubrics作为开源工具,通过结构化准则实现自动化评估,显著提升效率。其核心原理是将主观评价转化为可量化的多维指标,支持动态权重调整,并兼容主流RLHF框架。该工具在降低标注成本的同时,通过Fleiss' Kappa系数等指标保证评估一致性,适用于多语言和医疗等专业领域,为LLM对齐提供了工程化解决方案。

weixin_28730037的博客 360

如何快速掌握Python静态类型检查:MyPy的完整教程

Python作为动态类型语言,为开发者提供了极大的灵活性,但这种灵活性有时会带来难以发现的类型错误。MyPy正是为了解决这一问题而生的静态类型检查工具,它能帮助你在代码运行前发现潜在的类型问题,提升代码质量和可维护性。本文将通过六个步骤,带你从零开始掌握这个强大的工具。 ## 一、为什么Python开发者需要静态类型检查?🤔 在大型项目中,动态类型的Python代码经常会出现这样的问题:函数

gitblog_00242的博客 785

【第1章>第5节】SOM自组织映射网络的理论学习与MATLAB仿真

自组织映射网络(Self-Organizing Map,SOM)是一种无监督学习的人工神经网络,由芬兰学者Teuvo Kohonen于1981年提出,也被称为Kohonen网络。它的主要功能是将高维输入数据映射到低维(通常是二维)的离散网格上,同时保持输入数据的拓扑结构,即相邻的输入数据在映射后的网格上也相邻。

FPGA/MATLAB学习教程/源码/项目合作开发 404

初识Python模块typing、mypy类型注释

type notation 类型注释 PEP484作为核心,周边多个PEP构成的type hints矩阵,目前普及度并不高,上次看到相关应用还是cython加速,需要用到类型注解。 docstring是写给人看到,type hint更多是写给机器看的。 能够让IDE了解variable是什么类型,因此便于IDE进行自动补全。 在运行时会过滤掉类型信息。 谈到type就需要考虑到静态语言与动态语言孰优孰劣的问题。参见(英文原文,中文翻译),文中得出了静态语言比动态语言更好维护的结论,这也与referenc..

漫步量化 1032

【深度学习新浪潮】Token经济学深度解析:从AI“新智元”梗到产业核心,研究成果+标杆产品全拆解

在正式深入研究和产品分析前,必须先破除概念误区:行业内常说的Token经济学,并非单一概念,而是分为AI词元Token经济学和Web3通证Token经济学两大核心分支,二者底层逻辑、应用场景天差地别,也是大众最容易混淆的点。Token是AI时代的新大宗商品:黄仁勋将Token类比为工业时代的电力、石油,是AI时代的核心生产资料与基础计价单位,不再是单纯的技术单元,而是具备标准化、可计量、可交易、可分层的数字商品,其价值由算力消耗、推理效率、实际应用价值共同决定,而非虚拟炒作。Token五层定价模型。

专注:太空算力、AI infra、异构调度、大模型成本工程 686

反爬虫:POST 请求参数中 Sign 的加密机制详解,并设计带 Sign 校验的网站

本文介绍了API请求中sign签名的生成原理及实现方法。sign是通过对请求参数加密生成的一串字符串,用于验证请求合法性,防止参数篡改、重放攻击和伪造请求。其生成步骤包括参数排序、拼接字符串、加盐和哈希加密。文章还演示了如何在FastAPI后端实现带sign验证的新闻网站,包括参数校验、时间戳验证和签名比对等安全措施,有效提升API安全性,增加爬虫逆向难度。

数据知道的博客 4079

Python-类型检查:typing模块和mypy工具

文章链接: 文章链接:

u011079613的博客 856

python mypy类型检查_Python的类型标注与检查

Python作为一个动态类型语言,支持Subtyping和Duck Typing,一些Lint工具可以对Python代码静态进行类型检查来提高程序质量,还有工具可以支持类型标注和检查,并编译代码以提升性能。Python 3.5又引入了Type Hints机制来提供统一的类型标注协议。__class__ and isinstancePython中,判断一个对象是否是某个类的实例的做法:判断直接实例使...

weixin_39834984的博客 347

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Python类型提示实战:从基础到高级的typing模块完全指南

本文是Python typing模块的实战指南,从基础变量注解到高级泛型与协议应用,系统讲解了类型提示的语法、价值与最佳实践。通过具体代码示例,指导开发者利用类型提示提升代码可读性、可维护性,并借助mypy等工具实现静态检查,有效服务于团队协作与大型项目管理。

nept的博客 737

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

Python类型检查终极指南:MyPy如何提升代码质量与开发效率

MyPy是Python生态系统中最重要的静态类型检查工具,它为动态类型的Python语言带来了静态类型检查的强大能力。作为Python官方推荐的类型检查器,MyPy能够在你运行代码之前发现潜在的类型错误,大幅提升代码的可靠性和可维护性。在Python 3.5引入类型提示后,MyPy已成为现代Python开发的标配工具,帮助开发者编写更健壮、更易维护的代码。 ## 1. 项目亮点与核心价值:为什么

gitblog_00471的博客 674

深度学习工具包 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")

mypy 和 typing

合理利用 mypy + typing 让你的 python 代码更安全并且更易读

TwistedDemonwy的博客 670

Python Typing: 实战应用指南

Python Typing 是一种用于显式指定变量、函数参数和返回值类型的机制。这不仅可以帮助开发者写出更易于理解和维护的代码,还能通过类型检查工具(如 MyPy)捕获潜在的错误。在这个例子中,函数接收一个整型列表,并返回一个整型值。通过类型注解和typing模块,你可以让代码更具可读性和安全性,同时通过静态检查工具(如 MyPy)减少运行时错误。在团队协作中,类型注解还能让新成员快速理解代码逻辑。希望本篇文章能帮助你在实际项目中充分利用 Python Typing 的强大功能!

爱死亡机器人 2047

【Python】typing 模块:支持类型注解(Type Hints)和类型检查

typing 模块是 Python 的类型注解支持库,用于提供静态类型提示(type hinting),增强代码的可读性、可维护性和开发工具的静态检查能力。从 Python 3.5 开始引入,后续版本不断扩展,Python 3.9+ 支持更多简化语法。基本类型 int, str, bool,列表 List[int] / list[str],字典 Dict[str, int],元组 Tuple[str, int],可选值(含 None) Optional[str],联合类型 Union[int, float]

彬彬侠的博客 1657

python——typing 库

Python 的typing库提供了丰富的类型注解支持,使得开发者可以在代码中明确表示函数参数和返回值的类型。这对于代码理解和维护、IDE 自动补全、静态类型检查工具(如mypy)等都有极大的帮助。以下是一些typing。

pumpkin84514的博客 1800

如何用 douyin-downloader 批量下载抖音无水印视频

douyin-downloader 是一款开源的抖音批量下载工具,提供 Python 命令行版和 Douzy 桌面版两种形态,支持无水印抓取博主主页作品、喜欢、合集与音乐,面向想批量保存并整理抖音内容的用户。它解决的核心问题是:手工逐个保存作品效率低、文件散落难管理、网络波动时容易中断。 ## 📌 谁适合用抖音批量下载工具 - **整理博主作品集**:你关注了一位创作者,想把 TA 主页的所

gitblog_01057的博客 366
上一篇: 从CT切片到3D模型:5步搞定VTK体渲染可视化(避坑指南)
下一篇: Cadence Sigrity SPEED2000串扰仿真全流程:从BRD文件导入到结果分析的保姆级教程
php55
博客等级 码龄15年 51粉丝 1553原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值