基于Python的深度学习基础

最新推荐文章于 2024-05-16 21:34:32 发布

程序媛了了

最新推荐文章于 2024-05-16 21:34:32 发布

阅读量1.4k

点赞数 46

文章标签： python 开发语言

本文链接：https://blog.csdn.net/Trb401012/article/details/135865311

版权

Python基础

Python是一种开源的、简单易记、可以自由使用编程语言。
深度学习将使用NumPy和Matplotlib这两种外部库
Python有“解释器”和“脚本文件”两种运行模式
Python能够将一系列处理集成为函数或类等模块
NumPy中有很多用于操作多维数组的便捷方法

类与对象

变量是挂在对象身上的标签

class Man:     
#定义了一个新类Man，类Man生成了实例（对象）m
#类Man的构造函数（初始化方法会接收参数name）
#参数name初始化实例变量self.name（实例变量是存储在各个实例中的变量）
    def __init__(self, name):  
        self.name = name    #通过在self后面添加属性名来生成或访问实例变量
        print('Initialized!')

    def hello(self):
        print("Hello" + self.name +'!')

    def goodbye(self):
        print('Good-bye' + self.name + '!')

m = Man('David')
m.hello()
m.goodbye()

NumPy基础

import numpy as np

NumPy的 N 维数组（矩阵）

A = np.array([1,2] , [3,4])
A.array()    #查看矩阵的形状
A = np.dtype()    #查看矩阵元素的数据类型

数组和矩阵的计算工具
关于array类型和matrix类型

Numpy中两大重要类型array类型(N维数组ndarray)和矩阵类型matrix是很多基于Numpy数值计算的基础；

Numpy中最重要的数据结构就是ndarry，简写为array，即N维数组；matrix也是一种array，只不过是维数为2的特殊array，matrix的维数是固定的，这点和一般array显著不同

即便加减乘除各种运算，matrix的维数不会发生变化，而array在运算时特别是归约时维数会发生变化，一句话，matrix的维数永远是

二者之间的转化，array转matrix用np.asmatrix或者np.matrix，matrix转array用np.asarray或者matrix的A属性
行向量或者列向量对应的array和matrix的实际维数

广播（broadcast）

在np乘法中，标量被当作是由相同元素组成的的 N 维数组，以便进行和数组进行算术运算

广播的例子：标量10被当作2 × 2的矩阵

访问元素

X = np.array([51,55], [14,19], [0,4])

X[0]	#访问第0行元素 -> OUTPUT:array([51,55])

X[0][1]	#访问(0,1)元素 -> OUTPUT:55

#遍历数组中的元素
for row in X:
    print(row)

X = X.flatten()#将X转换为一维数组 - > OUTPUT:[51 55 14 19 0 4]

NumPy多维数组的运算

此部分知识将在神经网络中应用.

矩阵的点积（乘积）

np.dot(A, B) #A和B的顺序影响结果

在多维数组的点积运算中，两个矩阵对应维度的元素必须一致.

在矩阵的点积运算中，对应维度的元素个数要保持一致

Matplotilb

安装

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple matplotlib

导入库

import numpy as np
import matplotlib.pyplot as plt

绘制sin函数曲线

#生成数据
x = np.arange(0, 6, 0.1)  #以0.1为单位，生成0到6的数据
y = np.sin(x)

#绘制图形
plt.plot(x, y)

plt.xlabel("在此处输入x轴标签")
plt.ylabel("在此处输入y轴标签")
plt.title("在此处输入图像标题")

plt.show()

方法查阅表

pyplot函数	功能
plt.ylim(start, stop, step)	指定y轴的范围
plt.show()	显示绘制的图像
plt.plot(x ,y)	绘制折线图
plt.xticks()	设置x轴刻度

感知机（perceptron）

感知机接收多个输入信号，输出一个信号；
感知机的信号只有1/0两个取值

0 对应“不传递信号”
1 对应"传递信号"

有两个输入的感知机

输入信号前往神经元的传输过程中会乘以固定的权重（ \omega_1x_1,\omega_2x_2 ）；只有当输入信号的总和超过阀值 \theta 后，才会输出 1 .

即 y=\begin{cases} 0\ (\omega_1x_1+\omega_2x_2\leq\theta)\\ 1\ (\omega_1x_1+\omega_2x_2>\theta) \end{cases},

令 \theta= -b,

其中，b被称作偏置.

简单逻辑电路

与门（AND gate）
与非门（NAND gate）
或门（OR gate）
与门（AND gate）

- 与门真值表:

x1	x2	y
1	1	1
0	0	0
1	0	0
0	1	0

与门仅在两个输入（ x_1,x_2 ）均为 1 时输出 1 ，其他时候则输出 0 .

与非门（NAND gate）

- 与非门真值表：

x1	x2	y
0	0	1
0	1	1
1	0	1
1	1	0

颠倒了与门的输出，即仅当 x_1 和 x_2 同时为 1 时输出 0 ，其他时候则输出 1 .

或门（OR gate）

x1	x2	y
1	0	1
0	1	1
0	0	0
1	1	1

以上三种基本电路只有参数的值（权重 \omega 和阈值 \theta ）不同可以用通过调整参数的值改变电路的类型，因此都可以用感知机实现.

Python实现简单逻辑电路

与门（仅当输入均为1才输出1）

def AND(x1, x2):    定义一个接收参数x1和x2的AND函数
    w1, w2, theta = 0.5, 0.5 0.7    #在函数内初始化w1,w2,theta
    tmd = x1*w1 + x2*w2
    if tmd <= theta:
        return 0
    elif tmd > theta:
        return 1
#当输入的加权总和超过阀值时返回1，否则返回0

- 导入权重和偏置

def AND(x1, x2):
	x = np.array([x1, x2])
	w = np.array([0.5, 0.5])
	b = -0.7
	tmp = np.sum(w*x) + b
	if tmp <= 0:
		return 0
	else:
		return 1

多层感知机（multi-layered perceptron）

异或门无法通过单层感知机来表示
使用2层感知机可以表示异或门
单层感知机只能表示线性空间，而多层感知机可以表示非线性空间
多层感知机（在理论上）可以表示计算

异或门（XOR gate）——感知机的局限性

异或门也被称为逻辑异或电路，而单层感知机无法表示异或门.

- 异或门的真值表

x1	x2	y
0	0	0
1	1	0
1	0	1
0	1	1

仅当 x_1 或 x_2 中的一方为 1时，才会输出 1 .

简单逻辑电路组合

import numpy as np

根据之前定义的门：

def OR(x1, x2):
    x = np.array([x1, x2])
    w = np.array([-0.5, -0.5])
    b = -0.1
    tmp = np.sum(w*x) + b
    if tmp <= 0:
        return 0
    else:
        return 1

AND

def AND(x1, x2):
    x = np.array([x1. x2])
    w = np.array([0.5, 0.5])
    b = -0.7
    tmp = np.sum(w*x) + b
    if tmp <= 0:
        return 0
    else:
        return 1

接下来进行电路的组合

def XOR(x1, x2):
    s1 = OR(x1, x2)
    s2 = AND(s1, s2)
    return y

通过叠加层（加深层），感知机能更加灵活的表示.

坏消息：感知机必需人工设定权重参数

好消息：神经网络不用，可以自动从数据中学习到合适的权重参数

神经网络

我们可以通过分析神经网络与感知机的不同来学习它，即基于感知机的构造来认识神经网络.

激活函数（activation function）

已经学习过，感知机原理的数学表达为： y=\omega_1x_1+\omega_2x_2+b,

引入新函数 h(x), 将其改写为 y=h(\omega_1x_1+\omega_2x_2+b)=h(x),

由此， y=\begin{cases} 0\ (b+\omega_1x_1+\omega_2x_2\leq0)\\ 1\ (b+\omega_1x_1+\omega_2x_2>0) \end{cases} 即可改写为：

y= \begin{cases} 0\ (x\leq0)\\ 1\ (x>0) \end{cases}.

激活函数的计算过程

神经网络的activation function必须使用非线性函数.

关于激活函数的选择，主要有两种（分别针对机器学习的两种主要问题）

回归问题——恒等函数
分类问题——softmax函数

后续专门会有一小节介绍这两种函数.

阶跃函数

- 简单实现

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

- NumPy数组实现

import numpy as np
def step_funtion(x):
    y = x > 0
    return y.astype(np.int)

阶跃函数的绘制

import numpy as np
import matplotlib.pyplot as plt
def step_function(x):
    return np.array(x > 0, dtype=np.int16)  #此处原书所给代码有错误，本文已修正

x = np.arange(-5.0, 5.0, 0.1)
y = step_function(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1) #指定y轴的范围
plt.show()

sigmoid函数

神经网络中用sigmoid函数作为激活函数，进行信号的转换，转换后的信号被传送给下一个神经元.

公式表达： h(x)=\frac{1}{1+\exp(-x)}
代码实现

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

x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid_function(x)

plt.plot(x, y)
plt.ylim(-0.1, 1.1)    #指定y轴的范围
plt.title("Sigmoid")
plt.show()

ReLU（Rectified Linear Unit）函数

公式表达： h(x)=\begin{cases} x\ (x>0)\\ 0\ (x\leq0) \end{cases}
代码实现

def relu_function(x):
    return np.maximum(0, x)  #使用了maximum函数

x = np.arange(-5.0, 5.0, 0.1)
y = relu_function(x)

plt.ylim(-1.0, 5.0)
plt.title("Rectified Linear Unit")
plt.plot(x, y)
plt.show()

3层神经网络的实现

关于3层神经网络，讲解的最清楚的视频：

https://b23.tv/jBaGuul

总的来说，从输入层到输入层，就是经过6次线性处理，每次处理分别有2个参数（权重 \omega 和偏置 b ），因此总共需要12个参数；同时，分别经过3次激活函数的转换（sigmoid或relu等）——3层神经网络的处理过程也不过就是这样而已；即便遇到更复杂一点的神经网络，原理也是一样的.

数学表达： a_1^{(1)}=\omega{(1)}_{12}x_1+\omega^{{(1)}_{12}x_{2}+b}{1}_{1}
代码实现

import numpy as np

#定义sigmoid激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

#定义恒等函数
def identity_function(x):
    return x

#定义init_network()函数，进行权重和偏置的初始化，并将其保存在字典变量network中
def init_network():
    network = {}
    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])
    network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
    network['b2'] = np.array([0.1, 0.2])
    network['W3'] = np.array([0.1, 0.3], [0.2, 0.4])
    network['b3'] = np.array([0.1, 0.2])   
    return network

#定义forward()函数，封装输入信号转换为输出信号的处理过程
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 = identity_function(a3)

    return y

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

输出层的设计

identity_function

恒等函数将输入原样输出.

恒等函数进行的转换处理可以用一根箭头来表示

softmax_function

y_k=\frac{\exp(a_k)}{\sum_{i=1}^{n}\exp(a_i)}

softmax函数的输出通过箭头与所有的输入信号相连

- 代码实现

import numpy as np

a = np.array([0.3, 2.9, 4.0])

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

计算机进行数值计算时，数值必须在4字节或8字节的数据宽度内，换言之，数值是存在有效位数的，而softmax有溢出问题，这就是它的缺陷.

softmax函数的改进

- 公式表达

\begin{aligned} y_k = \frac{\exp(a_k)}{\sum_{i=1}^{n}\exp(a_i)} = &\frac{C \exp(a_k)}{C\sum_{i=1}^{n}\exp(a_i)}\\ =&\frac{ \exp(a_k + \log C)}{\sum_{i=1}^{n}\exp(a_i + \log C)}\\ =&\frac{\exp(a_k + C’)}{\sum_{i=1}^{n}\exp(a_i + C’)} \end{aligned}

#将 \log C 替换为 C’ ，进行softmax的指数函数运算时，可以加减任意常数，不会影响结果.

- 代码实现

import numpy as np
import matplotlib.pyplot as plt

def soft(x):
    c = np.max(x)
    y = np.exp(x - c) / np.sum(np.exp(x - c))
    return y

x = np.array([1010, 1000, 990])
y = soft(x)
print(y)

softmax函数的特性

softmax函数的输出是0_.0~1._0之间的实数
softmax函数的输出值的总和是1

神经网络的学习

神经网络相较于感知机的优势即为拥有自主从训练数据中获取最优权重参数的过程，这是通过导入损失函数这一指标实现的.

损失函数（loss function）

评价神经网络模型的指标，可以反映当前的神经网络对监督数据（训练数据）在多大程度上不一致（不拟合），优化模型也即将这种不一致尽可能地降低到最小.

均方误差（mean squared error）

E = \frac{1}{2}\sum_{k}(y_k-t_k)^2 ，其中 y_k 表示神经网络的输出， t_k 表示监督数据， k 表示数据的维数.

交叉熵误差（cross entropy error）

E = -\sum_{k}t_k\log y_k , 其中 y_k 表示神经网络的输出， t_k 表示正确解标签

数值微分（numerical differentiation）

求偏导

已知函数 f(x_0, x_1)=x_0^2+x_12,

求 x_0=3,x_1=4 时，关于 x_0 的偏导数 \frac{\partial f}{\partial x_0} .

import numpy as np

def numerical_diff(f, x0):
    h = 0.0001
    return (f(x0 + h) - f(x0-h)) / h*2

def function_top1(x0):
    return x0**2.0 + 4.0**2.0

numerical_diff(function_top1, 3.0)

求 x_0=3,x_1=4 时，关于 x_1 的偏导数 \frac{\partial f}{\partial x_0} .

import numpy as np

def numerical_diff(f, x1):
    h = 0.0001
    return f(x1+h)- f(x1-h) / h*2

def function_top2(x1):
    return 3.0**2.0 + x1**2.0

numerical_diff(function_top2(x1), 4.0)

梯度（gradient）

由全部变量的偏导数组成的向量称为梯度，例如，上个例子的梯度为 (\frac{\partial f}{\partial x_0}, \frac{\partial f}{\partial x_1}) .

以上就是“基于Python的深度学习基础”的全部内容，希望对你有所帮助。

关于Python技术储备

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

在这里插入图片描述

二、Python必备开发工具

三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、Python练习题

检查学习结果。

六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

最后祝大家天天进步！！

上面这份完整版的Python全套学习资料已经上传至CSDN官方，朋友如果需要可以直接微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】。

程序媛了了

关注

46
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
基于Python的深度学习基础

即 y=\begin{cases} 0\ (\omega_1x_1+\omega_2x_2\leq\theta)\\ 1\ (\omega_1x_1+\omega_2x_2>\theta) \end{cases},E = \frac{1}{2}\sum_{k}(y_k-t_k)^2 ，其中 y_k 表示神经网络的输出， t_k 表示监督数据， k 表示数据的维数.观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
复制链接

扫一扫