深度学习系列用paddlepaddle和tensorflow实现经典cnn网络vgg

 1 #coding:utf-8
 2 '''
 3 Created by huxiaoman 2017.12.12
 4 vggnet.py:用vgg网络实现cifar-10分类
 5 '''
 6 
 7 import paddle.v2 as paddle
 8 
 9 def vgg(input):
10     def conv_block(ipt, num_filter, groups, dropouts, num_channels=None):
11         return paddle.networks.img_conv_group(
12             input=ipt,
13             num_channels=num_channels,
14             pool_size=2,
15             pool_stride=2,
16             conv_num_filter=[num_filter] * groups,
17             conv_filter_size=3,
18             conv_act=paddle.activation.Relu(),
19             conv_with_batchnorm=True,
20             conv_batchnorm_drop_rate=dropouts,
21             pool_type=paddle.pooling.Max())
22 
23     conv1 = conv_block(input, 64, 2, [0.3, 0], 3)
24     conv2 = conv_block(conv1, 128, 2, [0.4, 0])
25     conv3 = conv_block(conv2, 256, 3, [0.4, 0.4, 0])
26     conv4 = conv_block(conv3, 512, 3, [0.4, 0.4, 0])
27     conv5 = conv_block(conv4, 512, 3, [0.4, 0.4, 0])
28 
29     drop = paddle.layer.dropout(input=conv5, dropout_rate=0.5)
30     fc1 = paddle.layer.fc(input=drop, size=512, act=paddle.activation.Linear())
31     bn = paddle.layer.batch_norm(
32         input=fc1,
33         act=paddle.activation.Relu(),
34         layer_attr=paddle.attr.Extra(drop_rate=0.5))
35     fc2 = paddle.layer.fc(input=bn, size=512, act=paddle.activation.Linear())
36     return fc2

  1 #coding:utf-8
  2 '''
  3 Created by huxiaoman 2017.12.12
  4 train_vgg.py:训练vgg16对cifar10数据集进行分类
  5 '''
  6 
  7 import sys, os
  8 import paddle.v2 as paddle
  9 from vggnet import vgg
 10 
 11 with_gpu = os.getenv('WITH_GPU', '0') != '1'
 12 
 13 def main():
 14     datadim = 3 * 32 * 32
 15     classdim = 10
 16 
 17     # PaddlePaddle init
 18     paddle.init(use_gpu=with_gpu, trainer_count=8)
 19 
 20     image = paddle.layer.data(
 21         name="image", type=paddle.data_type.dense_vector(datadim))
 22     
 23     net = vgg(image)
 24 
 25     out = paddle.layer.fc(
 26         input=net, size=classdim, act=paddle.activation.Softmax())
 27 
 28     lbl = paddle.layer.data(
 29         name="label", type=paddle.data_type.integer_value(classdim))
 30     cost = paddle.layer.classification_cost(input=out, label=lbl)
 31 
 32     # Create parameters
 33     parameters = paddle.parameters.create(cost)
 34 
 35     # Create optimizer
 36     momentum_optimizer = paddle.optimizer.Momentum(
 37         momentum=0.9,
 38         regularization=paddle.optimizer.L2Regularization(rate=0.0002 * 128),
 39         learning_rate=0.1 / 128.0,
 40         learning_rate_decay_a=0.1,
 41         learning_rate_decay_b=50000 * 100,
 42         learning_rate_schedule='discexp')
 43 
 44     # End batch and end pass event handler
 45     def event_handler(event):
 46         if isinstance(event, paddle.event.EndIteration):
 47             if event.batch_id % 100 == 0:
 48                 print "\nPass %d, Batch %d, Cost %f, %s" % (
 49                     event.pass_id, event.batch_id, event.cost, event.metrics)
 50             else:
 51                 sys.stdout.write('.')
 52                 sys.stdout.flush()
 53         if isinstance(event, paddle.event.EndPass):
 54             # save parameters
 55             with open('params_pass_%d.tar' % event.pass_id, 'w') as f:
 56                 parameters.to_tar(f)
 57 
 58             result = trainer.test(
 59                 reader=paddle.batch(
 60                     paddle.dataset.cifar.test10(), batch_size=128),
 61                 feeding={'image': 0,
 62                          'label': 1})
 63             print "\nTest with Pass %d, %s" % (event.pass_id, result.metrics)
 64 
 65     # Create trainer
 66     trainer = paddle.trainer.SGD(
 67         cost=cost, parameters=parameters, update_equation=momentum_optimizer)
 68 
 69     # Save the inference topology to protobuf.
 70     inference_topology = paddle.topology.Topology(layers=out)
 71     with open("inference_topology.pkl", 'wb') as f:
 72         inference_topology.serialize_for_inference(f)
 73 
 74     trainer.train(
 75         reader=paddle.batch(
 76             paddle.reader.shuffle(
 77                 paddle.dataset.cifar.train10(), buf_size=50000),
 78             batch_size=128),
 79         num_passes=200,
 80         event_handler=event_handler,
 81         feeding={'image': 0,
 82                  'label': 1})
 83 
 84     # inference
 85     from PIL import Image
 86     import numpy as np
 87     import os
 88 
 89     def load_image(file):
 90         im = Image.open(file)
 91         im = im.resize((32, 32), Image.ANTIALIAS)
 92         im = np.array(im).astype(np.float32)
 93         im = im.transpose((2, 0, 1))  # CHW
 94         im = im[(2, 1, 0), :, :]  # BGR
 95         im = im.flatten()
 96         im = im / 255.0
 97         return im
 98 
 99     test_data = []
100     cur_dir = os.path.dirname(os.path.realpath(__file__))
101     test_data.append((load_image(cur_dir + '/image/dog.png'), ))
102 
103     probs = paddle.infer(
104         output_layer=out, parameters=parameters, input=test_data)
105     lab = np.argsort(-probs)  # probs and lab are the results of one batch data
106     print "Label of image/dog.png is: %d" % lab[0][0]
107 
108 
109 if __name__ == '__main__':
110     main()

 1 def inference_op(input_op, keep_prob):
 2     p = []
 3     # 第一块 conv1_1-conv1_2-pool1
 4     conv1_1 = conv_op(input_op, name='conv1_1', kh=3, kw=3,
 5                 n_out = 64, dh = 1, dw = 1, p = p)
 6     conv1_2 = conv_op(conv1_1, name='conv1_2', kh=3, kw=3,
 7                 n_out = 64, dh = 1, dw = 1, p = p)
 8     pool1 = mpool_op(conv1_2, name = 'pool1', kh = 2, kw = 2,
 9                 dw = 2, dh = 2)
10     # 第二块 conv2_1-conv2_2-pool2
11     conv2_1 = conv_op(pool1, name='conv2_1', kh=3, kw=3,
12                 n_out = 128, dh = 1, dw = 1, p = p)
13     conv2_2 = conv_op(conv2_1, name='conv2_2', kh=3, kw=3,
14                 n_out = 128, dh = 1, dw = 1, p = p)
15     pool2 = mpool_op(conv2_2, name = 'pool2', kh = 2, kw = 2,
16                 dw = 2, dh = 2)
17     # 第三块 conv3_1-conv3_2-conv3_3-pool3
18     conv3_1 = conv_op(pool2, name='conv3_1', kh=3, kw=3,
19                 n_out = 256, dh = 1, dw = 1, p = p)
20     conv3_2 = conv_op(conv3_1, name='conv3_2', kh=3, kw=3,
21                 n_out = 256, dh = 1, dw = 1, p = p)
22     conv3_3 = conv_op(conv3_2, name='conv3_3', kh=3, kw=3,
23                 n_out = 256, dh = 1, dw = 1, p = p)
24     pool3 = mpool_op(conv3_3, name = 'pool3', kh = 2, kw = 2,
25                 dw = 2, dh = 2)
26     # 第四块 conv4_1-conv4_2-conv4_3-pool4
27     conv4_1 = conv_op(pool3, name='conv4_1', kh=3, kw=3,
28                 n_out = 512, dh = 1, dw = 1, p = p)
29     conv4_2 = conv_op(conv4_1, name='conv4_2', kh=3, kw=3,
30                 n_out = 512, dh = 1, dw = 1, p = p)
31     conv4_3 = conv_op(conv4_2, name='conv4_3', kh=3, kw=3,
32                 n_out = 512, dh = 1, dw = 1, p = p)
33     pool4 = mpool_op(conv4_3, name = 'pool4', kh = 2, kw = 2,
34                 dw = 2, dh = 2)
35     # 第五块 conv5_1-conv5_2-conv5_3-pool5
36     conv5_1 = conv_op(pool4, name='conv5_1', kh=3, kw=3,
37                 n_out = 512, dh = 1, dw = 1, p = p)
38     conv5_2 = conv_op(conv5_1, name='conv5_2', kh=3, kw=3,
39                 n_out = 512, dh = 1, dw = 1, p = p)
40     conv5_3 = conv_op(conv5_2, name='conv5_3', kh=3, kw=3,
41                 n_out = 512, dh = 1, dw = 1, p = p)
42     pool5 = mpool_op(conv5_3, name = 'pool5', kh = 2, kw = 2,
43                 dw = 2, dh = 2)
44     # 把pool5 ( [7, 7, 512] )  拉成向量
45     shp  = pool5.get_shape()
46     flattened_shape = shp[1].value * shp[2].value * shp[3].value
47     resh1 = tf.reshape(pool5, [-1, flattened_shape], name = 'resh1')
48 
49     # 全连接层1 添加了 Droput来防止过拟合    
50     fc1 = fc_op(resh1, name = 'fc1', n_out = 2048, p = p)
51     fc1_drop = tf.nn.dropout(fc1, keep_prob, name = 'fc1_drop')
52 
53     # 全连接层2 添加了 Droput来防止过拟合    
54     fc2 = fc_op(fc1_drop, name = 'fc2', n_out = 2048, p = p)
55     fc2_drop = tf.nn.dropout(fc2, keep_prob, name = 'fc2_drop')
56 
57     # 全连接层3 加一个softmax求给类别的概率
58     fc3 = fc_op(fc2_drop, name = 'fc3', n_out = 10, p = p)
59     softmax = tf.nn.softmax(fc3)
60     predictions = tf.argmax(softmax, 1)
61     return predictions, softmax, fc3, p

  1 # -*- coding: utf-8 -*-
  2 """
  3 Created by huxiaoman 2017.12.12
  4 vgg_tf.py:训练tensorflow版的vgg16网络，对cifar-10shuju进行分类
  5 """
  6 from datetime import datetime
  7 import math
  8 import time
  9 import tensorflow as tf
 10 import cifar10
 11 
 12 batch_size = 128
 13 num_batches = 200
 14 
 15 # 定义函数对卷积层进行初始化
 16 # input_op : 输入数据 
 17 # name : 该卷积层的名字，用tf.name_scope()来命名
 18 # kh,kw : 分别是卷积核的高和宽
 19 # n_out : 输出通道数
 20 # dh,dw : 步长的高和宽
 21 # p ： 是参数列表，存储VGG所用到的参数
 22 # 采用xavier方法对卷积核权值进行初始化
 23 def conv_op(input_op, name, kh, kw, n_out, dh, dw, p):
 24     n_in = input_op.get_shape()[-1].value # 获得输入图像的通道数
 25     with tf.name_scope(name) as scope:
 26         kernel = tf.get_variable(scope+'w',
 27             shape = [kh, kw, n_in, n_out], dtype = tf.float32,
 28             initializer = tf.contrib.layers.xavier_initializer_conv2d())
 29         #  卷积层计算
 30         conv = tf.nn.conv2d(input_op, kernel, (1, dh, dw, 1), padding = 'SAME')
 31         bias_init_val = tf.constant(0.0, shape = [n_out], dtype = tf.float32)
 32         biases = tf.Variable(bias_init_val, trainable = True, name = 'b')
 33         z = tf.nn.bias_add(conv, biases)
 34         activation = tf.nn.relu(z, name = scope)
 35         p += [kernel, biases]
 36         return activation
 37 
 38 # 定义函数对全连接层进行初始化
 39 # input_op : 输入数据
 40 # name : 该全连接层的名字
 41 # n_out : 输出的通道数
 42 # p : 参数列表 
 43 # 初始化方法用 xavier方法
 44 def fc_op(input_op, name, n_out, p):
 45     n_in = input_op.get_shape()[-1].value
 46 
查看详情  

                
深度学习系列paddlepaddle之数据预处理
...识和手写CNN，但是有很多同学跟我发邮件或私信问我关于PaddlePaddle如何读取数据、做数据预处理相关的内容。网上看的很多教程都是几个常见的例子，数据集不需要自己准备，所以不需要关心，但是实际做项目的时候做数据预处...  查看详情  
                
paddlepaddle系列手写数字识别(代码片段)
 最近百度为了推广自家编写对深度学习框架PaddlePaddle不断推出各种比赛。百度声称PaddlePaddle是一个“易学、易用”的开源深度学习框架，然而网上的资料少之又少。虽然百度很用心地提供了许多文档，而且还是中英双语具备...  查看详情  
                
全开源深度学习平台paddlepaddle入手之路----利用docker在windows10专业版环境下配置paddlepaddle
利用Docker在Windows10专业版环境下配置PaddlePaddle    对于PaddlePaddle的安装，查询官网信息，PaddlePaddle提供pip安装和Docker安装运行的使用方式。我们已经了解到Docker在避免环境配置难题上的的巨大优势，加上本人用的是...  查看详情  
                
百度正式发布paddlepaddle深度强化学习框架parl
...发布在赛事夺冠中起到关键作用的深度强化学习框架 PaddlePaddlePARL，同时开源了基于该框架的NeurIPS2018强化学习赛事的完整训练代码。点击“阅读原文”可查看冠军解决方案。 PaddlePaddlePARL的名字来源于PAddlepaddle Reinfoce...  查看详情  
                
叮！你有一条来自百度深度学习公开课的消息待查看
作为百度自主研发的深度学习平台，PaddlePaddle的易学易用和灵活高效极大地降低了开发者的研发门槛。为帮助开发者打造一条深度学习快速进阶之路，百度开设了“深度学习公开课”，从PaddlePaddle开发基础与功能、深度学习工程...  查看详情  
                
百度paddlepaddle常规赛nlp赛道火热开启
...是人工智能最热门、企业投入最多的研究领域之一，百度PaddlePaddle深度学习框架应运而生，这是国内唯一一家拥有自主知识产权的开源深度学习框架。在此框架中，汇聚了更多的AI科学家、架构师、AI爱好者，设置常规赛，提供...  查看详情  
                
paddlepaddle：在serverless架构上十几行代码实现ocr能力
...式和命令式编程，兼具开发的灵活性和高性能。飞桨(PaddlePaddle)以百度多年的深度学习技术研究和业务应用为基础，是中国首个自主研发、功能完备、开源开放的产业级深度学习平台，集深度学习核心训练和推理框架...  查看详情  
                
paddlepaddle：在serverless架构上十几行代码实现ocr能力
...式和命令式编程，兼具开发的灵活性和高性能。飞桨(PaddlePaddle)以百度多年的深度学习技术研究和业务应用为基础，是中国首个自主研发、功能完备、开源开放的产业级深度学习平台，集深度学习核心训练和推理框架...  查看详情  
                
深度学习系列1深度学习在腾讯的平台化和应用实践（转载）
转载：原文链接【深度学习系列1】深度学习在腾讯的平台化和应用实践引言：深度学习是近年机器学习领域的重大突破，有着广泛的应用前景。随着Google公开GoogleBrain计划，业界对深度学习的热情高涨。腾讯在深度学习领域持续...  查看详情  
                
百度paddlepaddle入门-8(代码片段)
 数字识别是计算机从纸质文档、照片或其他来源接收、理解并识别可读的数字的能力，目前比较受关注的是手写数字识别。手写数字识别是一个典型的图像分类问题，已经被广泛应用于汇款单号识别、手写邮政编码识别，大...  查看详情  
                
paddlepaddle使用
paddlepaddle是百度提出来的深度学习的框架，个人感觉其实和tensorflow差不多(语法上面)，因为本人也是初学者，也不是很懂tensorflow，所以，这些都是个人观点。百度的paddlepaddle提出貌似有一段时间了，我是最近才知道的，好奇去...  查看详情  
                
paddlepaddle应用于百度视觉技术的工程实践
...的出现，某种程度上改变了我们对计算机视觉的定义。而PaddlePaddle是百度开源的深度学习框架，它是如何支持百度视觉技术，有哪些工程实践，这篇文章将由百度视觉技术部主任研发架构师刘国翌为大家解答。以下为刘国翌老师...  查看详情  
                
深度学习课程介绍
课程框架：Python基础机器学习入门知识重点讲解深度学习框架PaddlePaddle入门知识图像识别与深度学习卷积神经网络深度学习进阶在百度AIStudio平台进行项目实践  查看详情  
                
浅说深度学习
...普挺好，所以就转载过来了　　本文旨在提供直观简明的深度学习引导，涵盖深度学习的基本概念，而不涉及很多数学和理论细节。当然如果要做更深入的研究，数学肯定是必不可少的，但是本系列主要还是用图片和类比等方式...  查看详情  
                
百度paddlepaddle再获新技能智能推荐对话系统控制领域都能搞定！
...都离不开底层深度学习框架的支持。近日，百度深度学习PaddlePaddle正式发布了强化学习框架PARL，同时开源了基于该框架，在NeurIPS2018强化学习赛事中夺冠的模型完整训练代码，再次向业界展示了百度在深度学习领域的技术能力。...  查看详情  
                
深度学习系列44.siren和deep-daze模型(代码片段)
1.SirenSiren就是用sin函数代替原先的激活函数（例如ReLU）1.1代码实现首先定义一个sineLayer层，输出为sin(ω0f(x))sin(\\omega_0f(x))sin(ω0​f(x))，其中f(x)为全连接层。classSineLayer(nn.Module):def__init__(self,in_features  查看详情  
                
百度paddlepaddle再获新技能智能推荐对话系统控制领域都能搞定！
...都离不开底层深度学习框架的支持。近日，百度深度学习PaddlePaddle正式发布了强化学习框架PARL，同时开源了基于该框架，在NeurIPS2018强化学习赛事中夺冠的模型完整训练代码，再次向业界展示了百度在深度学习领域的技术能力。...  查看详情