当前位置:首页 > 人工智能 >
《图解深度学习与神经网络》电子书封面

图解深度学习与神经网络

  • 发布时间:2019年06月26日 08:42:33
  • 作者:张平
  • 大小:174.5 MB
  • 类别:TensorFlow电子书
  • 格式:PDF
  • 版本:超清版
  • 评分:9.6

    图解深度学习与神经网络 PDF 超清版

      给大家带来的一篇关于TensorFlow相关的电子书资源,介绍了关于TensorFlow、深度学习、神经网络方面的内容,本书是由电子工业出版社出版,格式为PDF,资源大小174.5 MB,张平编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:8.4分

      Tags:深度学习 TensorFlow 神经网络 

      内容介绍

      图解深度学习与神经网络

      图解深度学习与神经网络

      内容介绍

      本书是以TensorFlow 为工具介绍神经网络和深度学习的入门书,内容循序渐进,以简单示例和图例的形式,展示神经网络和深度学习背后的数学基础原理,帮助读者更好地理解复杂抽象的公式。同时,采用手动计算和程序代码这两种方式讲解示例,可以更好地帮助读者理解TensorFlow的常用函数接口,为读者掌握利用TensorFlow搭建人工智能项目打下良好的基础。

      本书适合神经网络、深度学习、TensorFlow的入门者阅读。

      目录

      • 1 深度学习及TensorFlow 简介 1
      • 1.1 深度学习 1
      • 1.2 TensorFlow 简介及安装 2
      • 2 基本的数据结构及运算6
      • 2.1 张量 6
      • 2.1.1 张量的定义 6
      • 2.1.2 Tensor 与Numpy 的ndarray 转换 9
      • 2.1.3 张量的尺寸 10
      • 2.1.4 图像转换为张量 13
      • 2.2 随机数 14
      • 2.2.1 均匀(平均)分布随机数 14
      • 2.2.2 正态(高斯)分布随机数 15
      • 2.3 单个张量的运算 17
      • 2.3.1 改变张量的数据类型 17
      • 2.3.2 访问张量中某一个区域的值 19
      • 2.3.3 转置 22
      • 2.3.4 改变形状 26
      • 2.3.5 归约运算:求和、平均值、最大(小)值 29
      • 2.3.6 最大(小)值的位置索引 34
      • 2.4 多个张量之间的运算 35
      • 2.4.1 基本运算:加、减、乘、除 35
      • 2.4.2 乘法 41
      • 2.4.3 张量的连接 42
      • 2.4.4 张量的堆叠 44
      • 2.4.5 张量的对比 48
      • 2.5 占位符 49
      • 2.6 Variable 对象 50
      • 3 梯度及梯度下降法 52
      • 3.1 梯度 52
      • 3.2 导数计算的链式法则 53
      • 3.2.1 多个函数和的导数 54
      • 3.2.2 复合函数的导数 54
      • 3.2.3 单变量函数的驻点、极值点、鞍点 55
      • 3.2.4 多变量函数的驻点、极值点、鞍点 57
      • 3.2.5 函数的泰勒级数展开 60
      • 3.2.6 梯度下降法 63
      • 3.3 梯度下降法 73
      • 3.3.1 Adagrad 法 73
      • 3.3.2 Momentum 法 75
      • 3.3.3 NAG 法 77
      • 3.3.4 RMSprop 法 78
      • 3.3.5 具备动量的RMSprop 法 80
      • 3.3.6 Adadelta 法 81
      • 3.3.7 Adam 法 82
      • 3.3.8 Batch 梯度下降 84
      • 3.3.9 随机梯度下降 85
      • 3.3.10 mini-Batch 梯度下降 86
      • 3.4 参考文献 86
      • 4 回归分析 88
      • 4.1 线性回归分析 88
      • 4.1.1 一元线性回归 88
      • 4.1.2 保存和加载回归模型 91
      • 4.1.3 多元线性回归 95
      • 4.2 非线性回归分析 99
      • 5 全连接神经网络 102
      • 5.1 基本概念 102
      • 5.2 计算步骤 104
      • 5.3 神经网络的矩阵表达 107
      • 5.4 激活函数 112
      • 5.4.1 sigmoid 激活函数 112
      • 5.4.2 tanh 激活函数 113
      • 5.4.3 ReLU 激活函数 114
      • 5.4.4 leaky relu 激活函数 115
      • 5.4.5 elu 激活函数 118
      • 5.4.6 crelu 激活函数 119
      • 5.4.7 selu 激活函数 120
      • 5.4.8 relu6 激活函数 121
      • 5.4.9 softplus 激活函数 121
      • 5.4.10 softsign 激活函数 122
      • 5.5 参考文献 123
      • 6 神经网络处理分类问题 125
      • 6.1 TFRecord 文件 125
      • 6.1.1 将ndarray 写入TFRecord 文件 125
      • 6.1.2 从TFRecord 解析数据 128
      • 6.2 建立分类问题的数学模型 134
      • 6.2.1 数据类别(标签) 134
      • 6.2.2 图像与TFRecrder 135
      • 6.2.3 建立模型 140
      • 6.3 损失函数与训练模型 143
      • 6.3.1 sigmoid 损失函数 143
      • 6.3.2 softmax 损失函数 144
      • 6.3.3 训练和评估模型 148
      • 6.4 全连接神经网络的梯度反向传播 151
      • 6.4.1 数学原理及示例 151
      • 6.4.2 梯度消失 166
      • 7 一维离散卷积 168
      • 7.1 一维离散卷积的计算原理 168
      • 7.1.1 full 卷积 169
      • 7.1.2 valid 卷积 170
      • 7.1.3 same 卷积 170
      • 7.1.4 full、same、valid 卷积的关系 171
      • 7.2 一维卷积定理 174
      • 7.2.1 一维离散傅里叶变换 174
      • 7.2.2 卷积定理 177
      • 7.3 具备深度的一维离散卷积 182
      • 7.3.1 具备深度的张量与卷积核的卷积 182
      • 7.3.2 具备深度的张量分别与多个卷积核的卷积 183
      • 7.3.3 多个具备深度的张量分别与多个卷积核的卷积 185
      • 8 二维离散卷积 187
      • 8.1 二维离散卷积的计算原理 187
      • 8.1.1 full 卷积 187
      • 8.1.2 same 卷积 189
      • 8.1.3 valid 卷积 191
      • 8.1.4 full、same、valid 卷积的关系 192
      • 8.1.5 卷积结果的输出尺寸 193
      • 8.2 离散卷积的性质 194
      • 8.2.1 可分离的卷积核 194
      • 8.2.2 full 和same 卷积的性质 195
      • 8.2.3 快速计算卷积 197
      • 8.3 二维卷积定理 198
      • 8.3.1 二维离散傅里叶变换 198
      • 8.3.2 二维与一维傅里叶变换的关系 201
      • 8.3.3 卷积定理 203
      • 8.3.4 利用卷积定理快速计算卷积 203
      • 8.4 多深度的离散卷积 205
      • 8.4.1 基本的多深度卷积 205
      • 8.4.2 一个张量与多个卷积核的卷积 207
      • 8.4.3 多个张量分别与多个卷积核的卷积 208
      • 8.4.4 在每一深度上分别卷积 211
      • 8.4.5 单个张量与多个卷积核在深度上分别卷积 212
      • 8.4.6 分离卷积 214
      • 9 池化操作218
      • 9.1 same 池化 218
      • 9.1.1 same 最大值池化 218
      • 9.1.2 多深度张量的same 池化 221
      • 9.1.3 多个三维张量的same 最大值池化 223
      • 9.1.4 same 平均值池化 224
      • 9.2 valid 池化 226
      • 9.2.1 多深度张量的vaild 池化 228
      • 9.2.2 多个三维张量的valid 池化 229
      • 10 卷积神经网络231
      • 10.1 浅层卷积神经网络 231
      • 10.2 LeNet 238
      • 10.3 AlexNet 244
      • 10.3.1 AlexNet 网络结构详解 244
      • 10.3.2 dropout 及其梯度下降 247
      • 10.4 VGGNet 256
      • 10.5 GoogleNet 264
      • 10.5.1 网中网结构 264
      • 10.5.2 Batch Normalization 269
      • 10.5.3 BN 与卷积运算的关系 273
      • 10.5.4 指数移动平均 275
      • 10.5.5 带有BN 操作的卷积神经网络 276
      • 10.6 ResNet 281
      • 10.7 参考文献 284
      • 11 卷积的梯度反向传播 286
      • 11.1 valid 卷积的梯度 286
      • 11.1.1 已知卷积核,对未知张量求导 286
      • 11.1.2 已知输入张量,对未知卷积核求导 290
      • 11.2 same 卷积的梯度 294
      • 11.2.1 已知卷积核,对输入张量求导 294
      • 11.2.2 已知输入张量,对未知卷积核求导 298
      • 12 池化操作的梯度 303
      • 12.1 平均值池化的梯度 303
      • 12.2 最大值池化的梯度 306
      • 13 BN 的梯度反向传播311
      • 13.1 BN 操作与卷积的关系 311
      • 13.2 示例详解 314
      • 14 TensorFlow 搭建神经网络的主要函数 324

      读书笔记

      Tensorflow实现AlexNet卷积神经网络及运算时间评测

      本文实例为大家分享了Tensorflow实现AlexNet卷积神经网络的具体实现代码,供大家参考,具体内容如下

      之前已经介绍过了AlexNet的网络构建了,这次主要不是为了训练数据,而是为了对每个batch的前馈(Forward)和反馈(backward)的平均耗时进行计算。在设计网络的过程中,分类的结果很重要,但是运算速率也相当重要。尤其是在跟踪(Tracking)的任务中,如果使用的网络太深,那么也会导致实时性不好。

      from datetime import datetime
      import math
      import time
      import tensorflow as tf
      
      batch_size = 32
      num_batches = 100
      
      def print_activations(t):
       print(t.op.name, '', t.get_shape().as_list())
      
      def inference(images):
       parameters = []
      
       with tf.name_scope('conv1') as scope:
        kernel = tf.Variable(tf.truncated_normal([11, 11, 3, 64], dtype = tf.float32, stddev = 1e-1), name = 'weights')
        conv = tf.nn.conv2d(images, kernel, [1, 4, 4, 1], padding = 'SAME')
        biases = tf.Variable(tf.constant(0.0, shape = [64], dtype = tf.float32), trainable = True, name = 'biases')
        bias = tf.nn.bias_add(conv, biases)
        conv1 = tf.nn.relu(bias, name = scope)
        print_activations(conv1)
        parameters += [kernel, biases]
      
        lrn1 = tf.nn.lrn(conv1, 4, bias = 1.0, alpha = 0.001 / 9, beta = 0.75, name = 'lrn1')
        pool1 = tf.nn.max_pool(lrn1, ksize = [1, 3, 3, 1], strides = [1, 2, 2, 1], padding = 'VALID', name = 'pool1')
        print_activations(pool1)
      
       with tf.name_scope('conv2') as scope:
        kernel = tf.Variable(tf.truncated_normal([5, 5, 64, 192], dtype = tf.float32, stddev = 1e-1), name = 'weights')
        conv = tf.nn.conv2d(pool1, kernel, [1, 1, 1, 1], padding = 'SAME')
        biases = tf.Variable(tf.constant(0.0, shape = [192], dtype = tf.float32), trainable = True, name = 'biases')
        bias = tf.nn.bias_add(conv, biases)
        conv2 = tf.nn.relu(bias, name = scope)
        parameters += [kernel, biases]
        print_activations(conv2)
      
        lrn2 = tf.nn.lrn(conv2, 4, bias = 1.0, alpha = 0.001 / 9, beta = 0.75, name = 'lrn2')
        pool2 = tf.nn.max_pool(lrn2, ksize = [1, 3, 3, 1], strides = [1, 2, 2, 1], padding = 'VALID', name = 'pool2')
        print_activations(pool2)
      
       with tf.name_scope('conv3') as scope:
        kernel = tf.Variable(tf.truncated_normal([3, 3, 192, 384], dtype = tf.float32, stddev = 1e-1), name = 'weights')
        conv = tf.nn.conv2d(pool2, kernel, [1, 1, 1, 1], padding = 'SAME')
        biases = tf.Variable(tf.constant(0.0, shape = [384], dtype = tf.float32), trainable = True, name = 'biases')
        bias = tf.nn.bias_add(conv, biases)
        conv3 = tf.nn.relu(bias, name = scope)
        parameters += [kernel, biases]
        print_activations(conv3)
      
       with tf.name_scope('conv4') as scope:
        kernel = tf.Variable(tf.truncated_normal([3, 3, 384, 256], dtype = tf.float32, stddev = 1e-1), name = 'weights')
        conv = tf.nn.conv2d(conv3, kernel, [1, 1, 1, 1], padding = 'SAME')
        biases = tf.Variable(tf.constant(0.0, shape = [256], dtype = tf.float32), trainable = True, name = 'biases')
        bias = tf.nn.bias_add(conv, biases)
        conv4 = tf.nn.relu(bias, name = scope)
        parameters += [kernel, biases]
        print_activations(conv4)
      
       with tf.name_scope('conv5') as scope:
        kernel = tf.Variable(tf.truncated_normal([3, 3, 256, 256], dtype = tf.float32, stddev = 1e-1), name = 'weights')
        conv = tf.nn.conv2d(conv4, kernel, [1, 1, 1, 1], padding = 'SAME')
        biases = tf.Variable(tf.constant(0.0, shape = [256], dtype = tf.float32), trainable = True, name = 'biases')
        bias = tf.nn.bias_add(conv, biases)
        conv5 = tf.nn.relu(bias, name = scope)
        parameters += [kernel, biases]
        print_activations(conv5)
      
        pool5 = tf.nn.max_pool(conv5, ksize = [1, 3, 3, 1], strides = [1, 2, 2, 1], padding = 'VALID', name = 'pool5')
        print_activations(pool5)
      
        return pool5, parameters
      
      def time_tensorflow_run(session, target, info_string):
       num_steps_burn_in = 10
       total_duration = 0.0
       total_duration_squared = 0.0
      
       for i in range(num_batches + num_steps_burn_in):
        start_time = time.time()
        _ = session.run(target)
        duration = time.time() - start_time
        if i >= num_steps_burn_in:
         if not i % 10:
          print('%s: step %d, duration = %.3f' %(datetime.now(), i - num_steps_burn_in, duration))
         total_duration += duration
         total_duration_squared += duration * duration
      
       mn = total_duration / num_batches
       vr = total_duration_squared / num_batches - mn * mn
       sd = math.sqrt(vr)
       print('%s: %s across %d steps, %.3f +/- %.3f sec / batch' %(datetime.now(), info_string, num_batches, mn, sd))
      
      def run_benchmark():
       with tf.Graph().as_default():
        image_size = 224
        images = tf.Variable(tf.random_normal([batch_size, image_size, image_size, 3], dtype = tf.float32, stddev = 1e-1))
        pool5, parameters = inference(images)
      
        init = tf.global_variables_initializer()
        sess = tf.Session()
        sess.run(init)
      
        time_tensorflow_run(sess, pool5, "Forward")
      
        objective = tf.nn.l2_loss(pool5)
        grad = tf.gradients(objective, parameters)
        time_tensorflow_run(sess, grad, "Forward-backward")
      
      
      run_benchmark()

      这里的代码都是之前讲过的,只是加了一个计算时间和现实网络的卷积核的函数,应该很容易就看懂了,就不多赘述了。我在GTX TITAN X上前馈大概需要0.024s, 反馈大概需要0.079s。哈哈,自己动手试一试哦。

      以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

      以上就是本次介绍的TensorFlow电子书的全部相关内容,希望我们整理的资源能够帮助到大家,感谢大家对码农之家的支持。

      上一篇:大型网站技术架构演进与性能优化

      下一篇:自然语言处理实践:聊天机器人技术原理与应用

      展开 +

      收起 -

      下载地址:百度网盘下载
      读者心得
      54小时58分钟前回答

      对Tensorflow中的变量初始化函数详解

      Tensorflow 提供了7种不同的初始化函数: tf.constant_initializer(value) #将变量初始化为给定的常量,初始化一切所提供的值。 假设在卷积层中,设置偏执项b为0,则写法为:1. bias_initializer=tf.constant_initializer(0)2. bias_initializer=tf.zeros_initializer(0) tf.random_normal_initializer(mean,stddev) #功能是将变量初始化为满足正太分布的随机值,主要参数(正太分布的均值和标准差),用所给的均值和标准差初始化均匀分布 tf.truncated_normal_initializer(mean,stddev,seed,dtype) #功能:将变量初始化为满足正太分布的随机值,但如果随机出来的值偏离平均值超过2个标准差,那么这个数将会被重新随机 mean:用于指定均值;stddev用于指定标准差;seed:用……

      102小时13分钟前回答

      使用tensorflow实现AlexNet

      AlexNet是2012年ImageNet比赛的冠军,虽然过去了很长时间,但是作为深度学习中的经典模型,AlexNet不但有助于我们理解其中所使用的很多技巧,而且非常有助于提升我们使用深度学习工具箱的熟练度。尤其是我刚入门深度学习,迫切需要一个能让自己熟悉tensorflow的小练习,于是就有了这个小玩意儿...... 先放上我的代码:https://github.com/hjptriplebee/AlexNet_with_tensorflow 如果想运行代码,详细的配置要求都在上面链接的readme文件中了。本文建立在一定的tensorflow基础上,不会对太细的点进行说明。 模型结构 关于模型结构网上的文献很多,我这里不赘述,一会儿都在代码里解释。 有一点需要注意,AlexNet将网络分成……

      码农之家

      边景明 提供上传

      资源
      31
      粉丝
      32
      喜欢
      164
      评论
      8

      Copyright 2018-2021 www.xz577.com 码农之家

      版权投诉 / 书籍推广:520161757@qq.com