深度学习框架paddlepaddle的简单使用
一、深度学习框架简介
名称 | 机构 | 支持语言 | 简介 |
---|---|---|---|
tensorflow | Python/C++ | 一个用于机器智能的开源软件库,多用于工业界 | |
pytorch | Python | 一个开源的Python机器学习库,多用于学术界 | |
caffe | BVLC | C++/Python | 老牌深度学习框架 |
paddlepaddle | 百度 | C++/Python | 源于产业实践的开源深度学习平台 |
keras | François Chollet 等 | Python | 作为Tensorflow、Microsoft-CNTK和Theano的高阶应用程序接口 |
MXNet | 亚马逊 | Python/C++/matlab | 致力于提供兼顾性能与灵活性的深度 学习框架 |
CNTK | 微软 | C++ | 在语音和图像辨识能力方面表现较好 |
二、Python简介
2.1 Python的安装过程
1.去官网下载稳定版本的Python3.7.7(Windows版本)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9x3otqYy-1619333938505)(深度学习框架paddlepaddle的简单使用.assets/image-20200422102046371.png)]
2.安装Python(勾选添到环境变量),选择Customize installation
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x8pkmajc-1619333938510)(深度学习框架paddlepaddle的简单使用.assets/20200422220000.png)]
3.点击Next
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nUJKVf8f-1619333938516)(深度学习框架paddlepaddle的简单使用.assets/20200422220014.png)]
4.选择安装路径(非系统盘)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4W3Xu6UL-1619333938518)(深度学习框架paddlepaddle的简单使用.assets/20200422220101.png)]
5.添加到环境变量(未勾选Add Python to PATH的处理),右击计算机,选择属性
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wZuiJMUD-1619333938521)(深度学习框架paddlepaddle的简单使用.assets/20200422220440.png)]
6.选择高级系统设置
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Snq85Rww-1619333938522)(深度学习框架paddlepaddle的简单使用.assets/20200422220453.png)]
7.选择环境变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CmNCdmZP-1619333938524)(深度学习框架paddlepaddle的简单使用.assets/20200422220509.png)]
8.将Python的安装路径添加到PATH的值中,PATH的值如下所示,其中C:\develop\Python\Python37是Python安装的根目录
PATH值:
C:\develop\Python\Python37\Scripts\;C:\develop\Python\Python37\;
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Kjva3ql-1619333938526)(深度学习框架paddlepaddle的简单使用.assets/20200422220546.png)]
9.验证是否安装成功
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2E22kHNk-1619333938528)(深度学习框架paddlepaddle的简单使用.assets/20200422222651.png)]
10.更新pip至最新版本
python -m pip install --upgrade pip
2.2 Python简介
计算机不能直接理解任何除机器语言以外的语言,所以必须要把程序员所写的程序语言翻译成机器语言,计算机才能执行程序。将其他语言翻译成机器语言的工具,被称为编译器
编译器翻译的方式有两种:一个是编译,另外一个是解释。两种方式之间的区别在于翻译时间点的不同。当编译器以解释方式运行的时候,也称之为解释器,Python的编译器就是以解释的方式运行,所以Python就是一种解释性语言。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FhHvVFRI-1619333938540)(深度学习框架paddlepaddle的简单使用.assets/001_编译型和解释型语言工作对比.png)]
- 编译型语言:程序在执行之前需要一个专门的编译过程,把程序编译成为机器语言的文件,运行时不需要重新翻译,直接使用编译的结果就行了。程序执行效率高,依赖编译器,跨平台性差些。如 C、C++
- 解释型语言:解释型语言编写的程序不进行预先编译,以文本方式存储程序代码,会将代码一句一句直接运行。在发布程序时,看起来省了道编译工序,但是在运行程序的时候,必须先解释再运行
2.3 Python 特点
- Python 是完全面向对象的语言
- 函数、模块、数字、字符串都是对象,在 Python 中一切皆对象
- 完全支持继承、重载、多重继承
- 支持重载运算符,也支持泛型设计
- Python 拥有一个强大的标准库,Python 语言的核心只包含 数字、字符串、列表、字典、文件 等常见类型和函数,而由 Python 标准库提供了 系统管理、网络通信、文本处理、数据库接口、图形系统、XML 处理 等额外的功能
- Python 社区提供了大量的第三方模块,使用方式与标准库类似。它们的功能覆盖 科学计算、人工智能、机器学习、Web 开发、数据库接口、图形系统 多个领域
三、Python 的 IDE -PyCharm
3.1 集成开发环境(IDE)
集成开发环境(IDE
,Integrated Development Environment)—— 集成了开发软件需要的所有工具,一般包括以下工具:
- 图形用户界面
- 代码编辑器(支持 代码补全/自动缩进)
- 编译器/解释器
- 调试器(断点/单步执行)
- ……
3.2 PyCharm 介绍
PyCharm
是 Python 的一款非常优秀的集成开发环境PyCharm
除了具有一般 IDE 所必备功能外,还可以在Windows
、Linux
、macOS
下使用PyCharm
适合开发大型项目- 一个项目通常会包含 很多源文件
- 每个 源文件 的代码行数是有限的,通常在几百行之内
- 每个 源文件 各司其职,共同完成复杂的业务功能
3.3 PyCharm安装过程
1.去PyCharm官网下载PyCharm(PyCharm下载地址),下载社区免费版即可
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U1xEbyj4-1619333938550)(深度学习框架paddlepaddle的简单使用.assets/image-20200422142125161.png)]
2.安装PyCharm,选择安装路径
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OS1iQDQ5-1619333938552)(深度学习框架paddlepaddle的简单使用.assets/20200422225434.png)]
3.全部勾选,点击Next
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tl6qH61c-1619333938554)(深度学习框架paddlepaddle的简单使用.assets/20200422225933.png)]
4.点击Install
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vvauZPnS-1619333938557)(深度学习框架paddlepaddle的简单使用.assets/20200422225942.png)]
3.4 PyCharm的初始设置
3.5 在PyCharm中创建Python项目
方式一:New Project
1.选择File->New Project
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MJig4L5H-1619333938564)(深度学习框架paddlepaddle的简单使用.assets/image-20200422235000341.png)]
2.选好项目的位置,点击下方的侧三角
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k54l8GwF-1619333938568)(深度学习框架paddlepaddle的简单使用.assets/image-20200422235133651.png)]
3.按顺序点击
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JF93JhQf-1619333938570)(深度学习框架paddlepaddle的简单使用.assets/image-20200422235232446.png)]
4.按顺序点击
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a3gRqq1m-1619333938572)(深度学习框架paddlepaddle的简单使用.assets/image-20200422235323191.png)]
5.选择Python的安装路径下的pytho.exe
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ffMdnfl-1619333938576)(深度学习框架paddlepaddle的简单使用.assets/image-20200422235435893.png)]
方式二:Open
直接打开一个文件夹作为项目的根目录
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z04Uf09y-1619333938580)(深度学习框架paddlepaddle的简单使用.assets\20200426141818.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eFZbT3tY-1619333938583)(深度学习框架paddlepaddle的简单使用.assets\20200426141841.png)]
为当前项目选择解释器
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-niuTfPXv-1619333938585)(深度学习框架paddlepaddle的简单使用.assets\20200426143759.png)]
3.6 PyCharm 项目布局
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qb8Tgv6b-1619333938587)(深度学习框架paddlepaddle的简单使用.assets/001_PyCharm的界面结构.png)]
- 文件导航区域 能够 浏览/定位/打开 项目文件
- 文件编辑区域 能够 编辑 当前打开的文件
- 控制台区域 能够:
- 输出程序执行内容
- 跟踪调试代码的执行
四、Python的使用
4.1 Python的缩进规则
Python中的缩进(Indentation)决定了代码的作用域范围。这一点和传统的c/c++有很大的不同(传统的c/c++使用花括号花括号{}符决定作用域的范围;Python使用缩进空格来表示作用域的范围,相同缩进行的代码是处于同一范围)。
4.2 Python的简单使用
4.2.1 注释
C语言程序都必须有一个且只能有一个 main()函数,python直接可以从上至下运行,无需入口函数。
print("hello Python!")#打印hello Python!
print("hello World!")#打印hello World!
4.2.2 变量
1.变量定义
- 在 Python 中,每个变量 在使用前都必须赋值,变量 赋值以后 该变量 才会被创建
- 等号(=)用来给变量赋值
=
左边是一个变量名=
右边是存储在变量中的值
#变量名 = 值
a = 3
2.变量的类型
在 Python
中定义变量是 不需要指定类型(在其他很多高级语言中都需要),数据类型可以分为 数字型 和 非数字型
- 数字型
- 整型 (
int
) - 浮点型(
float
) - 布尔型(
bool
)- 真
True
非 0 数
—— 非零,非空,非None即真 - 假
False
0
- 真
- 复数型 (
complex
)- 主要用于科学计算,例如:平面场问题、波动问题、电感电容等问题
- 整型 (
- 非数字型
- 字符串(str)
- 列表(list)
- 元组(tuple)
- 字典(dict)
使用 type
函数可以查看一个变量的类型
a = 3.0
print(type(a))#<class 'float'>
4.2.3 运算符
1. 算术运算符
- 是完成基本的算术运算使用的符号,用来处理四则运算
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 | 10 + 20 = 30 |
- | 减 | 10 - 20 = -10 |
* | 乘 | 10 * 20 = 200 |
/ | 除 | 10 / 20 = 0.5 |
// | 取整除 | 返回除法的整数部分(商) 9 // 2 输出结果 4 |
% | 取余数 | 返回除法的余数 9 % 2 = 1 |
** | 幂 | 又称次方、乘方,2 ** 3 = 8 |
- 在 Python 中
*
运算符还可以用于字符串,计算结果就是字符串重复指定次数的结果
print("-" * 50)#'----------------------------------------'
2. 比较(关系)运算符
运算符 | 描述 |
---|---|
== | 检查两个操作数的值是否 相等,如果是,则条件成立,返回 True |
!= | 检查两个操作数的值是否 不相等,如果是,则条件成立,返回 True |
> | 检查左操作数的值是否 大于 右操作数的值,如果是,则条件成立,返回 True |
< | 检查左操作数的值是否 小于 右操作数的值,如果是,则条件成立,返回 True |
>= | 检查左操作数的值是否 大于或等于 右操作数的值,如果是,则条件成立,返回 True |
<= | 检查左操作数的值是否 小于或等于 右操作数的值,如果是,则条件成立,返回 True |
3. 逻辑运算符
运算符 | 逻辑表达式 | 描述 |
---|---|---|
and | x and y | 只有 x 和 y 的值都为 True,才会返回 True 否则只要 x 或者 y 有一个值为 False,就返回 False |
or | x or y | 只要 x 或者 y 有一个值为 True,就返回 True 只有 x 和 y 的值都为 False,才会返回 False |
not | not x | 如果 x 为 True,返回 False 如果 x 为 False,返回 True |
4. 赋值运算符
- 在 Python 中,使用
=
可以给变量赋值 - 在算术运算时,为了简化代码的编写,
Python
还提供了一系列的 与 算术运算符 对应的 赋值运算符 - 注意:赋值运算符中间不能使用空格
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
+= | 加法赋值运算符 | c += a 等效于 c = c + a |
-= | 减法赋值运算符 | c -= a 等效于 c = c - a |
*= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
/= | 除法赋值运算符 | c /= a 等效于 c = c / a |
//= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
%= | 取 模 (余数)赋值运算符 | c %= a 等效于 c = c % a |
**= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
5. 运算符的优先级
- 以下表格的算数优先级由高到最低顺序排列
运算符 | 描述 |
---|---|
** | 幂 (最高优先级) |
* / % // | 乘、除、取余数、取整除 |
+ - | 加法、减法 |
<= < > >= | 比较运算符 |
== != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
not or and | 逻辑运算符 |
4.2.4 循环
主要学习for循环
对比python和c++中的for循环
for i in range(10):
print(i,end="")
#结果:0,1,2,3,4,5,6,7,8,9
for(int i=0;i<10;i++){
cout<<i;
}
#结果:0,1,2,3,4,5,6,7,8,9
4.2.5 函数
1. 函数定义格式:
def 函数名():
函数封装的代码
……
def
是英文define
的缩写- 函数名称 应该能够表达 函数封装代码 的功能,方便后续的调用
- 函数名称 的命名应该 符合 标识符的命名规则
- 可以由 字母、下划线 和 数字 组成
- 不能以数字开头
- 不能与关键字重名
4.2.6 非数字型类型变量的使用
在 Python
中,所有 非数字型变量 都支持以下特点:
- 都是一个 序列
sequence
,也可以理解为 容器 - 取值
[]
- 遍历
for in
- 计算长度、最大/最小值、比较、删除
- 链接
+
和 重复*
- 切片
字符串的使用
def test1():
# - 都是一个 ** 序列 ** `sequence`,也可以理解为 ** 容器 **
# - ** 取值 ** `[]`
# - ** 遍历 ** `
# for in `
# - ** 计算长度 **、 ** 最大 / 最小值 **、 ** 比较 **、 ** 删除 **
# - ** 链接 ** `+` 和 ** 重复 ** `*`
# - ** 切片 **
a = []
print(a)
a.append(3)
a.append('xiaoming')
a.clear()
a = [1,2,3,4,5,6]
print(a[3])
print(a[1:3])
b = [7,8,9]
c = a + b
print(c)
print(len(c))
d = []
d.append(a)
d.append(b)
d.append(c)
print(d)
print(len(d))
def testStr():
#字符串拼接
a = 'hello'
b = 'world'
c = a + ',' + b
print(c)#'hello,world'
#字符串分割成字符数组
str1 = 'hello,world,hello,python'
str1_list = str1.split(",")
print(str1_list)#['hello','world','hello','python']
#字符数组拼接成字符串
str2_list = ["It's", 'a', 'Lovely', 'Day', 'Today']
str2 = ' '.join(str2_list)
print(str2)#It's a Lovely Day Today
#字符串的格式化
for i in range(10):
str_format = ("%-"+str(i+1)+"s:line")%(i)
print(str_format)
if __name__== '__main__':
testStr()
List的使用
def testList():
a = []#定义空列表
a.append(3)#增,[3]
a.append("xiaoming")#增,[3,'xiaoming']
a.pop(1)#删,[3]
a.append('xiaoming')#增,[3,'xiaoming']
a[1]='xiaohong'#改,[3,'xiaohong']
#查,查询a中所有的元素并打印
for data in a:
print(data)
if __name__=='__main__':
testList()
练习:打印杨辉三角
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vlbrxMyk-1619333938588)(深度学习框架paddlepaddle的简单使用.assets/杨辉三角_1-1587949541718.png)]
分析:
数字规律:
- 设杨辉三角为
pascalTriangle
,行号为i,列号为j - 行号i的取值范围
0~numOfRows-1
,每一行中,列号j的取值范围为0~i
j=0
或i=j
时等于行号的时,值为1
,其它为:pascalTriangle[i-1][j-1]+pascalTriangle[i-1][j]
结构规律
- 设单位长度为
unitLength
- 第
i
行首元素缩进的规律是(numOfRows-i+1)*unitLength
- 首位元素定位完之后,然后保证每一个元素的打印宽度为
unitLength*2
即可
def isoscelesTriangle(numOfRows,unitLength):
space = " "
star = "*"
for i in range(numOfRows):
#首元素缩进
beginSpace = space*( (numOfRows-i+1) * unitLength )
print( "%s"%( beginSpace ),end="" )
for j in range(i+1):
#字符串拼接+格式化输出
print(("%-"+str(unitLength*2)+"s")%(star),end="")
print("\n")
def printPascalTriangle(numOfRows,unitLength):
space = " "
pascalTriangle = []
for i in range(numOfRows):
pascalTriangle.append([1]*(i+1))
for i in range(numOfRows):
for j in range(i):
if(i!=j) and j!=0:
pascalTriangle[i][j] = pascalTriangle[i - 1][j - 1] + pascalTriangle[i - 1][j]
for i in range(numOfRows):
#首元素缩进
beginSpace = space * ((numOfRows - i + 1) * unitLength)
print("%s" % (beginSpace), end="")
for j in range(i+1):
#字符串拼接+格式化输出
print(("%-" + str(unitLength*2) + "d") % (pascalTriangle[i][j]), end="")
print("\n")
if __name__ == '__main__':
isoscelesTriangle(10,4)
printPascalTriangle(10,4)
4.2.7 文件的读写
**材料:**德国手语数据集的三个文件phoenix2014T.dev.gloss
、phoenix2014T.dev.sign
、phoenix2014T.vocab.gloss
**需求:**将phoenix2014T.dev.gloss
中的gloss标签全部转换成数字标签,然后写入到phoenix2014T.dev.sign
中每个对应的视频的后面,以#
分割
def combineSignAndGloss():
parentPath = 'C:/workspace/PyCharm/PycharmProjects/testPython/txtFile/'
file1 = parentPath + 'phoenix2014T.dev.sign'
file2 = parentPath + 'phoenix2014T.dev.gloss'
file3 = parentPath + 'phoenix2014T.vocab.gloss'
file4 = parentPath + 'phoenix2014T_sign_numLabel.txt'
fo1 = open(file1,'r')
fo2 = open(file2,'r')
fo3 = open(file3,'r')
fw1 = open(file4,'w')
vocabLines = fo3.readlines()
vocabGloss = {}
for i,v in enumerate(vocabLines):
v = v.strip()
vocabGloss[v] = i
line1 = fo1.readline()
line2 = fo2.readline()
while line1 and line2:
videoPath = line1.strip()
glossLabel = line2.strip()
splitGlossLabel = glossLabel.split(' ')
strNumLabel = []
for l in splitGlossLabel:
if l in vocab_gloss.keys():
strNumLabel.append(str(vocabGloss[l]))
else:
strNumLabel.append(str(vocabGloss['<unk>']))
strNumLabel = " ".join(strNumLabel)
fw1.write("%s#%s\n"%(videoPath,strNumLabel))
line1 = fo1.readline()
line2 = fo2.readline()
if __name__ == '__main__':
combineSignAndGloss()
4.2.8 numpy的使用
Numpy:提供了一个在Python中做科学计算的基础库,重在数值计算,主要用于多维数组(矩阵)处理的库。用来存储和处理大型矩阵,比Python自身的嵌套列表结构要高效的多。本身是由C语言开发,是个很基础的扩展,Python其余的科学计算扩展大部分都是以此为基础。
- 高性能科学计算和数据分析的基础包
- ndarray,多维数组(矩阵),具有矢量运算能力,快速、节省空间
- 矩阵运算,无需循环,可完成类似Matlab中的矢量运算
- 线性代数、随机数生成
import numpy as np
import numpy as np
# list序列转换为 ndarray
lis = range(10)
arr = np.array(lis)
print(arr) # ndarray数据
print(arr.ndim) # 维度个数
print(arr.shape) # 维度大小
# list of list嵌套序列转换为ndarray
lis_lis = [range(10), range(10)]
arr = np.array(lis_lis)
print(arr) # ndarray数据
print(arr.ndim) # 维度个数
print(arr.shape) # 维度大小
# 多维数组
arr2 = np.arange(12).reshape(3,4)
print(arr2)
print(arr2[1])
print(arr2[0:2, 2:])
print(arr2[:, 1:3])
五、PaddlePaddle的安装
1.进入PaddlePaddle官网(PaddlePaddle官网),选择好自己的操作系统、安装方式、Python版本、CUDA版本
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-89gxCtVy-1619333938590)(深度学习框架paddlepaddle的简单使用.assets/image-20200422143005597.png)]
2.进入命令行界面,粘贴安装命令(默认安装paddlepaddle的最新版本,如果想安装指定版本可以在安装命令后面加上"==版本号")
1)安装指定版本的命令
python -m pip install paddlepaddle==1.7.1 -i https://mirror.baidu.com/pypi/simple
pip install 模块名 -i https://pypi.tuna.tsinghua.edu.cn/simple#使用清华镜像源安装软件的指令
六、PaddlePaddle的使用
1.基本概念
1).Tensor
在神经网络中传递的数据都是Tensor。Tensor可以简单理解成一个多维数组,一般而言可以有任意多的维度。 不同的Tensor可以具有自己的数据类型和形状,同一Tensor中每个元素的数据类型是一样的,Tensor的形状就是Tensor的维度。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jnx0OE6j-1619333938594)(深度学习框架paddlepaddle的简单使用.assets/tensor.jpg)]
2).Operator
在飞桨中,所有对数据的操作都由Operator表示,因为一些常见的对Tensor的操作可能是由更多基础操作构成,为了提高使用的便利性,框架内部对基础 Operator 进行了一些封装,包括创建 Operator 依赖可学习参数,可学习参数的初始化细节等,减少用户重复开发的成本。
3).Program
用户定义Operator会被顺序的放入Program中,最终构成想要的网络结构。
4).Executor
执行器,执行program中定义的运算。
5).place
指定执行器执行时所在的设备。
2.线性回归
- 用给定的样本训练一个线性模型
- 用训练好的模型进行预测
- 本例中训练样本是通过
x = np.linspace(-100, 100, 100)
和y = np.linspace(-100, 100, 100)
产生,x,y是-100~100之间均匀产生的100个数。z=x+y,这是三维空间中的一个平面.
from mpl_toolkits import mplot3d
import matplotlib.pyplot as plt
import numpy as np
import math
ax = plt.axes(projection='3d')
import paddle.fluid as fluid
import paddle.fluid.layers as layers
from visualdl import LogWriter
def print3Dgraph():
def f(x,y):
return x+y
#均匀的聪-100~100中产生100个数
x = np.linspace(-100, 100, 100)
y = np.linspace(-100, 100, 100)
X, Y = np.meshgrid(x, y)
Z = f(X,Y)
ax = plt.axes(projection='3d')
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='viridis', edgecolor='none')
ax.set_title('surface')
plt.show()
def f(x,y):
return x+y
def trainGenerate(batchSize=100):
X = np.linspace(-10, 10, 100)
Y = np.linspace(-10, 10, 100)
xy = []
rs_z = []
for x in X:
for y in Y:
z = f(x,y)
if len(xy)!=0 and len(xy)%batchSize==0:
yield np.array(xy).astype('float32'),np.array(rs_z).astype('float32').reshape(-1,1)
xy = []
rs_z = []
else:
xy.append([x,y])
rs_z.append(z)
def testGenerate(batchSize=5):
X = np.linspace(15, 20, 10)
Y = np.linspace(15, 20, 10)
xy = []
rs_z = []
for x in X:
for y in Y:
z = f(x, y)
if len(xy) != 0 and len(xy) % batchSize == 0:
yield np.array(xy).astype('float32'), np.array(rs_z).astype('float32').reshape(-1, 1)
xy = []
rs_z = []
else:
xy.append([x, y])
rs_z.append(z)
def train():
#定义Tensor
xy = fluid.data(name='xy', shape=[-1,2], dtype='float32')
z = fluid.data(name='z', shape=[-1,1], dtype='float32')
# 定义operator
predict = fluid.layers.fc(input=xy, size=1, name='fc_predict')
cost = fluid.layers.square_error_cost(input=predict, label=z) # 利用标签数据和输出的预测数据估计方差
avg_loss = fluid.layers.mean(cost) # 对方差求均值,得到平均损失
#定义优化器
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.0001)
sgd_optimizer.minimize(avg_loss)
# adam_optimizer = fluid.optimizer.AdamOptimizer(0.001)
# adam_optimizer.minimize(avg_loss)
# rms_optimizer = fluid.optimizer.RMSProp(learning_rate=0.001)
# rms_optimizer.minimize(avg_loss)
#获得program,一个用于运行时,一个用于初始化所有operator的参数
main_program = fluid.default_main_program()
startup_program = fluid.default_startup_program()
#定义place,即执行器执行的地方
use_cuda = False # 如想使用GPU,请设置为 True
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
# 定义执行器,并且指定定执行的设备为CPU
exe = fluid.Executor(place)
exe.run(startup_program)
# 创建 LogWriter 对象,记录运行时的loss等
log_writer = LogWriter("./model/recordLog", sync_cycle=20)
# 创建 scalar 组件,模式为 train
with log_writer.mode("train") as logger:
train_loss = logger.scalar("loss")
#迭代次数
EPOCH_NUM = 100
# 数据输入及训练过程
step = 0
for i in range(EPOCH_NUM):
for xy,z in trainGenerate():
avg_loss_, = exe.run(main_program,feed={'xy':xy,'z':z},fetch_list=[avg_loss])
# 向名称为 loss 的图中添加模式为train的数据
train_loss.add_record(step, avg_loss_[0])
print("epoch:{0},step:{1},avg_loss:{2}".format(i,step,avg_loss_[0]))
step += 1
# 保存预测模型。注意,用于预测的模型网络结构不需要保存标签和损失。
if i!=0 and i%100==0:
fluid.io.save_inference_model(dirname='./model/graph_model/'+'epoch_%d'%(i), feeded_var_names=['xy'], target_vars=[predict], executor=exe)
def infer():
place = fluid.CPUPlace()
infer_exe = fluid.Executor(place)
inference_scope = fluid.core.Scope()
with fluid.scope_guard(inference_scope):
[inference_program, feed_target_names,fetch_targets] = \
fluid.io.load_inference_model('./model/graph_model/epoch_100', infer_exe) # 载入预训练模型
for xy,z in testGenerate(batchSize=5):
z_predict = infer_exe.run(inference_program,feed={feed_target_names[0]: xy},fetch_list=fetch_targets)
print("predict",z_predict[0].flatten())
print("origin",z.flatten())
if __name__=='__main__':
train()
3.手写数字识别
from __future__ import print_function # 将python3中的print特性导入当前版本
import os
from PIL import Image # 导入图像处理模块
import matplotlib.pyplot as plt
import numpy as np
import paddle # 导入paddle模块
import paddle.fluid as fluid
from visualdl import LogWriter
# 一个minibatch中有64个数据
BATCH_SIZE = 64
# 每次读取训练集中的500个数据并随机打乱,传入batched reader中,batched reader 每次 yield 64个数据
train_reader = paddle.batch(
paddle.reader.shuffle(
paddle.dataset.mnist.train(), buf_size=500),
batch_size=BATCH_SIZE)
# 读取测试集的数据,每次 yield 64个数据
test_reader = paddle.batch(
paddle.dataset.mnist.test(), batch_size=BATCH_SIZE)
def viewMnist():
mnist_train = paddle.dataset.mnist.train()
mnist_test = paddle.dataset.mnist.test()
i=0
for data in mnist_train():
print('np_img',data[0].shape)
print('label',data[1])
img = np.reshape(data[0],[28,28])
label = data[1]
plt.imshow(img, cmap='Greys', interpolation='nearest')
if i==10:
break
plt.imsave('img/infer_%s.jpg'%(i),img)
i += 1
# plt.show()
def softmax_regression():
"""
定义softmax分类器:
一个以softmax为激活函数的全连接层
Return:
predict_image -- 分类的结果
"""
# 输入的原始图像数据,大小为28*28*1
img = fluid.data(name='img', shape=[None, 1, 28, 28], dtype='float32')
# 以softmax为激活函数的全连接层,输出层的大小必须为数字的个数10
predict = fluid.layers.fc(
input=img, size=10, act='softmax')
return predict
def multilayer_perceptron():
"""
定义多层感知机分类器:
含有两个隐藏层(全连接层)的多层感知器
其中前两个隐藏层的激活函数采用 ReLU,输出层的激活函数用 Softmax
Return:
predict_image -- 分类的结果
"""
# 输入的原始图像数据,大小为28*28*1
img = fluid.data(name='img', shape=[None, 1, 28, 28], dtype='float32')
# 第一个全连接层,激活函数为ReLU
hidden = fluid.layers.fc(input=img, size=200, act='relu')
# 第二个全连接层,激活函数为ReLU
hidden = fluid.layers.fc(input=hidden, size=200, act='relu')
# 以softmax为激活函数的全连接输出层,输出层的大小必须为数字的个数10
prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
return prediction
def conv_pool(input, num_filters, filter_size, pool_size, pool_stride, act="relu"):
"""
定义卷积池化层:
含有一个卷积层和一个池化层
Args:
input —— 网络输入
num_filters —— 卷积核的个数
filter_size —— 卷积核的大小
pool_size —— 池化核的大小
pool_stride —— 池化的步长
act —— 卷积层的激活函数
Return:
out -- 经过卷积池化后的特征图
"""
conv_out = fluid.layers.conv2d(
input=input,
num_filters=num_filters,
filter_size=filter_size,
act=act)
out = fluid.layers.pool2d(
input=conv_out,
pool_size=pool_size,
pool_stride=pool_stride)
return out
def convolutional_neural_network():
"""
定义卷积神经网络分类器:
输入的二维图像,经过两个卷积-池化层,使用以softmax为激活函数的全连接层作为输出层
Return:
predict -- 分类的结果
"""
# 输入的原始图像数据,大小为28*28*1
img = fluid.data(name='img', shape=[None, 1, 28, 28], dtype='float32')
# 第一个卷积-池化层
# 使用20个5*5的滤波器,池化大小为2,池化步长为2,激活函数为Relu
conv_pool_1 = conv_pool(
input=img,
filter_size=5,
num_filters=20,
pool_size=2,
pool_stride=2,
act="relu")
conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)
# 第二个卷积-池化层
# 使用50个5*5的滤波器,池化大小为2,池化步长为2,激活函数为Relu
conv_pool_2 = conv_pool(
input=conv_pool_1,
filter_size=5,
num_filters=50,
pool_size=2,
pool_stride=2,
act="relu")
# 以softmax为激活函数的全连接输出层,输出层的大小必须为数字的个数10
prediction = fluid.layers.fc(input=conv_pool_2, size=10, act='softmax')
return prediction
def optimizer_program():
return fluid.optimizer.Adam(learning_rate=0.001)
def train_program():
"""
配置train_program
Return:
predict -- 分类的结果
avg_cost -- 平均损失
acc -- 分类的准确率
"""
# 标签层,名称为label,对应输入图片的类别标签
label = fluid.data(name='label', shape=[None, 1], dtype='int64')
# predict = softmax_regression() # 取消注释将使用 Softmax回归
# predict = multilayer_perceptron() # 取消注释将使用 多层感知器
predict = convolutional_neural_network() # 取消注释将使用 LeNet5卷积神经网络
# 使用类交叉熵函数计算predict和label之间的损失函数
cost = fluid.layers.cross_entropy(input=predict, label=label)
# 计算平均损失
avg_cost = fluid.layers.mean(cost)
# 计算分类准确率
acc = fluid.layers.accuracy(input=predict, label=label)
return predict, [avg_cost, acc]
def event_handler(pass_id, batch_id, cost):
# 打印训练的中间结果,训练轮次,batch数,损失函数
print("Pass %d, Batch %d, Cost %f" % (pass_id,batch_id, cost))
def train():
# 该模型运行在单个CPU上
use_cuda = False # 如想使用GPU,请设置为 True
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
# 调用train_program 获取预测值,损失值,
prediction, [avg_loss, acc] = train_program()
# 输入的原始图像数据,名称为img,大小为28*28*1
# 标签层,名称为label,对应输入图片的类别标签
# 告知网络传入的数据分为两部分,第一部分是img值,第二部分是label值
feeder = fluid.DataFeeder(feed_list=['img', 'label'], place=place)
# 选择Adam优化器
optimizer = optimizer_program()
optimizer.minimize(avg_loss)
PASS_NUM = 5 #训练5轮
epochs = [epoch_id for epoch_id in range(PASS_NUM)]
# 将模型参数存储在名为 save_dirname 的文件中
save_dirname = "./model/graphModel"
def train_test(train_test_program,
train_test_feed, train_test_reader):
# 将分类准确率存储在acc_set中
acc_set = []
# 将平均损失存储在avg_loss_set中
avg_loss_set = []
# 将测试 reader yield 出的每一个数据传入网络中进行训练
for test_data in train_test_reader():
acc_np, avg_loss_np = exe.run(
program=train_test_program,
feed=train_test_feed.feed(test_data),
fetch_list=[acc, avg_loss])
acc_set.append(float(acc_np))
avg_loss_set.append(float(avg_loss_np))
# 获得测试数据上的准确率和损失值
acc_val_mean = np.array(acc_set).mean()
avg_loss_val_mean = np.array(avg_loss_set).mean()
# 返回平均损失值,平均准确率
return avg_loss_val_mean, acc_val_mean
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
main_program = fluid.default_main_program()
test_program = fluid.default_main_program().clone(for_test=True)
# 创建 LogWriter 对象,记录运行时的loss等
log_writer = LogWriter("./model/recordLog", sync_cycle=20)
# 创建 scalar 组件,模式为 train
with log_writer.mode("train") as logger:
train_loss = logger.scalar("loss")
lists = []
step = 0
for epoch_id in epochs:
for step_id, data in enumerate(train_reader()):
metrics = exe.run(main_program,
feed=feeder.feed(data),
fetch_list=[avg_loss, acc])
if step % 100 == 0: #每训练100次 打印一次log
print("Pass %d, Batch %d, Cost %f" % (step, epoch_id, metrics[0]))
# event_handler_plot(train_prompt, step, metrics[0])
train_loss.add_record(step, metrics[0])
step += 1
# 测试每个epoch的分类效果
avg_loss_val, acc_val = train_test(train_test_program=test_program,
train_test_reader=test_reader,
train_test_feed=feeder)
print("Test with Epoch %d, avg_cost: %s, acc: %s" %(epoch_id, avg_loss_val, acc_val))
# event_handler_plot(test_prompt, step, metrics[0])
lists.append((epoch_id, avg_loss_val, acc_val))
# 保存训练好的模型参数用于预测
fluid.io.save_inference_model(save_dirname,
["img"], [prediction], exe,
model_filename=None,
params_filename=None)
# 选择效果最好的pass
best = sorted(lists, key=lambda list: float(list[1]))[0]
print('Best pass is %s, testing Avgcost is %s' % (best[0], best[1]))
print('The classification accuracy is %.2f%%' % (float(best[2]) * 100))
def load_image(file):
# 读取图片文件,并将它转成灰度图
im = Image.open(file).convert('L')
# 将输入图片调整为 28*28 的高质量图
im = im.resize((28, 28), Image.ANTIALIAS)
# 将图片转换为numpy
im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
# 对数据作归一化处理
im = im / 255.0 * 2.0 - 1.0
return im
def infer():
inference_scope = fluid.core.Scope()
place = fluid.CPUPlace()
infer_exe = exe = fluid.Executor(place)
save_dirname = "./model/graphModel"
with fluid.scope_guard(inference_scope):
# 使用 fluid.io.load_inference_model 获取 inference program desc,
# feed_target_names 用于指定需要传入网络的变量名
# fetch_targets 指定希望从网络中fetch出的变量名
[inference_program, feed_target_names,
fetch_targets] = fluid.io.load_inference_model(
save_dirname, infer_exe, None, None)
# 将feed构建成字典 {feed_target_name: feed_target_data}
# 结果将包含一个与fetch_targets对应的数据列表
imgFilePath = 'D:/Workspace/PyCharm/PaddleTeset/手写数字识别/img/infer_4.jpg'
tensor_img = load_image(imgFilePath)
results = exe.run(inference_program,
feed={feed_target_names[0]: tensor_img},
fetch_list=fetch_targets)
lab = np.argsort(results)
# 打印 infer_3.png 这张图片的预测结果
img=Image.open(imgFilePath)
plt.imshow(img)
plt.show()
print("Inference result of %s is: %d" % (imgFilePath.split('/')[-1],lab[0][0][-1]))
if __name__=='__main__':
infer()
五、AIStudio的使用
1.AIStudio简介
AIStudio官方地址(AIStudio),注册之后可以获得免费的算力资源,每天登录可以获得12小时的GPU(16g显存)使用时间,也有很多现成的项目可以供运行测试。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mxs5tQuV-1619333938599)(深度学习框架paddlepaddle的简单使用.assets/image-20200422202950098.png)]
2.算力资源
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8baE6KvG-1619333938601)(深度学习框架paddlepaddle的简单使用.assets/image-20200422203126559.png)]
同志们薅羊毛吧!!!