Android 与tensorflow的基本功教程

作者:ca88编程

ca88编程 1f703bcab-69dd-4203-bd44-98e752ff8126.png.png然则在一张图片中,十分八的区域都以非边缘,为掌握决边缘和非边缘不平衡的标题,杂谈引进了三个类平衡圈子β,用它来定义大家在公式中用到的类平衡交叉熵函数△:ca88编程 26b3b50c8-7eaf-4e06-a3d2-52fa8455c1b5.png.png当中I,I-和I 分别代表总像素,非边缘像素和边缘像素的个数。βj=I-/I,1-βj=I /I。

ca88编程 3

1.1 常量与变量

Tensorflow中最中央的单元是常量、变量和占位符。

tf.constant(卡塔尔国和tf.Variable(卡塔尔国之间的不一致很了然;叁个常量有着固定不改变的值,黄金年代旦设置了它,它的值无法被改动。而变量的值能够在装置达成后转移,但变量的数据类型和造型不能改观。

#We can create constants and variables of different types.

#However, the different types do not mix well together.

a = tf.constant(2, tf.int16)

b = tf.constant(4, tf.float32)

c = tf.constant(8, tf.float32)

d = tf.Variable(2, tf.int16)

e = tf.Variable(4, tf.float32)

f = tf.Variable(8, tf.float32)

#we can perform computations on variable of the same type: e f

#but the following can not be done: d e

#everything in Tensorflow is a tensor, these can have different dimensions:

#0D, 1D, 2D, 3D, 4D, or nD-tensors

g = tf.constant(np.zeros(shape=(2,2), dtype=np.float32)) #does work

h = tf.zeros([11], tf.int16)

i = tf.ones([2,2], tf.float32)

j = tf.zeros([1000,4,3], tf.float64)

k = tf.Variable(tf.zeros([2,2], tf.float32))

l = tf.Variable(tf.zeros([5,6,5], tf.float32))

除开tf.zeros(卡塔尔(قطر‎和tf.ones(State of Qatar能够成立多少个最初值为0或1的张量(见这里)之外,还应该有三个tf.random_normal(卡塔尔国函数,它能够创制三个带有多少个随机值的张量,那一个随机值是从正态分布中随性所欲收取的(默许的分布均值为0.0,规范差为1.0)。

别的还应该有八个tf.truncated_normal(State of Qatar函数,它创设了一个含有从截断的正态分布中率性抽取的值的张量,此中下上限是标准不是的两倍。

有了那么些文化,大家就足以成立用于神经网络的权重矩阵和错误向量了。

weights = tf.Variable(tf.truncated_normal([256 * 256, 10]))

biases = tf.Variable(tf.zeros([10]))

print(weights.get_shape().as_list())

print(biases.get_shape().as_list())

>>>[65536, 10]

>>>[10]

CNN(Convolutional Neural Network)

计算:那篇杂文提议的HED方法进行边缘检验照旧很可信赖的,它提出的这种从深度网络的每生机勃勃层引二个侧边输出出来再开展混合的酌量也得以借鉴。

v2-358f29d5d8fab3ed6bea88ca7075f3a9_b.png

2.4 Tensorflow的多少个地点

Tensorflow包括大多层,那意味能够经过不相同的虚幻品级来完毕相近的操作。这里有一个差非常的少的例证,操作

logits = tf.matmul(tf_train_dataset, weights) biases,

也足以如此来兑现

logits = tf.nn.xw_plus_b(train_dataset, weights, biases)。

这是layers API中最令人瞩指标生机勃勃层,它是多个享有中度抽象性的层,能够十分轻易地创立由众多两样层组成的神经互连网。举例,conv_2d()或fully_connected()函数用于创立卷积和完全连接的层。通过那个函数,能够将层数、过滤器的大小或深度、激活函数的品类等钦点为参数。然后,权重矩阵和偏置矩阵会自动创造,一同开创的还大概有激活函数和抛弃正则化层(dropout regularization laye卡塔尔(قطر‎。

诸如,通过行使 层API,下边那个代码:

import Tensorflow as tf

w1 = tf.Variable(tf.truncated_normal([filter_size, filter_size, image_depth, filter_depth], stddev=0.1))

b1 = tf.Variable(tf.zeros([filter_depth]))

layer1_conv = tf.nn.conv2d(data, w1, [1, 1, 1, 1], padding='SAME')

layer1_relu = tf.nn.relu(layer1_conv b1)

layer1_pool = tf.nn.max_pool(layer1_pool, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')

能够更动为

from tflearn.layers.conv import conv_2d, max_pool_2d

layer1_conv = conv_2d(data, filter_depth, filter_size, activation='relu')

layer1_pool = max_pool_2d(layer1_conv_relu, 2, strides=2)

能够看到,大家无需定义权重、偏差或激活函数。非常是在您建设构造一个兼有许多层的神经互连网的时候,那样能够保持代码的清晰和卫生。

唯独,纵然你刚刚接触Tensorflow的话,学习怎么着营造分裂类别的神经网络并不确切,因为tflearn做了全数的干活。

故而,大家不会在本文中央银行使层API,然则意气风发旦你完全知晓了怎么在Tensorflow中构建神经网络,小编可能提议你使用它。

Environment

  • TensorFlow: 1.2.0
  • Python: 3.6
  • Python IDE: PyCharm 2017.2
  • Android IDE: Android Studio 3.0

ca88编程 43847bf0c-cd4b-41e4-8dd4-135248e3壹玖伍柒.png.pngHED的思谋根源多规格&多等级学习的定义,有的是通过内在互联网布局的多规格学习,有的是通过缩放扭曲图片打开的,上海教室的a-d就是作者列出的部分共处的多规格&多等第学习的神经网络。前八个互连网的主题素材是唯有单风流倜傥的输出层,所以只有多个估计结果,而在边缘检测中获得多少个预测结果然后将有所的边缘映射平均是更有益的。 而图c中的方法平时越多用来不依靠深度学习的格局,因为它会大大减少学习种类的猜度作用。而作为图a的变种,图d中的方法分别训练多少个差别层级的网络,不过这么会招致急需数倍的教练多少。而本诗歌建议的HED方法就改正自图d中的方法,如图e所示,它将同一个纵深学习互连网的两样层级侧边输出(side output)。

  • 教练集效果还是可以,99.30%,实际上由于有关cifar10的教练张开的次数超少,在此以前用vgg16直达过1.000, 很难说那些比率是或不是真的高,损失0.0082

  • 测量试验集74.39%,简单来讲现身了过拟合的光景,loss的不定也极其大,

  • 寻思解决方案, 参预dropout(0.5卡塔尔尝试,出席学习率衰减,是或不是因为模型过于复杂,因为resnet在Imagenet上的变现最佳,Imagenet的图像容积要远抢先cifar10

2.1 简介

包涵神经互联网的图(如上海体育地方所示)应包括以下步骤:

输入数据集:训练数据集和标签、测验数据集和标签(以致表明数据集和标签)。

测量检验和认证数据集能够放在tf.constant(卡塔尔(قطر‎中。而教练多少集被放在tf.placeholder(卡塔尔中,那样它能够在训练期间分批输入(随机梯度下落)。

神经互联网模型连同全体的层。那足以是二个粗略的一丝一毫连接的神经互联网,仅由黄金年代层组成,或许由5、9、16层组成的更头昏眼花的神经互连网。

权重矩阵错误矢量以方便的形状举行定义和起初化。(每层三个权重矩阵和偏差矢量)

损失值:模型能够出口分对数矢量(测度的教练标签),并通过将分对数与实际标签进行比较,总计出损失值(具备交叉熵函数的softmax)。损失值表示测度操练标签与事实上演习标签的相同程度,并用于更新权重值。

优化器:它用于将总结拿到的损失值来更新反向传播算法中的权重和不是。

Theory

权重混合数层为了最佳地使用本散文提议的布局中的每种侧输出层的结果,大家扩张了八个“权重混合层”用来将兼具的侧输出层的前瞻结果三翻五次到一块同有时候在练习的进度中上学混合权重。大家将混合权重记为h,混合权重层的损失函数如下:

程序没有管每个节点的命名, 主路1,3,1结构,侧路1结构
def conv_block(input_tensor, filters):
    filter1, filter2, filter3 = filters

    x = Conv2D(filter1,(1,1),strides=1)(input_tensor)
    x = BatchNormalization(axis=-1)(x)
    x = Activation('relu')(x)

    x = Conv2D(filter2,(3,3),strides=1,padding='same')(x)
    x = BatchNormalization(axis=-1)(x)
    x = Activation('relu')(x)

    x = Conv2D(filter3,(1,1),strides=1)(x)
    x = BatchNormalization(axis=-1)(x)
    x = Activation('relu')(x)

    y = Conv2D(filter3,(1,1),strides=1)(input_tensor)
    y = BatchNormalization(axis=-1)(y)
    y = Activation('relu')(y)

    out = merge([x,y],mode='sum')
    z = Activation('relu')(out)

    return z

2.8 学习速率和优化器的震慑

让大家来拜谒那个CNN在MNIST和CIFAHaval-10数据集上的变现。

在上面的图中,测量试验集的精度是迭代次数的函数。左边为后生可畏层完全连接的NN,中间为LeNet5 NN,左侧为类LeNet5 NN。

能够看出,LeNet5 CNN在MNIST数据集上展现得格外好。那并非三个大惊奇,因为它特别正是为分类手写数字而规划的。MNIST数据集超小,并从未太大的挑战性,所以固然是一个通通连接的网络也显现的很好。

而是,在CIFARubicon-10数据集上,LeNet5 NN的品质显着下跌,精度降到了40%左右。

为了拉长精度,大家能够通过行使正则化或上学速率衰减来改造优化器,大概微调神经网络。

能够看来,艾达gradOptimizer、AdamOptimizer和RMSPropOptimizer的质量比GradientDescentOptimizer更加好。那一个都以自适应优化器,其性质日常比GradientDescentOptimizer更加好,但须求越来越多的总结本领。

透过L2正则化或指数速率衰减,我们兴许会博得更搞的正确性,不过要得到越来越好的结果,大家要求越来越商讨。

MNIST

MNIST,最杰出的机械学习模型之意气风发,包罗0~9的数字,28*28轻重的单色灰度手写数字图片数据库,此中国共产党60,000 training examples和10,000 test examples。
文件目录如下,紧要包含4个二进制文件,分别为练习和测量试验图片及Label。如下为操练图片的二进制结构,在真实数据前(pixel),有部分陈述字段(魔数,图片个数,图片行数和列数),真实数据的蕴藏选用大端准绳。(大端准绳,正是多少的高字节保存在低内部存款和储蓄器地址中,低字节保存在高内部存款和储蓄器地址中)在实际实验应用,供给领取真实数据,可应用专门用于拍卖字节的库struct中的unpack_from方法,主题措施如下: struct.unpack_from(self._fourBytes2, buf, index)

ca88编程 5

image

ca88编程 6

image.png

MNIST作为AI的Hello World入门实例数据,TensorFlow封装对其包装好了函数,可径直利用
mnist = input_data.read_data_sets('MNIST', one_hot=True)

ca88编程 72ad5a9b5-6939-4451-8181-2bf62c9f171c.png.png所以总体的损失函数为:ca88编程 88cd9b33f-de83-464d-9ab4-5a18e94a35ea.png.png

data  1,3,224,224

conv  filter=64, kernel_size=7, pad=3,stride=2 1,64,112,112

bn

activation('relu')

maxpool kernel_size=3,stride=2  1,64,56,56

# block 1  (64,64,256)
conv_block() in:1,64,56,56 filter=(64,64,256),out=1,256,56,56

identity_block  in=1,256,56,56, filter=(64,64,256),out=1,256,56,56

identity_block  in=1,256,56,56, filter=(64,64,256),out=1,256,56,56

# block 2  (128,128,512)

conv_block  in=1,256,56,56 filter=(128,128,512),out=1,512,28,28

identity_block  in=1,256,56,56 filter=(128,128,512),out=1,512,28,28

identity_block  in=1,256,56,56 filter=(128,128,512),out=1,512,28,28

identity_block  in=1,256,56,56 filter=(128,128,512),out=1,512,28,28

# block 3 (256,256,1024)

conv_block  in=1,512,28,28 filter=(256,256,1024),out=1,1024,14,14

identity_block  in=1,512,28,28 filter=(256,256,1024),out=1,1024,14,14

identity_block  in=1,512,28,28 filter=(256,256,1024),out=1,1024,14,14

identity_block  in=1,512,28,28 filter=(256,256,1024),out=1,1024,14,14

identity_block  in=1,512,28,28 filter=(256,256,1024),out=1,1024,14,14

identity_block  in=1,512,28,28 filter=(256,256,1024),out=1,1024,14,14

# block 4 (512,512,2048)

conv_block  in=1,1024,14,14 filter=(512,512,2048),out=1,2048,7,7

identity_block  in=1,1024,14,14 filter=(512,512,2048),out=1,2048,7,7

identity_block  in=1,1024,14,14 filter=(512,512,2048),out=1,2048,7,7

maxpool kernel_size=7, stride=1 out=1,2048,1,1

flatten

dence(1,1000)

acivation('softmax')

probbility(1,1000)

2.6 影响层输出大小的参数

诚如的话,神经网络的层数更加的多越好。大家可以增多更加多的层、订正激活函数和池层,改过学习速率,以看看每种步骤是什么影响属性的。由于i层的输入是i-1层的出口,大家须求理解差异的参数是什么样影响i-1层的出口大小的。

要打听那或多或少,能够看看conv2d()函数。

它有八个参数:

输入图像,维度为[batch size, image_width, image_height, image_depth]的4D张量

权重矩阵,维度为[filter_size, filter_size, image_depth, filter_depth]的4D张量

种种维度的步幅数。

填充(='SAME'/'VALID')

那八个参数决定了出口图像的轻重。

前七个参数分别是含有一群输入图像的4D张量和蕴含卷积滤波器权重的4D张量。

其多少个参数是卷积的肥瘦,即卷积滤波器在四维的每叁个维度中应当跳过些微个岗位。那多少个维度中的第叁个维度表示图像批次中的图像编号,由于大家不想跳过此外图像,由此一直为1。最终一个维度表示图像深度(不是色彩的通道数;灰度为1,EvoqueGB为3),由于大家不想跳过此外颜色通道,所以这么些也接连为1。第二和第一个维度度表示X和Y方向上的肥瘦(图像宽度和冲天)。假设要选择步幅,则那个是过滤器应跳过之处的维度。因而,对于步幅为1,我们一定要将小幅参数设置为[1, 1, 1, 1],即使大家意在上涨的幅度为2,则将其安装为[1,2,2,1]。由此及彼。

最终三个参数表示Tensorflow是还是不是应当对图像用零开展填充,以保障对于步幅为1的出口尺寸不会变动。如果padding = 'SAME',则图像用零填充(何况输出大小不会转移),假若 padding = 'VALID',则不填充。

下边大家得以看看通过图像(大小为28 x 28)扫描的卷积滤波器(滤波器大小为5 x 5)的五个示范。

在左边,填充参数设置为“SAME”,图像用零填充,最终4行/列饱含在出口图像中。

在侧面,填充参数设置为“VALID”,图像不用零填充,最后4行/列不富含在出口图像中。

我们能够见到,若无用零填充,则不包蕴倒数单元格,因为卷积滤波器已经达到(非零填充)图像的最后。那代表,对于28 x 28的输入大小,输出大小变为24 x 24 。假诺 padding = 'SAME',则输出大小为28 x 28。

若是在扫描图像时记下过滤器在图像上的职位(为简便起见,唯有X方向),那么这点就变得更其明显了。要是幅度为1,则X地方为0-5、1-6、2-7,等等。假如幅度为2,则X地方为0-5、2-7、4-9,等等。

举个例子图像大小为28 x 28,滤镜大小为5 x 5,并且步长1到4,那么我们得以赢得上边这些表:

能够观察,对于步幅为1,零填充输出图像大小为28 x 28。要是非零填充,则输出图像大小变为24 x 24。对于步幅为2的过滤器,这多少个数字分别为 14 x 14 和 12 x 12,对于步幅为3的过滤器,分别为 10 x 10 和 8 x 8。就这样推算。

对此随便叁个步幅S,滤波器尺寸K,图像尺寸W和填充尺寸P,输出尺寸将为

假诺在Tensorflow中 padding = “SAME”,则分子加起来恒等于1,输出大小仅由步幅S决定。

Train & Evaluate(Python TensorFlow)

教练和评估部分重大指标是浮动用于测量试验用的pb文件,其保存了运用TensorFlow python API营造练习后的互连网拓扑结商谈参数音讯,实现方式有数不清种,除了cnn外还是能够动用rnn,fcnn等。
内部基于cnn的函数也是有两套,分别为tf.layers.conv2d和tf.nn.conv2d, tf.layers.conv2d应用tf.nn.conv2d作为后端管理,参数上filters是整数,filter是4维张量。原型如下:
convolutional.py文件

def conv2d(inputs, filters, kernel_size, strides=(1, 1), padding='valid', data_format='channels_last',
   dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer=None,
   bias_initializer=init_ops.zeros_initializer(), kernel_regularizer=None, bias_regularizer=None,
   activity_regularizer=None, kernel_constraint=None, bias_constraint=None, trainable=True, name=None,
   reuse=None)     

gen_nn_ops.py 文件

def conv2d(input, filter, strides, padding, use_cudnn_on_gpu=True, data_format="NHWC", name=None)

法定Demo实例中选用的是layers module,布局如下:

  • Convolutional Layer #1:三10个5×5的filter,使用ReLU激活函数
  • Pooling Layer #1:2×2的filter做max pooling,步长为2
  • Convolutional Layer #2:陆十个5×5的filter,使用ReLU激活函数
  • Pooling Layer #2:2×2的filter做max pooling,步长为2
  • Dense Layer #1:1025个神经元,使用ReLU激活函数,dropout率0.4 (为了幸免过拟合,在教练的时候,二成的神经细胞会被专擅去掉卡塔尔(قطر‎
  • Dense Layer #2 (Logits Layer卡塔尔国:11个神经元,各种神经元对应一个项目(0-9)

基本代码在cnn_model_fn(features, labels, mode卡塔尔国函数中,完毕卷积构造的完好定义,大旨代码如下.

ca88编程 9

image.png

也足以选用守旧的tf.nn.conv2d函数, 大旨代码如下。

ca88编程 10

image.png

ca88编程 11ca88编程,f00428d6-c6fd-4d73-b027-4d90045cc31c.png.png

def identity_block(input_tensor, filters):


    filter1, filter2, filter3 = filters

    x = Conv2D(filter1,(1,1),strides=1)(input_tensor)
    x = BatchNormalization(axis=-1)(x)
    x = Activation('relu')(x)

    x = Conv2D(filter2,(3,3),strides=1,padding='same')(x)
    x = BatchNormalization(axis=-1)(x)
    x = Activation('relu')(x)

    x = Conv2D(filter3,(1,1),strides=1)(x)
    x = BatchNormalization(axis=-1)(x)
    x = Activation('relu')(x)

    y = Conv2D(filter3,(1,1),strides=1)(input_tensor)
    y = BatchNormalization(axis=-1)(y)
    y = Activation('relu')(y)

    out = merge([x,input_tensor],mode='sum')
    z = Activation('relu')(out)
    return z

3.3 AlexNet 性能

用作相比,看一下对含有了比较大图片的oxflower17数据集的LeNet5 CNN质量:

References & Recommends

MNIST

  • [01]Mnist官网
  • [02]Visualizing MNIST: An Exploration of Dimensionality Reduction
  • [03]TensorFlow Mnist官方实例
  • [04]Sample code for “Tensorflow and deep learning, without a PhD”

Softmax

  • [11]Convex functions
  • [12]巴黎高师高校机械学习第七课-正则化-regularization
  • [13]MachineLearning_Python

CNN

  • [21]Stanford University's Convolutional Neural Networks for Visual Recognition course materials翻译
  • [22]July CNN笔记:通俗明了卷积神经网络
  • [23]知道卷积Convolution
  • [24]Imagenet classification with deep convolutional neural networks
  • [25]Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition
  • [26]Convolutional Neural Networks-Basics
  • [27]A technical report on convolution arithmetic in the context of deep learning

TensorFlow CNN / TensorFlow Android

  • [31]Google官方Demo
  • [32]Google官方Codelab
  • [33]deep-learning-cnns-in-tensorflowGithub
  • [34]tensorflow-classifier-android
  • [35]creating-custom-model-for-android-using-tensorflow
  • [36]TF-NN Mnist实例

代码库:https://github.com/skyseraph/AI_P2T

网络结构在此篇杂谈中笔者选用了VGG16当做功底网络,对它举办了修剪和改造。

# coding:utf-8
import keras
from resnet_model import resnet_model
from keras.datasets import cifar10
from keras.utils import plot_model
from keras.callbacks import TensorBoard, ModelCheckpoint, LearningRateScheduler
import math

if __name__ == '__main__':

    n_class = 10
    img_w = 32
    img_h = 32
    BATCH_SIZE = 128
    EPOCH = 100

    (x_train, y_train), (x_test, y_test) = cifar10.load_data()

    x_train = x_train.astype('float32')
    x_train /= 255.
    y_train = keras.utils.np_utils.to_categorical(y_train, n_class)

    x_test = x_test.astype('float32')
    x_test /= 255.
    y_test = keras.utils.np_utils.to_categorical(y_test, n_class)


    tb = TensorBoard(log_dir='log')
    cp = ModelCheckpoint(filepath='best_model.h5', monitor='val_loss',save_best_only=1, mode='auto')


    def step_decay(epoch):
        initial_lrate = 0.01
        drop = 0.5
        epochs_drop = 10.0
        lrate = initial_lrate * math.pow(drop, math.floor((1   epoch) / epochs_drop))
        return lrate

    lr = LearningRateScheduler(step_decay)
    CB = [tb, cp, lr]
    input_shape = [x_train.shape[1], x_train.shape[2], x_train.shape[3]]

    model = resnet_model(out_class=n_class, input_shape = input_shape)

    plot_model(model, show_layer_names=1)

    model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy'])

    model.fit(x_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCH, validation_split=0.3,
              callbacks=CB, shuffle=1)

    loss, acc = model.evaluate(x_test, y_test, batch_size= BATCH_SIZE)

4. 结语

连锁代码能够在作者的GitHub库中收获,由此能够任意在和谐的数据集上使用它。

在深度学习的社会风气中还恐怕有越来越多的学问能够去切磋:循环神经互联网、基于区域的CNN、GAN、狠抓学习等等。在现在的博客小说中,我将创设那几个项指标神经互联网,并依赖大家早就学到的学识创设更加有趣的应用程序。

小说原标题《Building Convolutional Neural Networks with Tensorflow》,笔者:Ahmet Taspinar,译者:九夏,审阅查对:大旨曲。

Regression Softmax

机械学习有监督学习(supervised learning)中两大算法分别是分类算法和回归算法,分类算法用于离散型布满预测,回归算法用于接二连三型布满预测。
回归的目的就是起家二个回归方程用来预测目的值,回归的求解正是求这几个回归方程的回归周全。
中间回归(Regression)算法满含Linear Regression,Logistic Regression等, Softmax Regression是里面后生可畏种用于减轻多分拣(multi-class classification)难题的Logistic回归算法的放大,卓绝实例正是在MNIST手写数字分类上的运用。

文中涉及做了以下改换:a)连接侧输出层(side output layer)到每二个品级的末段叁个卷积层在,分别为conv1 1,conv3 conv2 2,3,3 conv4,conv5 3。侧输出层被落成为保有基本大小1和输出数1的卷积层。由此每二个卷积层的心得野的轻重是相仿的呼应的呼应侧输出层。B)去掉了VGG第五层的池化层和全连接层。修剪完事后的互联网如下图所示。

第风流洒脱拜见Resnet最经常见到的一张图:

3.2 VGG Net-16

VGG Net于2015年由香港理艺术高校的凯琳 Simonyan和Andrew Zisserman创设出来。 它包涵了越多的层(16-19层),但是每豆蔻梢头层的思谋尤为轻便;全部卷积层都独具3×3以致步长为3的过滤器,况兼存有最大池化层的大幅都为2。

于是它是三个更加深的CNN,但更简便易行。

它存在不一致的配备,16层或19层。 那二种不一致计划之间的分别是在第2,第3和第4最大池化层之后对3或4个卷积层的接收(见下文)。

安插为16层(配置D)的结果就像更加好,所以我们试着在Tensorflow中创设它。

#The VGGNET Neural Network

VGG16_PATCH_SIZE_1, VGG16_PATCH_SIZE_2, VGG16_PATCH_SIZE_3, VGG16_PATCH_SIZE_4 = 3, 3, 3, 3

VGG16_PATCH_DEPTH_1, VGG16_PATCH_DEPTH_2, VGG16_PATCH_DEPTH_3, VGG16_PATCH_DEPTH_4 = 64, 128, 256, 512

VGG16_NUM_HIDDEN_1, VGG16_NUM_HIDDEN_2 = 4096, 1000

def variables_vggnet16(patch_size1 = VGG16_PATCH_SIZE_1, patch_size2 = VGG16_PATCH_SIZE_2,

                      patch_size3 = VGG16_PATCH_SIZE_3, patch_size4 = VGG16_PATCH_SIZE_4,

                      patch_depth1 = VGG16_PATCH_DEPTH_1, patch_depth2 = VGG16_PATCH_DEPTH_2,

                      patch_depth3 = VGG16_PATCH_DEPTH_3, patch_depth4 = VGG16_PATCH_DEPTH_4,

                      num_hidden1 = VGG16_NUM_HIDDEN_1, num_hidden2 = VGG16_NUM_HIDDEN_2,

                      image_width = 224, image_height = 224, image_depth = 3, num_labels = 17):

    w1 = tf.Variable(tf.truncated_normal([patch_size1, patch_size1, image_depth, patch_depth1], stddev=0.1))

    b1 = tf.Variable(tf.zeros([patch_depth1]))

    w2 = tf.Variable(tf.truncated_normal([patch_size1, patch_size1, patch_depth1, patch_depth1], stddev=0.1))

    b2 = tf.Variable(tf.constant(1.0, shape=[patch_depth1]))

    w3 = tf.Variable(tf.truncated_normal([patch_size2, patch_size2, patch_depth1, patch_depth2], stddev=0.1))

    b3 = tf.Variable(tf.constant(1.0, shape = [patch_depth2]))

    w4 = tf.Variable(tf.truncated_normal([patch_size2, patch_size2, patch_depth2, patch_depth2], stddev=0.1))

    b4 = tf.Variable(tf.constant(1.0, shape = [patch_depth2]))

    w5 = tf.Variable(tf.truncated_normal([patch_size3, patch_size3, patch_depth2, patch_depth3], stddev=0.1))

    b5 = tf.Variable(tf.constant(1.0, shape = [patch_depth3]))

    w6 = tf.Variable(tf.truncated_normal([patch_size3, patch_size3, patch_depth3, patch_depth3], stddev=0.1))

    b6 = tf.Variable(tf.constant(1.0, shape = [patch_depth3]))

    w7 = tf.Variable(tf.truncated_normal([patch_size3, patch_size3, patch_depth3, patch_depth3], stddev=0.1))

    b7 = tf.Variable(tf.constant(1.0, shape=[patch_depth3]))

    w8 = tf.Variable(tf.truncated_normal([patch_size4, patch_size4, patch_depth3, patch_depth4], stddev=0.1))

    b8 = tf.Variable(tf.constant(1.0, shape = [patch_depth4]))

    w9 = tf.Variable(tf.truncated_normal([patch_size4, patch_size4, patch_depth4, patch_depth4], stddev=0.1))

    b9 = tf.Variable(tf.constant(1.0, shape = [patch_depth4]))

    w10 = tf.Variable(tf.truncated_normal([patch_size4, patch_size4, patch_depth4, patch_depth4], stddev=0.1))

    b10 = tf.Variable(tf.constant(1.0, shape = [patch_depth4]))

    w11 = tf.Variable(tf.truncated_normal([patch_size4, patch_size4, patch_depth4, patch_depth4], stddev=0.1))

    b11 = tf.Variable(tf.constant(1.0, shape = [patch_depth4]))

    w12 = tf.Variable(tf.truncated_normal([patch_size4, patch_size4, patch_depth4, patch_depth4], stddev=0.1))

    b12 = tf.Variable(tf.constant(1.0, shape=[patch_depth4]))

    w13 = tf.Variable(tf.truncated_normal([patch_size4, patch_size4, patch_depth4, patch_depth4], stddev=0.1))

    b13 = tf.Variable(tf.constant(1.0, shape = [patch_depth4]))

    no_pooling_layers = 5

    w14 = tf.Variable(tf.truncated_normal([(image_width // (2**no_pooling_layers))*(image_height // (2**no_pooling_layers))*patch_depth4 , num_hidden1], stddev=0.1))

    b14 = tf.Variable(tf.constant(1.0, shape = [num_hidden1]))

    w15 = tf.Variable(tf.truncated_normal([num_hidden1, num_hidden2], stddev=0.1))

    b15 = tf.Variable(tf.constant(1.0, shape = [num_hidden2]))

    w16 = tf.Variable(tf.truncated_normal([num_hidden2, num_labels], stddev=0.1))

    b16 = tf.Variable(tf.constant(1.0, shape = [num_labels]))

    variables = {

        'w1': w1, 'w2': w2, 'w3': w3, 'w4': w4, 'w5': w5, 'w6': w6, 'w7': w7, 'w8': w8, 'w9': w9, 'w10': w10,

        'w11': w11, 'w12': w12, 'w13': w13, 'w14': w14, 'w15': w15, 'w16': w16,

        'b1': b1, 'b2': b2, 'b3': b3, 'b4': b4, 'b5': b5, 'b6': b6, 'b7': b7, 'b8': b8, 'b9': b9, 'b10': b10,

        'b11': b11, 'b12': b12, 'b13': b13, 'b14': b14, 'b15': b15, 'b16': b16

    }

    return variables

def model_vggnet16(data, variables):

    layer1_conv = tf.nn.conv2d(data, variables['w1'], [1, 1, 1, 1], padding='SAME')

    layer1_actv = tf.nn.relu(layer1_conv variables['b1'])

    layer2_conv = tf.nn.conv2d(layer1_actv, variables['w2'], [1, 1, 1, 1], padding='SAME')

    layer2_actv = tf.nn.relu(layer2_conv variables['b2'])

    layer2_pool = tf.nn.max_pool(layer2_actv, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')

    layer3_conv = tf.nn.conv2d(layer2_pool, variables['w3'], [1, 1, 1, 1], padding='SAME')

    layer3_actv = tf.nn.relu(layer3_conv variables['b3']) 

    layer4_conv = tf.nn.conv2d(layer3_actv, variables['w4'], [1, 1, 1, 1], padding='SAME')

    layer4_actv = tf.nn.relu(layer4_conv variables['b4'])

    layer4_pool = tf.nn.max_pool(layer4_pool, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')

    layer5_conv = tf.nn.conv2d(layer4_pool, variables['w5'], [1, 1, 1, 1], padding='SAME')

    layer5_actv = tf.nn.relu(layer5_conv variables['b5'])

    layer6_conv = tf.nn.conv2d(layer5_actv, variables['w6'], [1, 1, 1, 1], padding='SAME')

    layer6_actv = tf.nn.relu(layer6_conv variables['b6'])

    layer7_conv = tf.nn.conv2d(layer6_actv, variables['w7'], [1, 1, 1, 1], padding='SAME')

    layer7_actv = tf.nn.relu(layer7_conv variables['b7'])

    layer7_pool = tf.nn.max_pool(layer7_actv, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')

    layer8_conv = tf.nn.conv2d(layer7_pool, variables['w8'], [1, 1, 1, 1], padding='SAME')

    layer8_actv = tf.nn.relu(layer8_conv variables['b8'])

    layer9_conv = tf.nn.conv2d(layer8_actv, variables['w9'], [1, 1, 1, 1], padding='SAME')

    layer9_actv = tf.nn.relu(layer9_conv variables['b9'])

    layer10_conv = tf.nn.conv2d(layer9_actv, variables['w10'], [1, 1, 1, 1], padding='SAME')

    layer10_actv = tf.nn.relu(layer10_conv variables['b10'])

    layer10_pool = tf.nn.max_pool(layer10_actv, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')

    layer11_conv = tf.nn.conv2d(layer10_pool, variables['w11'], [1, 1, 1, 1], padding='SAME')

    layer11_actv = tf.nn.relu(layer11_conv variables['b11'])

    layer12_conv = tf.nn.conv2d(layer11_actv, variables['w12'], [1, 1, 1, 1], padding='SAME')

    layer12_actv = tf.nn.relu(layer12_conv variables['b12'])

    layer13_conv = tf.nn.conv2d(layer12_actv, variables['w13'], [1, 1, 1, 1], padding='SAME')

    layer13_actv = tf.nn.relu(layer13_conv variables['b13'])

    layer13_pool = tf.nn.max_pool(layer13_actv, [1, 2, 2, 1], [1, 2, 2, 1], padding='SAME')

    flat_layer  = flatten_tf_array(layer13_pool)

    layer14_fccd = tf.matmul(flat_layer, variables['w14']) variables['b14']

    layer14_actv = tf.nn.relu(layer14_fccd)

    layer14_drop = tf.nn.dropout(layer14_actv, 0.5)

    layer15_fccd = tf.matmul(layer14_drop, variables['w15']) variables['b15']

    layer15_actv = tf.nn.relu(layer15_fccd)

    layer15_drop = tf.nn.dropout(layer15_actv, 0.5)

    logits = tf.matmul(layer15_drop, variables['w16']) variables['b16']

    return logits

Test(Android TensorFlow)

  • 基本是选择API​​接口: TensorFlowInferenceInterface.java

  • 布局gradle可能自编写翻译TensorFlow源码导入jar和so
    compile 'org.tensorflow:tensorflow-android:1.2.0'

  • 导入pb文件.pb文件放assets目录,然后读取

    String actualFilename = labelFilename.split(“file:///android_asset/“)[1];
    Log.i(TAG, “Reading labels from: “ actualFilename);
    BufferedReader br = null;
    br = new BufferedReader(new InputStreamReader( assetManager.open(actualFilename)));
    String line;
    while ((line = br.readLine()) != null) {
    c.labels.add(line);
    }
    br.close();

  • TensorFlow接口使用

ca88编程 12

image.png

最后效果:

ca88编程 13

image.png

ca88编程 14

image.png

本文由ca88发布,转载请注明来源

关键词: ca88网址 边缘 笔记 论文 深度学习