notebook1

最新推荐文章于 2022-12-19 17:18:31 发布

Jacklucicc

最新推荐文章于 2022-12-19 17:18:31 发布

阅读量436

点赞数 2

分类专栏： notebook

本文链接：https://blog.csdn.net/weixin_44811068/article/details/116129299

版权

notebook 专栏收录该内容

1 篇文章 1 订阅

订阅专栏

深度学习框架paddlepaddle的简单使用

一、深度学习框架简介

名称	机构	支持语言	简介
tensorflow	Google	Python/C++	一个用于机器智能的开源软件库，多用于工业界
pytorch	Facebook	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)]

同志们薅羊毛吧！！！

Jacklucicc

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
notebook1

深度学习框架paddlepaddle的简单使用一、深度学习框架简介名称机构支持语言简介tensorflowGooglePython/C++一个用于机器智能的开源软件库，多用于工业界pytorchFacebookPython一个开源的Python机器学习库，多用于学术界caffeBVLCC++/Python老牌深度学习框架paddlepaddle百度C++/Python源于产业实践的开源深度学习平台kerasFrançois Cho
复制链接

扫一扫