DW-Numpy_数据类型和数组重建

纯NumPy手写神经网络:重建深度学习直觉的实践指南 神经网络本质是张量运算与链式法则的工程实现,其核心原理植根于线性代数、微积分和数值计算。理解前向传播的形状演化、反向传播的梯度维度对齐、以及Softmax-CrossEntropy联合优化的数值稳定性,是突破框架黑箱、掌握模型行为的关键。NumPy作为轻量级数值计算基石,天然支持手动推导每一步矩阵乘法、广播机制与内存布局,使开发者能精准控制权重初始化(如He/Xavier)、bias形状对齐、梯度累加逻辑等底层细节。这种‘可触摸’的实现方式,不仅服务于算法岗面试准备与教学验证,更在边缘部署、嵌入式AI及ON 阅读详情

常量

  • numpy.nan:表示空值。两个numpy.nan是不相等的
  • numpy.isnan(x, *args, **kwargs) 返回布尔数组True/False Test element-wise for NaN and return result as a boolean array.
  • numpy.inf:表示正无穷大。
  • numpy.pi: 表示圆周率
  • numpy.e:表示自然常数

数据类型

常见数据类型

为了加以区分 numpy 在这些类型名称末尾都加了“_”。下表列举了常用 numpy 基本类型。

类型备注说明
bool_ = bool88位布尔类型
int8 = byte8位整型
int16 = short16位整型
int32 = intc32位整型
int_ = int64 = long = int0 = intp64位整型
uint8 = ubyte8位无符号整型
uint16 = ushort16位无符号整型
uint32 = uintc32位无符号整型
uint64 = uintp = uint0 = uint64位无符号整型
float16 = half16位浮点型
float32 = single32位浮点型
float_ = float64 = double64位浮点型
str_ = unicode_ = str0 = unicodeUnicode 字符串
datetime64日期时间类型
timedelta64表示两个时间之间的间隔

创建数据类型

numpy 的数值类型实际上是 dtype 对象的实例。

每个内建类型都有一个唯一定义它的字符代码,如下:

字符对应类型备注
bboolean‘b1’
isigned integer‘i1’(type:int8 itemsize:1), ‘i2’(int16 2), ‘i4’(32 4), ‘i8’
uunsigned integer‘u1’, ‘u2’ ,‘u4’ ,‘u8’(同上)
ffloating-point‘f2’(16 2), ‘f4’, ‘f8’
ccomplex floating-point
mtimedelta64表示两个时间之间的间隔
Mdatetime64日期时间类型
Oobject
S(byte-)stringS3(bytes_)表示长度为3的字符串
UUnicodeUnicode (U3:dtype:str_,itemsize:12)字符串
Vvoid

数据类型信息

Python 的浮点数通常是64位浮点数,几乎等同于 np.float64。

NumPy和Python整数类型的行为在整数溢出方面存在显着差异,与 NumPy 不同,Python 的int 是灵活的。这意味着Python整数可以扩展以容纳任何整数并且不会溢出。

Machine limits for integer types.

ii16 = np.iinfo(np.int16)
print(ii16.min)  # -32768
print(ii16.max)  # 32767

Machine limits for floating point types.

ff16 = np.finfo(np.float16)
print(ff16.bits)  # 16
print(ff16.min)  # -65500.0
print(ff16.max)  # 65500.0
print(ff16.eps)  # 0.000977 #表示浮点相对精度 取非负的最小值


#具体作用和应用
eps = np.finfo(height.dtype).eps
height = np.maximum(height, eps)

dy = (base_ctr_y - ctr_y) / height
dh = xp.log(base_height / height)
dw = xp.log(base_width / width

这里可以看到有除法,我们要考虑到除法的分母是不能为0的,而且式子中log内也不能为负数,不然会直接跳出显示错误。

代码中是用上半部分来处理的,eps开始的三行将可能出现的负数和零,使用eps来替换,这样就不会出现错误了。

finfo函数是根据height.dtype类型来获得信息,获得符合这个类型的float型,eps是取非负的最小值。

时间日期和时间增量

datetime64 基础

在 numpy 中,我们很方便的将字符串转换成时间日期类型 datetime64(datetime 已被 python 包含的日期时间库所占用)。
1秒 = 1000 毫秒

  • 从字符串创建 datetime64 类型时,默认情况下,numpy 会根据字符串自动选择对应的单位,也可以强制指定使用的单位。
a = np.datetime64('2020-03', 'D')
  • 从字符串创建 datetime64 数组时,如果单位不统一,则一律转化成其中最小的单位。
a = np.array(['2020-03', '2020-03-08', '2020-03-08 20:00'], dtype='datetime64')
print(a, a.dtype)
# ['2020-03-01T00:00' '2020-03-08T00:00' '2020-03-08T20:00'] datetime64[m]
  • 使用arange()创建 datetime64 数组,用于生成日期范围。np.arange(‘2020-08-01’, ‘2020-08-10’, dtype=np.datetime64)

datetime64 和 timedelta64 运算

  • timedelta64 表示两个 datetime64 之间的差。timedelta64 和相减运算中的两个 datetime64 中的较小的单位保持一致。
a = np.datetime64('2020-03') + np.timedelta64(20, 'D')
print(a, a.dtype)  # 2020-03-21 datetime64[D]
  • 生成 timedelta64时,要注意年(‘Y’)和月(‘M’)这两个单位无法和其它单位进行运算(一年有几天?一个月有几个小时?不确定)。

  • timedelta64 的运算

c = np.timedelta64(1, 'W')
d = np.timedelta64(1, 'D')
print(c / d)  # 7.0
  • numpy.datetime64(2020-06-01T20:05:30) 与 datetime.datetime(2020-06-01 20:05:30) 相互转换A.astype(B)
import numpy as np
import datetime

dt = datetime.datetime(year=2020, month=6, day=1, hour=20, minute=5, second=30)
dt64 = np.datetime64(dt, 's')
print(dt64, dt64.dtype)
# 2020-06-01T20:05:30 datetime64[s]

dt2 = dt64.astype(datetime.datetime)
print(dt2, type(dt2))
# 2020-06-01 20:05:30 <class 'datetime.datetime'>

datetime64 的应用

为了允许在只有一周中某些日子有效的上下文中使用日期时间,NumPy包含一组“busday”(工作日)功能。
numpy.busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)

  • 将指定的偏移量应用于工作日,单位天(‘D’)。计算下一个工作日,如果当前日期为非工作日,默认报错。可以指定 forward 或 backward 规则来避免报错。(一个是向前取未来第一个有效的工作日,一个是向后取过去第一个有效的工作日)
    可以指定偏移量为 0 来获取当前日期向前或向后最近的工作日,当然,如果当前日期本身就是工作日,则直接返回当前日期。
# 2020-07-10 星期五
a = np.busday_offset('2020-07-10', offsets=1)
print(a)  # 2020-07-13

a = np.busday_offset('2020-07-11', offsets=1)
print(a)  # ValueError: Non-business day date in busday_offset

a = np.busday_offset('2020-07-11', offsets=0, roll='forward')
print(a)  # 2020-07-13

a = np.busday_offset('2020-07-11', offsets=1, roll='forward')
print(a)  # 2020-07-14
  • 返回指定日期是否是工作日:np.is_busday(‘2020-07-10’) # True

  • 统计一个 datetime64[D] 数组中的工作日天数:np.count_nonzero(np.is_busday(a)) / 两个日期之间的工作日数量numpy.busday_count()
    numpy.busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)Counts the number of valid days between begindates and enddates, not including the day of enddates.

  • 自定义周掩码值,即指定一周中哪些星期是工作日:np.is_busday(‘2020-07-10’, weekmask=[1, 1, 1, 1, 1, 0, 0]) #True

数组的创建

numpy 提供的最重要的数据结构是ndarray,它是 python 中list的扩展。

1. 依据现有数据来创建 ndarray

  • (a)通过array()函数进行创建。
    np.array([0, 1, 2, 3, 4])

  • (b)通过asarray()函数进行创建

array()和asarray()都可以将结构数据(list)转化为 ndarray(np.array([1,2])=np.asarray([1,2]))

但是array()和asarray()主要区别就是当数据源是ndarray 时,array()仍然会 copy 出一个副本,占用新的内存(和改变前ndarray相同),但不改变 dtype 时 asarray()不会。

import numpy as np

x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
y = np.array(x)
z = np.asarray(x)
x[1][2] = 2
print(x,type(x),x.dtype)
# [[1 1 1]
#  [1 1 2]
#  [1 1 1]] <class 'numpy.ndarray'> int32

print(y,type(y),y.dtype)
# [[1 1 1]
#  [1 1 1]
#  [1 1 1]] <class 'numpy.ndarray'> int32

print(z,type(z),z.dtype)
# [[1 1 1]
#  [1 1 2]
#  [1 1 1]] <class 'numpy.ndarray'> int32

更改为较大的dtype时,其大小必须是array的最后一个axis的总大小(以字节为单位)的除数 ?!

import numpy as np

x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
print(x, x.dtype)
# [[1 1 1]
#  [1 1 1]
#  [1 1 1]] int32
x.dtype = np.float

# ValueError: When changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.
  • (c)通过fromfunction()函数进行创建

给函数绘图的时候可能会用到fromfunction(),该函数可从函数中创建数组。

def fromfunction(function, shape, **kwargs):
import numpy as np

def f(x, y):
    return 10 * x + y

x = np.fromfunction(f, (5, 4), dtype=int)
print(x)
# [[ 0  1  2  3]
#  [10 11 12 13]
#  [20 21 22 23]
#  [30 31 32 33]
#  [40 41 42 43]]

x = np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
print(x)
# [[ True False False]
#  [False  True False]
#  [False False  True]]

x = np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
print(x)
# [[0 1 2]
#  [1 2 3]
#  [2 3 4]]

2.随机初始化矩阵

zeros(shape) zeros_like(x)

  • zeros()函数:返回给定形状和类型的零数组。

  • zeros_like()函数:返回与给定数组形状和类型相同的零数组。

  • ones()函数:返回给定形状和类型的1数组。

  • ones_like()函数:返回与给定数组形状和类型相同的1数组。

  • empty()函数:返回一个空数组,数组元素为随机数。

  • empty_like函数:返回与给定数组具有相同形状和类型的新数组。

  • eye()函数:返回一个对角线上为1,其它地方为零的单位数组。eye(4):4*4

  • identity()函数:返回一个方的单位数组。

  • diag(v, k=0)函数:提取对角线或构造对角数组。k表示对角线上方的第几条线(负数表示下方) np.diag(v)构造以v为对角线的数组

  • full(shape,const)函数:返回一个常数数组。

  • full_like()函数:返回与给定数组具有相同形状和类型的常数数组。

3. 利用数值范围来创建ndarray

  • arange()函数:返回给定间隔内的均匀间隔的值。
  • linspace()函数:返回指定间隔内的等间隔数字。
  • logspace()函数:返回数以对数刻度均匀分布。 相当于 10 ** i for i in x (x是linspace产生的)
  • numpy.random.rand() 返回一个由[0,1)内的随机数组成的数组。
x = np.logspace(0, 1, 5)
print(np.around(x, 2))
# [ 1.    1.78  3.16  5.62 10.  ]            
                                    #np.around 返回四舍五入后的值,可指定精度。
                                   # around(a, decimals=0, out=None)
                                   # a 输入数组
                                   # decimals 要舍入的小数位数。 默认值为0。 如果为负,整数将四舍五入到小数点左侧的位置

x = np.linspace(start=0, stop=1, num=5)
x = [10 ** i for i in x]
print(np.around(x, 2))
# [ 1.    1.78  3.16  5.62 10.  ]

4. 结构数组的创建

结构数组,首先需要定义结构,然后利用np.array()来创建数组,其参数dtype为定义的结构。

  • (a)利用字典来定义结构
personType = np.dtype({
    'names': ['name', 'age', 'weight'],
    'formats': ['U30', 'i8', 'f8']})

a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],
             dtype=personType)
print(a, type(a))
# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# <class 'numpy.ndarray'>
  • (b)利用包含多个元组的列表来定义结构
import numpy as np

personType = np.dtype([('name', 'U30'), ('age', 'i8'), ('weight', 'f8')])
a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],
             dtype=personType)
print(a, type(a))
# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
# <class 'numpy.ndarray'>

# 结构数组的取值方式和一般数组差不多,可以通过下标取得元素:
print(a[0])
# ('Liming', 24, 63.9)

print(a[-2:])
# [('Mike', 15, 67. ) ('Jan', 34, 45.8)]

# 我们可以使用字段名作为下标获取对应的值
print(a['name'])
# ['Liming' 'Mike' 'Jan']
print(a['age'])
# [24 15 34]
print(a['weight'])
# [63.9 67.  45.8]

数组的属性

在使用 numpy 时,你会想知道数组的某些信息。很幸运,在这个包里边包含了很多便捷的方法,可以给你想要的信息。

  • numpy.ndarray.ndim用于返回数组的维数(轴的个数)也称为秩,一维数组的秩为 1,二维数组的秩为 2,以此类推。
  • numpy.ndarray.shape表示数组的维度,返回一个元组,这个元组的长度就是维度的数目,即 ndim 属性(秩)。
  • numpy.ndarray.size数组中所有元素的总量,相当于数组的shape中所有元素的乘积,例如矩阵的元素总量为行与列的乘积。
  • numpy.ndarray.dtype ndarray 对象的元素类型。
  • numpy.ndarray.itemsize以字节的形式返回数组中每一个元素的大小。

在ndarray中所有元素必须是同一类型,否则会自动向下转换,int->float->str。
b = np.array([1, 2, 3, 4, ‘5’])
print(b) # [‘1’ ‘2’ ‘3’ ‘4’ ‘5’]

部分练习

1.numpy是python中基于数组对象的科学计算库。
提炼关键字,可以得出numpy以下三大特点:
拥有n维数组对象;
拥有广播功能(后面讲到);
拥有各种科学计算API,任你调用;

print(0 * np.nan)# nan
print(np.nan == np.nan)# False
print(np.inf > np.nan)# False
print(np.nan - np.nan)# nan
print(0.3 == 3 * 0.1)# False

3.填充缺失的日期,使其成为连续的日期序列

import numpy as np

dates = np.arange('2020-02-01', '2020-02-10', 2, np.datetime64)
print(dates)
# ['2020-02-01' '2020-02-03' '2020-02-05' '2020-02-07' '2020-02-09']

out = []
for date, d in zip(dates, np.diff(dates)):
    out.extend(np.arange(date, date + d))
fillin = np.array(out)
output = np.hstack([fillin, dates[-1]])
print(output)
# ['2020-02-01' '2020-02-02' '2020-02-03' '2020-02-04' '2020-02-05'
#  '2020-02-06' '2020-02-07' '2020-02-08' '2020-02-09']
4.#得到当下时间日期
yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')
today     = np.datetime64('today', 'D')
tomorrow  = np.datetime64('today', 'D') + np.timedelta64(1, 'D')
5.#创建布尔数组
import numpy as np

arr = np.full([3, 3], True, dtype=np.bool)
print(arr)
# [[ True  True  True]
#  [ True  True  True]
#  [ True  True  True]]

6.创建一个二维数组,其中边界值为1,其余值为0

Z = np.ones((10,10))
Z[1:-1,1:-1] = 0
print(Z)

7.将本地图像导入并将其转换为numpy数组

import numpy as np
from PIL import Image

img1 = Image.open('Scarlett.jpg')
a = np.array(img1)

print(a.shape, a.dtype)
# (700, 500, 3) uint8
(700, 500, 3) uint8
从零手写GPT:用NumPy实现Transformer核心组件 语言模型的本质是基于上下文的概率化词预测,其技术根基在于矩阵运算、注意力机制与梯度优化。理解GPT需回归第一性原理——从Token Embedding的查表机制、Positional Encoding的正弦编码设计,到Multi-Head Self-Attention的多视角加权聚合,每一步都依赖清晰的张量形状推演与数值稳定性处理。这种底层实现不仅揭示了大模型‘如何思考’的直觉回路,更支撑模型调试、结构改进与教学迁移等工程实践。本文聚焦纯Python+NumPy手写路径,覆盖Embedding、位置编码、自 阅读详情

相关推荐

004、Nvidia Jetson Nano Developer KIT(b01)-代码环境配置

这是关于自己的demo要移植到jetson nano上,缺啥补啥的过程。

here we are的博客 379

Mysql数据库 | 第六章 | 表复制和去重 | 合并查询 | 外连接 | 主键 | 外键 | check约束

- 演示check 的使用-- mysql 5.7目前还不支持check ,只做语法检验,但不会生效-- 测试sex VARCHAR(6) CHECK (sex IN ('man','woman')), -- 性别强制为男或者女的-- sal大于1001,小于2000-- 添加数据-- 查询然而并没有生效,所以在mysql 5.7 还不会生效。

ZJC744575的博客 546

Android 跨进程通信-(一)Binder概念引入

前言 主要对Android中的跨进程通信进行总结下,这篇先梳理下里面的涉及的一些概念 一 多进程 1.进程与线程 进程:系统中正在运行的一个应用程序,某个程序一旦运行就是一个进程,是资源分配的最小单位; 线程:程序执行的最小单位,包含在进程中,一个进程可以包含多个线程。 2.Android应用中的多进程 (1)dalivk虚拟机 Android系统的底层任务管理以及驱动都是基于Linux系统。一个Android系统其实就是一个Linux系统,通过adb shell进入连接的手机,就可以看到Li

nihaomabmt的专栏 1105

MySQL数据库: 多表查询.蠕虫复制.约束.自增长.索引.事务.视图.管理

MySQL的使用 数据库三层结构 所谓安装Mysql数据库,就是在主机安装一个数据库管理系统(DBMS),这个管理程序可以管理多个数据库.DBMS(database manage system) 一个数据库中可以创建多个表,以保存数据. 数据库管理系统(DBMS),数据库和表的关系如图所示: 数据在数据库中的存储方式 SQL语句分类 DDL: 数据定义语句 [CREATE 表,库…] DML: 数据操作语句 [增加 insert,修改 update,删除 delete] DQL: 数据查询语句 [

jason_bone_的博客 846

ELK - CentOS7 安装 elasticsearch 7.17.5

elk elasticsearch 安装

qq_19783793的博客 1462

STM32测测速---编码电机读取速度的计算

速度计算:轮胎每转一圈的脉冲数取决于编码器的分辨率,可由下面公式进行计算:PPR是电机的线数最后可以计算轮胎每转一圈的脉冲数为:轮胎每转一圈的脉冲数 = 9.6 × 11 × 4 = 422.4最后的速度公式简化为:速度 = (0.01 秒内产生的脉冲数 ∗ 0.055 ∗ π )/(0.01 ∗422.4​。

weixin_69414084的博客 3813

蠕虫复制

1.复制创建表(只会复制表结构,不会复制表中数据):create table 新表名 like 被复制的表名; 查看表 复制表my_user2(只会复制表结构,不会复制表中数据) 查看表my_usercopr中是否有数据 2.蠕虫复制(复制表数据,成倍复制的):INSERT INTO my_usercopr SELEC

聆听 1695

【蒸汽幻想台服新版商业端】2025最新整理单机一键即玩镜像端+WIN系半手工端+PC客户端+网页注册+网页管理后台+教程【站长亲测】

MMORPG端游【蒸汽幻想台服新版商业端】2025最新整理单机一键即玩镜像端+WIN系半手工端+PC客户端+网页注册+网页管理后台+教程。

百创科技 535

SQL高级操作之一——新增数据(主键冲突更新,主键冲突替换,蠕虫复制)

新增数据 先创建一张表   多数据插入 只要写一次insert指令,但是可以直接插入多条记录 基本语法:insert into 表名 [(字段列表)] values(值列表), (值列表)…; 主键冲突 主键冲突:在有的表中,使用的是业务主键(字段有业务含义),但是往往在进行数据插入的时候,又不确定数据表中是否已经存在对应的主键。 先创建一张带业务主键的表   主键...

JavaCoder_juejue的博客 7394

2024年 Flutter 面试题大全(2024.6.28持续更新中)

2024年 Flutter 面试题大全(持续更新中)

Code Metaverse 6671

【OpenCV】图像的像素直方图 图像特征点 cv::FAST cv::ORB ORB_SLAM2::ORB

文章目录图像直方图代码实现cv::FAST和cv::ORB 检测图像特征点cv::FAST和cv::ORB 检测图像特征点代码实现ORB_SLAM2::ORB和自己实现ORB图像特征点检测效果对比ORB_SLAM2::ORB和自己实现ORB图像特征点检测效果对比代码实现 图像直方图代码实现 图像是由不同数值(颜色)的像素构成的,像素值在图像中的分布情况是图像的重要属性,可以用直方图修改图像的外观,标识图像的内容,检测图像中特定的物体或纹理。 单通道灰度图像中每个像素都有一个 0(黑色)-255(白色)的整

小秋 AI SLAM 入门实战教程 2511

手写NumPy神经网络:从矩阵维度到数值稳定性的深度拆解

神经网络本质是张量运算的链式法则实现,其核心在于矩阵乘法、广播机制与梯度维度匹配。理解反向传播的关键,在于掌握`dW = dZ @ A_prev.T`等公式背后的线性代数原理与内存布局约束;而实际训练的稳定性,则高度依赖Softmax平移、log概率截断、He初始化等数值敏感设计。这些基础能力直接决定模型在嵌入式部署、框架定制或梯度调试等工程场景中的可控性与鲁棒性。本文以纯NumPy实现为载体,系统揭示全连接网络前向/反向传播中维度推导、浮点精度处理与参数初始化的底层逻辑。

weixin_30387799的博客 419

ZYNQ 7020 之 FPGA知识点重塑笔记一——串口通信

通信方式一般分为串行通信和并行通信。并行通信是指多比特数据同时通过并行线进行传送。这种传输方式通信线多、成本高,故不宜进行远距离通信,通常传输距离小于 30 米。串行通信是指数据在一条数据线上,一比特接一比特地按顺序传送的方式。这种运输方式通常节省传输线,大大降低使用成本,但数据传送速度慢。综上可知,串行通信主要应用于长距离、低速率的通信场合。本次实验我们主要讲解下串行通信。串行通信一般有2种通信方式:同步串行通信和异步串行通信。同步串行通信。

m0_51430584的博客 3098

纯NumPy手写神经网络:从梯度计算到训练闭环

神经网络训练的本质是基于梯度的参数优化过程,其核心在于准确计算损失函数对各层参数的偏导数,并沿负梯度方向迭代更新。这一过程依赖链式法则在多维数组上的精确实现,涉及矩阵乘法、广播机制与维度对齐等NumPy关键能力。掌握梯度(Gradient)的数值意义与数组映射关系,是理解反向传播、调试收敛异常(如梯度消失/爆炸)及实现轻量化部署的技术基础。本文以纯NumPy从零构建前向-反向-更新闭环为例,聚焦梯度计算的可验证性、可调试性与工程鲁棒性,覆盖线性层、ReLU/Sigmoid激活、Cross-Entropy损失

weixin_30219613的博客 304

基于Xilinx XDMA 的PCIE通信

基于Xilinx XDMA 的PCIE通信 概述:   想实现基于FPGA的PCIe通信,查阅互联网各种转载…基本都是对PCIe的描述,所以想写一下基于XDMA的PCIe通信的实现(PCIe结构仅做简单的描述(笔记),了解详细结构移至互联网)。实践实践!!! 说明: 参考文档: PCI Express Base Specification Revision 3.0 PCI Express Base Specification Revision 5.0 pg195-pcie-dma PCI Express体系

Crazzy_M的博客 1万+

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

用NumPy从零实现神经网络:掌握梯度流与维度对齐的核心原理

神经网络本质是张量运算与链式求导的系统工程,其核心在于前向传播的矩阵线性变换、激活函数的非线性映射,以及反向传播中梯度沿计算图的精确回传。理解这一过程的关键,在于掌握维度对齐规则与数值稳定性机制——前者决定梯度能否正确累积,后者保障训练不因log(0)或exp溢出而崩溃。NumPy实现强制暴露shape匹配、广播行为、手动微分等底层细节,使开发者直面sigmoid饱和、ReLU导数定义、softmax数值保护等真实挑战。这种面向数组编程的硬核实践,将抽象的‘自动微分’转化为可调试、可验证的矩阵操作流,为后续

aoe41606的博客 309

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

从零手写推理模型:用NumPy实现符号逻辑神经网络

推理模型是人工智能中实现形式化逻辑推演的核心技术,其本质在于将符号关系、传递性规则与数值计算深度融合。不同于通用语言模型依赖统计模式匹配,符号推理模型需显式建模关系结构、保证输出确定性,并在低维离散空间中完成可解释的中间表征。这要求开发者深入理解张量运算的数学原理、反向传播的链式法则实现、以及softmax等算子的数值稳定性机制。基于NumPy的手动实现,不仅剥离了PyTorch自动微分等抽象层,更暴露出维度对齐、梯度累积、浮点精度控制等底层工程关键点。本文聚焦于面向一阶逻辑(如传递性判断)的轻量级推理网络

lvwenwen 551

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

手写神经网络:用NumPy从零实现二分类全连接网络

神经网络是深度学习的核心基础模型,其本质是多层非线性函数的复合映射与基于梯度的参数优化过程。理解前向传播的矩阵运算、反向传播的链式求导,以及权重初始化、激活函数选择、学习率设定等关键设计,是掌握深度学习原理与调试能力的前提。这类手写实现虽不追求工业级性能,但能建立对梯度流动、维度对齐和数值稳定性的直观认知,显著提升模型调优与问题定位能力。尤其在教学与工程排障场景中,纯NumPy实现的可打断点、可打印中间变量特性,使其成为验证理论与实践一致性的黄金标准。本文即围绕二分类任务,详解单隐藏层全连接网络的手动构建全

weixin_30635053的博客 413

纯NumPy手写计算图:从零实现神经网络前向与反向传播

计算图是深度学习自动微分的核心抽象,本质是有向无环图(DAG)上的链式法则遍历。其原理在于将数学运算分解为原子节点,通过拓扑排序组织前向执行顺序,并逆序累积梯度实现反向传播。该机制赋予模型可微性与可训练性,是PyTorch、TensorFlow等框架的底层基石。在工程实践中,显式构建计算图能彻底暴露梯度流向、广播规则与雅可比矩阵计算细节,显著提升调试能力与算法理解深度。本文聚焦NumPy手动求导与计算图(Computational Graph)两大关键技术,以MNIST全连接网络为载体,完整呈现节点设计、拓

chulilang8944的博客 337

ComfyUI ControlNet Aux模块OpenCV报错:5步彻底解决指南

当你在使用ComfyUI ControlNet Aux预处理模块时,是否遇到过这样的尴尬场景:满怀期待地准备进行深度估计或姿态检测,却被一个看似简单的OpenCV resize报错"src is not a numpy array, neither a scalar"彻底打乱了工作节奏?这个问题困扰着许多AI图像处理爱好者,但别担心,本文将带你一步步彻底解决这个烦人的技术难题。 ## 〖紧急警报

gitblog_00398的博客 1106

【亲测免费】 PyWavelets 使用教程

PyWavelets 是一个用于小波变换的 Python 库,支持多种小波基函数,如 Daubechies、Morlet、Symlet 等。它提供了丰富的功能,包括单层和多尺度小波变换、逆变换以及阈值函数等。PyWavelets 广泛应用于信号处理、图像处理和数据分析等领域。 ## 项目快速启动 ### 安装 PyWavelets 首先,确保你已经安装了 Python。然后,使用以下命令安装...

gitblog_00406的博客 894

从数学到项目:非科班转AI这8周,我的深度学习入门路线差点崩在第三周

非科班转AI第3周就卡在数学推导?我原计划的8周深度学习速成路线险些崩盘。从线性代数到CNN项目实战,分享如何用亚马逊云科技AI课程补基础、避坑,最终实现从调包侠到理解模型本质的转变。

weixin_47315004的博客 16

手写神经网络:从零实现反向传播与梯度计算

神经网络中的反向传播是深度学习的基石机制,其本质是链式法则在计算图上的系统性应用。理解它不仅需要掌握数学原理,更需通过数值验证、显式变量流和手动梯度推导来建立工程直觉。手写神经网络作为一种教学级实现方式,剥离了PyTorch/TensorFlow等框架的自动求导黑箱,强制暴露权重更新、激活函数梯度(如ReLU与sigmoid的数值稳定性差异)、损失函数合并优化(如softmax-cross-entropy联合梯度)等关键细节。该实践特别适用于调试梯度消失、初始化敏感性、L2正则梯度系数错误等典型问题,是构建

weixin_30859423的博客 407

手写神经网络从零实现:理解反向传播与梯度下降的本质

神经网络是深度学习的基石,其核心在于前向传播、损失计算与反向传播构成的闭环。反向传播本质是链式法则在计算图上的系统应用,而梯度下降则通过权重沿负梯度方向迭代更新来最小化损失。这一过程高度依赖矩阵运算的维度对齐与数值稳定性,例如sigmoid导数用输出值而非输入值计算,可避免重复指数运算与下溢风险;损失函数与激活函数组合(如softmax+cross-entropy)能天然简化初始梯度为(y_pred - y_true),显著降低实现复杂度。这些原理在PyTorch或TensorFlow中被封装隐藏,但正是它

cuanmo8775的博客 413

从零实现神经网络:手写MLP、梯度推导与调试实践

神经网络本质是可微分的函数组合,其核心原理在于链式法则驱动的梯度反向传播。掌握这一机制的技术价值,在于摆脱框架黑箱依赖,获得对数值稳定性、内存布局和计算流的完全控制能力。典型应用场景包括模型轻量化部署、自定义损失函数开发、联邦学习梯度审计及边缘设备推理优化。本文聚焦全连接网络(MLP)这一最小可行结构,通过纯NumPy手写Dense层、ReLU激活、CrossEntropyLoss及SGD with Momentum,完整呈现前向计算、手动求导、参数更新与健康监控的工程闭环,覆盖梯度检查、NaN排查、初始化

299
上一篇: 01统计学习概论
下一篇: DW-numpy_索引、切片与迭代
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值