《深度学习》鱼书入门学习笔记Day1

最新推荐文章于 2024-10-06 16:55:30 发布

TTeng_

最新推荐文章于 2024-10-06 16:55:30 发布

阅读量1k

点赞数 14

文章标签：深度学习学习笔记

本文链接：https://blog.csdn.net/HST478_/article/details/135310469

版权

第一章 Python入门

1.3 Python解释器

列表

列表长度
len(a)

切片
索引两种方式：
0，1，2… 或者 …，-2，-1
a[x:y] 索引x到y，不包含y
a[x:] 索引x到最后
a[:y] 第一个到索引y，不包含y

字典

键值对
me = {a:b,c:d}

布尔型bool

True和False
运算符：and，or，not

for语句

for … in …

1.4 类

class 类名:
	# 初始化，构造方法
	def __init__(self, 参数1, 参数2):
		self.参数 # 生成实例变量
	def 方法名(self, 参数1, 参数2):
		.......

1.5 NumPy

一维数组——向量

import numpy as np
x = np.array([1, 2, 3, 4])

print(x) 打印
type(x) 类型
基本算数运算，保证x和y元素个数相同

二维数组——矩阵，多维数组——张量

import numpy as np
A = np.array([1, 2], [3, 4], [5, 6])
print(A) 打印
A.shape 矩阵形状
A.dtype 矩阵中元素类型

广播

扩展实现不同形状数组运算

访问元素

索引法访问单个元素

x = np.array([1, 2], [3, 4], [5, 6])
print(x) 直接打印一个二维数组
x[0][1] 索引操作访问矩阵中元素，如2

标记法访问单个元素

除索引操作访问单个元素，还可以使用一维数组
x = np.array([1, 2], [3, 4], [5, 6])
x = x.flatten() 转换为一维数组
x[np,array([0,2,4])] 得到array([1,3,5])

for row in x：print(row) 访问每个元素，如[1,2]

1.6 Matplotlib

import matplotlib.pyplot as plt
from matplotlib.image import imread
plt.plot(x, y, label=“绘制图线标题”, linestlye=“绘制图线形状”)
plt.xlabel(“x轴名字”)
plt.ylabel(“y轴名字”)
plt.title(“标题名字”)
plt.legend() 图例
plt.show() 展示
img = imread(“路径”)
plt.imread(img)

第二章感知机

2.1 基础知识

感知机的信号只有流和不流两种 0表示不传递信号，1表示传递信号

输入信号送往神经元，乘固定的权重，计算总和，超过阈值则激活
x1w1+x2w2>阈值，神经元被激活

与门与非门或门
异或门：（与非门）与（或门）

偏置b和权重w
偏置决定了神经元被激活的容易程度

2.2 多层感知机

第0层的两个神经元先接受输入信号，并将信号发送到第一层的神经元
第1层的神经元将信号发送至第二层的神经元，第二层神经元输出y

第三章神经网络

3.1 基础知识

输入层——中间层——输出层
层号从0开始
x1和x2是输入信号，y是输出
b是偏置——神经元被激活的容易程度
w1和w2是权重——信号的重要程度

当w1x1+w2x2+b>0时，y=1，
当w1x1+w2x2+b<=0时，y=0

如图：

简化——引入新函数h(x)

3.2 激活函数

一、阶跃函数

实数：

def step_f(x):
    if x > 0:
        return 1
    else:
        return 0

numpy数组——生成bool型变量：

def step_f(x):
	y = x > 0
	return y.astype(np.int)

x为numpy整型数组，不等号运算使其变为bool型
再通过astype(np.int)转换为想要转换的数据类型

import numpy as np
import matplotlib.pyplot as plt
def fun(x):
    return np.array(x > 0, dtype=np.int64)
x = np.arange(-5.0, 5.0, 0.1)
y = fun(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1)
plt.show()

二、sigmoid函数

支持numpy数组直接运算——广播

def sigmoid(x):
	return 1/(1 + np.exp(-x))

import numpy as np
import matplotlib.pyplot as plt


def sigmoid(x):
    return 1 / (1 + np.exp(-x))


x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1)
plt.show()

三、二者比较

不同点

平滑性不同
sigmoid可以返回实数——神经网络流动的是连续的实数值信号
阶跃函数只能返回0或1——感知机流动的的是0或1的二元信号

相同点

形状相似
输出信号重要，输出的值大
输出信号的值在0和1之间

四、ReLU函数

当x>0时，h(x)=x
当x<=0时，h(x)=0

import numpy as np
import matplotlib.pyplot as plt


def ReLU(x):
    return np.maximum(0,x)


x = np.arange(-5.0, 5.0, 0.1)
y = ReLU(x)
plt.plot(x, y)
plt.ylim(-1.0, 5.0)
plt.show()

3.3 多维数组的运算

一、多维数组

x = np.array([1,2,3,4])
np.ndim(x)——数组的维数，1
x.shape——矩阵的形状，(4,)
x.shape[i]——x.shape是一个元组,i=0时返回4

x = np.array([1,2],[3,4],[5,6])
np.ndim(x)——数组的维数，2（行和列）
x.shape——矩阵的形状，(3,2)
x.shape[i]——x.shape是一个元组

np.dot(a,b)——矩阵乘法

一维——数组
二维——矩阵
三维——张量

3.4 三层神经网络的实现

一、符号确认

权重 w ij（k）

i表示w后一层的第i个神经元
j表示w前一层的第j个神经元
k表示第k层的权重

神经元a i（j）

i表示第i个神经元
j表示第j层的神经元

偏置

权重bi（1）中i的个数取决于后一层神经元的数量，
前一层只有一个神经元1

二、原理

输入层到第一层——由x1 x2 x3得到a1 a2 a3

A = XW + B
A表示a1（1），a2（1），a3（1）
X表示x1，x2
W表示w11（1） w21（1） w31（1）
w12（1） w22（1） w32（1）
B表示b1（1），b2（1），b3（1）

第一层sigmoid激活，由a1（1），a2（1），a3（1）得到z1（1），z2（1），z3（1)

第一层到第二层

A = XW + B
A表示a1（2），a2（2）
X表示z1（1），z2（1），z3（1)
W表示w11（2） w21（2）
w12（2） w22（2）
w13（2） w23（2）
B表示b1（2），b2（2）

第二层sigmoid激活，由a1（2），a2（2）得到z1（1），z2（1）

第二层到输出层

A = XW + B
A表示a1（3），a2（3）
X表示z1（2），z2（2）
W表示w11（3） w21（3）
w12（3） w22（3）
B表示b1（3），b2（3 ）

输出层使用恒等函数激活，输入信号会原封不动输出

三、代码

import numpy as np


def sigmoid(x):
    return 1 / (1 + np.exp(-x))


def init_network():
    def init_network():
        network = {}
        # 输入层到第一层 W是2*3，b是1*3
        network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
        network['b1'] = np.array([0.1, 0.2, 0.3])
        # 第一层到第二层 W是3*2 b是1*2
        network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
        network['b2'] = np.array([0.1, 0.2])
        # 第二层到输出层 W是2*2 b是1*2
        network['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])
        network['b3'] = np.array([0.1, 0.2])
        return network


def forward(network, x):
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']
    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, W2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, W3) + b3
    y = a3
    return y


network = init_network()
x = np.array([1.0, 0.5])
y = forward(network, x)
print(y)

3.5 输出层的设计

softmax函数

输出函数，回归问题（根据某个输入预测一个连续的数值的问题）使用恒等函数
分类问题使用softmax函数

def softmax(a):
    exp_a = np.exp(a)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

指数函数过大——溢出问题
改进：指数函数运算中加入一个任意的相同的常数值

def softmax(a):
    c = np.max(a)
    exp_a = np.exp(a-c)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

特征：

输出为0到1的实数
输出值总和为1——概率
输出层的神经元数量根据待解决的问题决定

3.6 手写数字识别

识别精度：即在多大程度上能够正确分类。（可以使用：正确分类数/分类总数来进行计算）
正规化：将数据限制到某一范围内。
预处理：对神经网络的输入数据进行某种既定的转换。
数据白化：将数据整体的分布形状均匀化的方法。
批处理：对数据进行打包处理。好处：减轻数据总线的符合，即相对于数据读入可以将更多的时间用于计算。

from PIL import Image #图像显示模块
img=img.shape #假设这里为(784,)
img=img.reshape(28,28) #改变数组形状
img=Image.fromarray(imgnp.uint(img)) #将numpy数组转化为PIL用的数据对象
img.show()#展示
#---------分割-----------
y=np.array([1,2,3])#获取最大元素的索引，在输出函数的时候可以用来判断最后的分类类别。
print(np.argmax(y，axis=1))#axis=1返回列索引
>>>2
#---------分割-----------
range(start,end,step)#[start,end)间隔为step
#---------分割-----------
y=np.array([1,2,3])
t=np.array([1,1,1])
print(y==t)#array支持比较运算符
>>>[True,False,Flase]
print(np.sum(y==t))
>>>1