精华内容
下载资源
问答
  • TensorFlow是一个用于Google创建和发布的快速数值计算的Python库。它是一个基础库,可用于直接创建深度学习模型...什么TensorFlowTensorFlow是一个用于快速数值计算的开源库。 它由Google创建并维护,并在Ap...

    TensorFlow是一个用于Google创建和发布的快速数值计算的Python库。它是一个基础库,可用于直接创建深度学习模型,或使用包装库来简化在TensorFlow之上构建的过程。

     

    在这篇文章中,您将发现用于深度学习的TensorFlow库。让我们开始吧。

    什么是TensorFlow?

    TensorFlow是一个用于快速数值计算的开源库。

    它由Google创建并维护,并在Apache 2.0开源许可下发布。 虽然可以访问底层的C ++ API,但API名义上是用于Python编程语言的。与Theano等深度学习中使用的其他数值库不同,TensorFlow设计用于研究和开发以及生产系统,尤其是Google搜索中的RankBrain和有趣的DeepDream项目。

     

    它可以在单CPU系统,GPU以及移动设备和数百台机器的大规模分布式系统上运行。

    如何安装TensorFlow

    如果您已经拥有Python SciPy环境,那么安装TensorFlow非常简单。

    TensorFlow适用于Python 2.7和Python 3.3+。 您可以按照TensorFlow网站上的“下载和设置”说明进行操作。 通过PyPI进行安装可能是最简单的,并且下载和设置网页上有用于Linux或Mac OS X平台的pip命令的特定说明。

    如果您愿意,还可以使用virtualenv和docker图像。要使用GPU,只支持Linux,它需要Cuda Toolkit。

    你在TensorFlow中的第一个例子

    根据有向图的结构中的数据流和操作来描述计算。

     

    节点:节点执行计算并具有零个或多个输入和输出。 在节点之间移动的数据称为张量,它是实数值的多维数组。

    边缘:该图定义了数据流,分支,循环和状态更新。 特殊边缘可用于同步图形内的行为,例如等待完成多个输入的计算。

    操作:操作是一个命名的抽象计算,它可以获取输入属性并生成输出属性。 例如,您可以定义添加或乘法操作。

    使用TensorFlow进行计算

    第一个示例是TensorFlow网站上示例的修改版本。 它显示了如何使用会话创建会话,定义常量和使用这些常量执行计算。

    import tensorflow as tf

    sess = tf.Session()

    a = tf.constant(10)

    b = tf.constant(32)

    print(sess.run(a+b))

    运行此示例显示:

    42

    使用TensorFlow进行线性回归

    下一个示例来自TensorFlow教程的介绍。

    此示例显示了如何定义变量(例如W和b)以及作为计算结果的变量(y)。

    我们对TensorFlow有一定的了解,它将计算的定义和声明与会话中的执行和运行调用分开。

     

    运行此示例将输出以下输出:

     

    您可以在“基本使用指南”中了解有关TensorFlow机制的更多信息。

    更多深度学习模型

    您的TensorFlow安装附带了许多深度学习模型,您可以直接使用它们进行试验。

    鉴于TensorFlow目前这么流行,想要学习和实践的程序员们也可以了解下谷歌最近的AI开源项目——AIY Projects。AIY 全称是 Artificial Intelligence Yourself,顾名思义就是利用 AI 来进行的 DIY 功能套件。借助 AIY 项目,创客可以利用人工智能来实现更像人与人交流的人机交互。谷歌目前为 AIY Projects 推出了两款硬件产品--AIY Voice Kit 和 AIY Vision Kit。

     

    Vision Kit 由Raspberry Pi和Intel movidius提供动力。它可以运行具有低耗处理能力的深度学习算法。Raspberry Pi Zero WH 包括视觉处理单元芯片,可以高效地运行Tensor Flow图像处理。

    而且谷歌为此还发布了一个TensorFlow.js的工具,有了这项工具,即使不是机器视觉领域的专家,大家也可以实现很多应用场景,比如在浏览器中训练自己的宠物脸辨识系统,在自家的监视系统中使用等等。

    展开全文
  • TensorFlow学习——CNN训练机器识别信长和信喵最近想搞个图片分类器,实现自己加载本地的图片进行训练,然后保存...数据准备用什么数据来构造分类器呢?记得前两年很喜欢玩《信长之野望14》,里面不是很多人物头像

    TensorFlow学习——用CNN训练机器识别信长和信喵

    最近想搞个图片分类器,实现自己加载本地的图片进行训练,然后保存模型,另起一个程序加载模型,然后读入几张图片进行预测。回头盘点了下几个熟悉开源的DL工具,觉得做图片分类还是tensorflow比较方便,于是就找了点图片完成了这个模型,这里记录一下。

    一.数据准备

    用什么数据来构造分类器呢?记得前两年很喜欢玩《信长之野望14》,里面不是有很多人物头像吗?而且还分信长之野望原版喵之信长版,索性做个分类器识别是人头还是猫头好了。

    数据下载地址(百度云):

    链接: https://pan.baidu.com/s/1slUDK0t 密码: vjv8

    这里面将头像数据分别放在了两个目录下,

    nobunaga :原版头像
    nobunyaga :喵版头像

    我从他们里面分别把信长的头像取了出去不做训练,看看最后的模型是否能够认识他。

    二.载入数据

    首先,用什么方法读取图片呢?百度一下之后觉得PIL是比较方便的,于是用pip装了下PIL就可以使用了。在pycharm中新建一个工程,创建python脚本CnnClassify,第一部分代码编写如下:

    # -*- coding: utf-8 -*-
    
    from PIL import Image
    import glob
    import os
    import tensorflow as tf
    import numpy as np
    import time
    
    img_path = '../images/nobu/'
    model_dir = "./model/nobu/"
    model_name = "nobunaga_model"
    
    # 将所有的图片resize成100*100
    w = 100
    h = 100
    c = 3
    
    
    # 读取图片
    def read_img(path):
        cate = [path + x for x in os.listdir(path) if os.path.isdir(path + x)]
        imgs = []
        labels = []
        for idx, folder in enumerate(cate):
            for im in glob.glob(folder + '/*.jpg'):
                print('reading the images:%s' % (im))
                print('classify is %d:' % (idx))
                # 打开图片
                img = Image.open(im)
                img = img.resize((w,h))
                img = np.array(img)
                imgs.append(img)
                labels.append(idx)
        return np.asarray(imgs, np.float32), np.asarray(labels, np.int32)

    这段代码主要做了几件事情:
    1. 把相关的工具给引用进来
    2. 设置一些全局变量,比如输入图片的路径、模型输出的路径以及规定训练用的图片大小
    3. 定义一个函数read_img来读取数据集,给定一个图片根目录,会自动读取其每个子目录下的图片,并且不同子目录的图片对应的分类号不同

    在读取图片时进行了一些转化,比如将原始图片大小转为100*100,然后转成了一个(100,100,3)的NpArray,再把这个NpArray加入倒一个List中去,作为数据集,结构就成了[n,100,100,3];同理,这样构造一个标签集合labels。

    接下来要对数据进行一个划分,分为训练集和验证集,先对这些图片的顺序进行shuffle(洗牌),然后按照一个比例划分。

    data, label = read_img(img_path)
    
    # 打乱顺序
    num_example = data.shape[0]
    arr = np.arange(num_example)
    np.random.shuffle(arr)
    data = data[arr]
    label = label[arr]
    
    # 将所有数据分为训练集和验证集
    ratio = 0.8
    s = np.int(num_example * ratio)
    x_train = data[:s]
    y_train = label[:s]
    x_val = data[s:]
    y_val = label[s:]

    至此,载入数据的工作完成。

    三.构建CNN模型

    做图片分类的首选是卷积神经网络(CNN),当然目前有很多优秀的CNN模型可以使用,我这里参考了博文 http://www.cnblogs.com/denny402/p/6931338.html 给出的模型,代码编写如下:

    # -----------------构建网络----------------------
    # 占位符
    x = tf.placeholder(tf.float32, shape=[None, w, h, c], name='x')
    y_ = tf.placeholder(tf.int32, shape=[None, ], name='y_')
    
    # 第一个卷积层(100——>50)
    conv1 = tf.layers.conv2d(
        inputs=x,
        filters=32,
        kernel_size=[5, 5],
        padding="same",
        activation=tf.nn.relu,
        kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
    pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
    
    # 第二个卷积层(50->25)
    conv2 = tf.layers.conv2d(
        inputs=pool1,
        filters=64,
        kernel_size=[5, 5],
        padding="same",
        activation=tf.nn.relu,
        kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
    pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
    
    # 第三个卷积层(25->12)
    conv3 = tf.layers.conv2d(
        inputs=pool2,
        filters=128,
        kernel_size=[3, 3],
        padding="same",
        activation=tf.nn.relu,
        kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
    pool3 = tf.layers.max_pooling2d(inputs=conv3, pool_size=[2, 2], strides=2)
    
    # 第四个卷积层(12->6)
    conv4 = tf.layers.conv2d(
        inputs=pool3,
        filters=128,
        kernel_size=[3, 3],
        padding="same",
        activation=tf.nn.relu,
        kernel_initializer=tf.truncated_normal_initializer(stddev=0.01))
    pool4 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=2)
    
    re1 = tf.reshape(pool4, [-1, 6 * 6 * 128])
    
    # 全连接层
    dense1 = tf.layers.dense(inputs=re1,
                             units=1024,
                             activation=tf.nn.relu,
                             kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),
                             kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003))
    dense2 = tf.layers.dense(inputs=dense1,
                             units=512,
                             activation=tf.nn.relu,
                             kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),
                             kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003))
    logits = tf.layers.dense(inputs=dense2,
                             units=5,
                             activation=None,
                             kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),
                             kernel_regularizer=tf.contrib.layers.l2_regularizer(0.003))
    # ---------------------------网络结束---------------------------
    
    loss = tf.losses.sparse_softmax_cross_entropy(labels=y_, logits=logits)
    train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss)
    correct_prediction = tf.equal(tf.cast(tf.argmax(logits, 1), tf.int32), y_)
    acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    

    这段代码构造了一个4层卷积+池化的CNN网络,然后用全连接层进行输出,这个全连接层包括两个隐层,用ReLU作为激活函数,一个输出层。最后,定义了损失函数、优化器、正确率度量和ACC。
    至此,CNN模型构建完毕。

    四.训练模型,保存

    首先,定义了一个函数来按批次取数据进行训练

    def minibatches(inputs=None, targets=None, batch_size=None, shuffle=False):
        assert len(inputs) == len(targets)
        if shuffle:
            indices = np.arange(len(inputs))
            np.random.shuffle(indices)
        for start_idx in range(0, len(inputs) - batch_size + 1, batch_size):
            if shuffle:
                excerpt = indices[start_idx:start_idx + batch_size]
            else:
                excerpt = slice(start_idx, start_idx + batch_size)
            yield inputs[excerpt], targets[excerpt]

    接着,定义总共进行多少轮训练,以及每轮训练使用的数据量大小batch。我使用的数据集有近400张图片,训练集80%,这里40轮,每轮64张,总共2560,相当于被张图片拿来训练了7、8次左右。然后创建了一个长连接的InteractiveSession。

    n_epoch = 40
    batch_size = 64
    sess = tf.InteractiveSession()
    sess.run(tf.global_variables_initializer())

    接下来就是训练和保存模型了。这里创建一个保存器,定义最多保存3个模型,创建模型生成路径,然后进行迭代训练,训练时打印每一轮的训练误差、ACC以及验证误差、ACC。迭代40轮之后ACC已经达到0.9以上了,试过增加迭代轮数ACC可以接近1。

    # 保存模型
    saver=tf.train.Saver(max_to_keep=3)
    max_acc=0
    
    if not os.path.exists(model_dir):
        os.mkdir(model_dir)
    
    for epoch in range(n_epoch):
        start_time = time.time()
        print ("step:\t%d" % epoch)
        # training
        train_loss, train_acc, n_batch = 0, 0, 0
        for x_train_a, y_train_a in minibatches(x_train, y_train, batch_size, shuffle=True):
            _, err, ac = sess.run([train_op, loss, acc], feed_dict={x: x_train_a, y_: y_train_a})
            print x_train_a.shape
            train_loss += err;
            train_acc += ac;
            n_batch += 1
        print("   train loss: %f" % (train_loss / n_batch))
        print("   train acc: %f" % (train_acc / n_batch))
    
        # validation
        val_loss, val_acc, n_batch = 0, 0, 0
        for x_val_a, y_val_a in minibatches(x_val, y_val, batch_size, shuffle=False):
            err, ac = sess.run([loss, acc], feed_dict={x: x_val_a, y_: y_val_a})
            val_loss += err;
            val_acc += ac;
            n_batch += 1
        print("   validation loss: %f" % (val_loss / n_batch))
        print("   validation acc: %f" % (val_acc / n_batch))
    
        # 保存模型
        if val_acc > max_acc:
            max_acc = val_acc
            saver.save(sess, os.path.join(model_dir, model_name), global_step = epoch+ 1)
            print "保存模型成功!"
    
    sess.close()

    这里有个技巧是每轮迭代计算新的验证ACC是否大于历史最有ACC,如果大于则把模型保存下来,否则就不保存。因为前面设置了最多保留3个模型,因此训练完后保留了ACC最高的3个模型。

    五.加载模型和预测

    新建一个CnnPredict的Python脚本,首先要把刚才定义的模型结构搬过来,因为代码太多,这里就省略了(如果有可以把结构也保存到模型的方法你可以告诉我,我试过不把模型搬过来Saver就会报错,说没有模型需要保存)。

    接着是把sess和saver都还原出来,然后使用latest_checkpoint在生成的一堆模型中去找最后一个生成的模型,进行还原。

    sess = tf.InteractiveSession()
    sess.run(tf.global_variables_initializer())
    
    saver = tf.train.Saver()
    
    # Load model
    model_file=tf.train.latest_checkpoint(model_dir)
    saver.restore(sess, model_file)
    

    接下来就要把之前被我拎出来的信长的头像拿来做预测了。这里需要构造跟之前训练一样的数据格式,不然会报格式不匹配的错误。

    # 加载信长头像,正确的分类是0
    imgs = []
    labels = []
    
    img = Image.open(img_path + "00034_00001.jpg")
    img = img.resize((w, h))
    img = np.array(img)
    imgs.append(img)
    labels.append(0)
    
    imgs = np.asarray(imgs, np.float32)
    labels = np.asarray(labels, np.float32)
    
    ret = sess.run(y_, feed_dict={x: imgs, y_:labels})
    print("计算模型结果成功!")
    # 显示测试结果
    print("预测结果:%d" % ret)
    print("实际结果:%d" % 0)
    
    # 加载信喵头像,正确的分类是1
    imgs = []
    labels = []
    
    img = Image.open(img_path + "00034_01904.jpg")
    img = img.resize((w, h))
    img = np.array(img)
    imgs.append(img)
    labels.append(1)
    
    imgs = np.asarray(imgs, np.float32)
    labels = np.asarray(labels, np.float32)
    
    # 根据模型计算结果
    ret = sess.run(y_, feed_dict={x: imgs, y_:labels})
    print("计算模型结果成功!")
    # 显示测试结果
    print("预测结果:%d" % ret)
    print("实际结果:%d" % 1)
    sess.close()

    预测结果如下:

    计算模型结果成功!
    预测结果:0
    实际结果:0
    计算模型结果成功!
    预测结果:1
    实际结果:1

    很高兴,我们的机器能够正确识别信长和信喵了。
    织田信长
    织田信长
    织田信喵
    织田信喵

    参考文献:

    [1] tensorflow 1.0 学习:用CNN进行图像分类
    [2] Tensorflow模型保存与使用

    完整代码

    见我的github

    展开全文
  • TensorFlow 是一个用于 Google 创建和发布的快速数值计算的 Python 库。它是一个基础库,可用于直接创建深度学习模型,或使用...什么TensorFlowTensorFlow 是一个用于快速数值计算的开源库。 它由 Google ...

    TensorFlow 是一个用于 Google 创建和发布的快速数值计算的 Python 库。它是一个基础库,可用于直接创建深度学习模型,或使用包装库来简化在 TensorFlow 之上构建的过程。

    在这篇文章中,您将发现用于深度学习的 TensorFlow 库。让我们开始吧。

    什么是 TensorFlow?

    TensorFlow 是一个用于快速数值计算的开源库。

    它由 Google 创建并维护,并在 Apache 2.0 开源许可下发布。 虽然可以访问底层的 C ++ API,但 API 名义上是用于 Python 编程语言的。与 Theano 等深度学习中使用的其他数值库不同,TensorFlow 设计用于研究和开发以及生产系统,尤其是 Google 搜索中的 RankBrain 和有趣的 DeepDream 项目。

    它可以在单 CPU 系统,GPU 以及移动设备和数百台机器的大规模分布式系统上运行。

    如何安装 TensorFlow

    如果您已经拥有 Python SciPy 环境,那么安装 TensorFlow 非常简单。TensorFlow 适用于 Python 2.7 和 Python 3.3+。 您可以按照 TensorFlow 网站上的“下载和设置”说明进行操作。 通过 PyPI 进行安装可能是最简单的,并且下载和设置网页上有用于 Linux 或 Mac OS X 平台的pip命令的特定说明。如果您愿意,还可以使用 virtualenv 和 docker 图像。要使用 GPU,只支持 Linux,它需要 Cuda Toolkit。遇到问题没人解答,小编创建了一个Python学习交流裙:五二八 三九七 六一七, 寻找有志同道合的小伙伴,互帮互助,群里还有不错的学习视频教程和PDF电子书分享!

    你在 TensorFlow 中的第一个例子

    根据有向图的结构中的数据流和操作来描述计算。

    节点:节点执行计算并具有零个或多个输入和输出。 在节点之间移动的数据称为张量,它是实数值的多维数组。

    边缘:该图定义了数据流,分支,循环和状态更新。 特殊边缘可用于同步图形内的行为,例如等待完成多个输入的计算。

    操作:操作是一个命名的抽象计算,它可以获取输入属性并生成输出属性。 例如,您可以定义添加或乘法操作。

    使用 TensorFlow 进行计算

    第一个示例是 TensorFlow 网站上示例的修改版本。 它显示了如何使用会话创建会话,定义常量和使用这些常量执行计算。

    import tensorflow as tf

    sess = tf.Session()

    a = tf.constant(10)

    b = tf.constant(32)

    print(sess.run(a+b))

    运行此示例显示:

    42

    使用 TensorFlow 进行线性回归

    下一个示例来自 TensorFlow 教程的介绍。此示例显示了如何定义变量(例如W和b)以及作为计算结果的变量(y)。我们对 TensorFlow 有一定的了解,它将计算的定义和声明与会话中的执行和运行调用分开。

    运行此示例将输出以下输出:

    您可以在“基本使用指南”中了解有关 TensorFlow 机制的更多信息

    其实 Python 已经不是该不该学而是必须学了,时代在发展 Python 现在的使用范围已经不用小编在这里多说,对于大家来说怎么学或者说怎么能够快速高效的学习并且在工作中使用才是最重要的问题。

    展开全文
  • 笔者这几天在跟着莫烦学习TensorFlow,正好到迁移学习(至于什么是迁移学习,看这篇),莫烦老师做的是预测猫和老虎尺寸大小的学习。作为一个有为的学生,笔者当然不能再预测猫啊狗啊的大小啦,正好之前正好做过...

            笔者这几天在跟着莫烦学习TensorFlow,正好到迁移学习(至于什么是迁移学习,看这篇),莫烦老师做的是预测猫和老虎尺寸大小的学习。作为一个有为的学生,笔者当然不能再预测猫啊狗啊的大小啦,正好之前正好有做过猫狗大战数据集的图像分类,做好的数据都还在,二话不说,开撸。

            既然是VGG16模型,当然首先上模型代码了:

      1 def conv_layers_simple_api(net_in):
      2     with tf.name_scope('preprocess'):
      3         # Notice that we include a preprocessing layer that takes the RGB image
      4         # with pixels values in the range of 0-255 and subtracts the mean image
      5         # values (calculated over the entire ImageNet training set).
      6         mean = tf.constant([123.68, 116.779, 103.939], dtype=tf.float32, shape=[1, 1, 1, 3], name='img_mean')
      7         net_in.outputs = net_in.outputs - mean
      8 
      9     # conv1
     10     network = Conv2d(net_in, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     11                      name='conv1_1')
     12     network = Conv2d(network, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     13                      name='conv1_2')
     14     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool1')
     15 
     16     # conv2
     17     network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     18                      name='conv2_1')
     19     network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     20                      name='conv2_2')
     21     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool2')
     22 
     23     # conv3
     24     network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     25                      name='conv3_1')
     26     network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     27                      name='conv3_2')
     28     network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     29                      name='conv3_3')
     30     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool3')
     31 
     32     # conv4
     33     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     34                      name='conv4_1')
     35     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     36                      name='conv4_2')
     37     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     38                      name='conv4_3')
     39     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool4')
     40 
     41     # conv5
     42     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     43                      name='conv5_1')
     44     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     45                      name='conv5_2')
     46     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     47                      name='conv5_3')
     48     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool5')
     49     return network``
     50 def conv_layers_simple_api(net_in):
     51     with tf.name_scope('preprocess'):
     52         # Notice that we include a preprocessing layer that takes the RGB image
     53         # with pixels values in the range of 0-255 and subtracts the mean image
     54         # values (calculated over the entire ImageNet training set).
     55         mean = tf.constant([123.68, 116.779, 103.939], dtype=tf.float32, shape=[1, 1, 1, 3], name='img_mean')
     56         net_in.outputs = net_in.outputs - mean
     57 
     58     # conv1
     59     network = Conv2d(net_in, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     60                      name='conv1_1')
     61     network = Conv2d(network, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     62                      name='conv1_2')
     63     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool1')
     64 
     65     # conv2
     66     network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     67                      name='conv2_1')
     68     network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     69                      name='conv2_2')
     70     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool2')
     71 
     72     # conv3
     73     network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     74                      name='conv3_1')
     75     network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     76                      name='conv3_2')
     77     network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     78                      name='conv3_3')
     79     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool3')
     80 
     81     # conv4
     82     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     83                      name='conv4_1')
     84     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     85                      name='conv4_2')
     86     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     87                      name='conv4_3')
     88     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool4')
     89 
     90     # conv5
     91     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     92                      name='conv5_1')
     93     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     94                      name='conv5_2')
     95     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
     96                      name='conv5_3')
     97     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool5')
     98     return network``
     99 def conv_layers_simple_api(net_in):
    100     with tf.name_scope('preprocess'):
    101         # Notice that we include a preprocessing layer that takes the RGB image
    102         # with pixels values in the range of 0-255 and subtracts the mean image
    103         # values (calculated over the entire ImageNet training set).
    104         mean = tf.constant([123.68, 116.779, 103.939], dtype=tf.float32, shape=[1, 1, 1, 3], name='img_mean')
    105         net_in.outputs = net_in.outputs - mean
    106 
    107     # conv1
    108     network = Conv2d(net_in, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    109                      name='conv1_1')
    110     network = Conv2d(network, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    111                      name='conv1_2')
    112     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool1')
    113 
    114     # conv2
    115     network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    116                      name='conv2_1')
    117     network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    118                      name='conv2_2')
    119     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool2')
    120 
    121     # conv3
    122     network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    123                      name='conv3_1')
    124     network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    125                      name='conv3_2')
    126     network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    127                      name='conv3_3')
    128     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool3')
    129 
    130     # conv4
    131     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    132                      name='conv4_1')
    133     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    134                      name='conv4_2')
    135     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    136                      name='conv4_3')
    137     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool4')
    138 
    139     # conv5
    140     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    141                      name='conv5_1')
    142     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    143                      name='conv5_2')
    144     network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME',
    145                      name='conv5_3')
    146     network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool5')
    147     return network

     

        笔者偷懒直接用的是TensorLayer库中的Vgg16模型,至于什么是tensorlayer请移步这里

    按照莫烦老师的教程,改写最后的全连接层做二分类学习:

    def fc_layers(net):
        # 全连接层前的预处理
        network = FlattenLayer(net, name='flatten')
        # tf.layers.dense(self.flatten, 256, tf.nn.relu, name='fc6')
        network = DenseLayer(network, n_units=256, act=tf.nn.relu, name='fc1_relu')
        # network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc2_relu')
        # self.out = tf.layers.dense(self.fc6, 1, name='out')
        network = DenseLayer(network, n_units=2, act=tf.identity, name='fc3_relu')
        return network

     

        定义输入输出以及损失函数已及学习步骤:

     1 # 输入
     2 x = tf.placeholder(tf.float32, [None, 224, 224, 3])
     3 # 输出
     4 y_ = tf.placeholder(tf.int32, shape=[None, ], name='y_')
     5 net_in = InputLayer(x, name='input')
     6 # net_cnn = conv_layers(net_in)               # professional CNN APIs
     7 net_cnn = conv_layers_simple_api(net_in)  # simplified CNN APIs
     8 network = fc_layers(net_cnn)
     9 y = network.outputs
    10 # probs = tf.nn.softmax(y)
    11 y_op = tf.argmax(tf.nn.softmax(y), 1)
    12 cost = tl.cost.cross_entropy(y, y_, name='cost')
    13 correct_prediction = tf.equal(tf.cast(tf.argmax(y, 1), tf.float32), tf.cast(y_, tf.float32))
    14 acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    15 # 定义 optimizer
    16 train_params = network.all_params[26:]
    17 # print(train_params)
    18 global_step = tf.Variable(0)
    19 # --------------学习速率的设置(学习速率呈指数下降)--------------------- #将 global_step/decay_steps 强制转换为整数
    20 # learning_rate = tf.train.exponential_decay(1e-2, global_step, decay_steps=1000, decay_rate=0.98, staircase=True)
    21 train_op = tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.9, beta2=0.999,
    22                                   epsilon=1e-08, use_locking=False).minimize(cost, var_list=train_params)

     

        读取数据读取训练、验证数据,加载模型参数:

     1 img, label = read_and_decode("F:\\001-python\\train.tfrecords")
     2 img_v, label_v = read_and_decode("F:\\001-python\\val.tfrecords")
     3 # 使用shuffle_batch可以随机打乱输入
     4 X_train, y_train = tf.train.shuffle_batch([img, label],
     5                                           batch_size=30, capacity=400,
     6                                           min_after_dequeue=300)
     7 X_Val, y_val = tf.train.shuffle_batch([img_v, label_v],
     8                                       batch_size=30, capacity=400,
     9                                       min_after_dequeue=300)
    10 tl.layers.initialize_global_variables(sess)
    11 network.print_params()
    12 network.print_layers()
    13 npz = np.load('vgg16_weights.npz')
    14 params = []
    15 for val in sorted(npz.items())[0:25]:
    16     # print("  Loading %s" % str(val[1].shape))
    17     params.append(val[1])
    18 加载预训练的参数
    19 tl.files.assign_params(sess, params, network)

     

    加载好之后,开始训练,200个epoch:

     1 for epoch in range(n_epoch):
     2     start_time = time.time()
     3     val, l = sess.run([X_train, y_train])
     4     for X_train_a, y_train_a in tl.iterate.minibatches(val, l, batch_size, shuffle=True):
     5         sess.run(train_op, feed_dict={x: X_train_a, y_: y_train_a})
     6     if epoch + 1 == 1 or (epoch + 1) % 5 == 0:
     7         print("Epoch %d of %d took %fs" % (epoch + 1, n_epoch, time.time() - start_time))
     8         train_loss, train_acc, n_batch = 0, 0, 0
     9         for X_train_a, y_train_a in tl.iterate.minibatches(val, l, batch_size, shuffle=True):
    10             err, ac = sess.run([cost, acc], feed_dict={x: X_train_a, y_: y_train_a})
    11             train_loss += err
    12             train_acc += ac
    13             n_batch += 1
    14         print("   train loss: %f" % (train_loss / n_batch))
    15         print("   train acc: %f" % (train_acc / n_batch))

     

    保存训练的参数:

    1 tl.files.save_npz(network.all_params, name='model.npz', sess=sess)

     

    下面就是开始训练啦,笔者很高兴的拿着自己的笔记本显卡呼呼的跑了一遍:

    ~~~~~~~~~~~~~~~~~~~~~~~~下面是漫长的等待

    .......
    [TL] Epoch 138 of 150 took 0.999402s
    [TL]    val loss: 0.687194
    [TL]    val acc: 0.562500
    [TL] Epoch 140 of 150 took 3.782207s
    [TL]    val loss: 0.619966
    [TL]    val acc: 0.750000
    [TL] Epoch 142 of 150 took 0.983802s
    [TL]    val loss: 0.685686
    [TL]    val acc: 0.562500
    [TL] Epoch 144 of 150 took 0.986604s
    [TL]    val loss: 0.661224
    [TL]    val acc: 0.687500
    [TL] Epoch 146 of 150 took 1.022403s
    [TL]    val loss: 0.675885
    [TL]    val acc: 0.687500
    [TL] Epoch 148 of 150 took 0.991802s
    [TL]    val loss: 0.682124
    [TL]    val acc: 0.625000
    [TL] Epoch 150 of 150 took 3.487811s
    [TL]    val loss: 0.674932
    [TL]    val acc: 0.687500
    [TL] Total training time: 319.859640s
    [TL] [*] model.npz saved

     

    额~~~~~~~~~~~~~~~~~

    0.68的正确率,群里一位朋友看了之后说:跟猜差不多了(一脸黑线)。问题出哪儿呢?难道是笔者训练的次数不够多?莫烦老师可是100次就能出很好的结果啊

    不管怎么样,要试试,笔者于是加载刚刚保存的model.npz参数继续跑100个epoch

    ~~~~~~~~~~~~~~~~~~~~~~~~又是漫长的等待

    [TL] Epoch 1 of 100 took 8.477617s
    [TL]    val loss: 0.685957
    [TL]    val acc: 0.562500
    [TL] Epoch 2 of 100 took 0.999402s
    [TL]    val loss: 0.661529
    [TL]    val acc: 0.625000
    ......
    [TL] Epoch 94 of 100 took 0.992208s
    [TL]    val loss: 0.708815
    [TL]    val acc: 0.562500
    [TL] Epoch 96 of 100 took 0.998406s
    [TL]    val loss: 0.710636
    [TL]    val acc: 0.562500
    [TL] Epoch 98 of 100 took 0.992807s
    [TL]    val loss: 0.621505
    [TL]    val acc: 0.687500
    [TL] Epoch 100 of 100 took 0.986405s
    [TL]    val loss: 0.670647
    [TL]    val acc: 0.625000
    [TL] Total training time: 156.734633s
    [TL] [*] model.npz saved

     

    坑爹啊这是,还不如之前的结果。

    笔者陷入深深的沉思中,难道是改了全连接层导致的?于是笔者又把之前去掉的全连接层加上:

    1 def fc_layers(net):
    2     # 全连接层前的预处理
    3     network = FlattenLayer(net, name='flatten')
    4     # tf.layers.dense(self.flatten, 256, tf.nn.relu, name='fc6')
    5     network = DenseLayer(network, n_units=256, act=tf.nn.relu, name='fc1_relu')
    6     network = DenseLayer(network, n_units=256, act=tf.nn.relu, name='fc2_relu')
    7     # self.out = tf.layers.dense(self.fc6, 1, name='out')
    8     network = DenseLayer(network, n_units=2, act=tf.identity, name='fc3_relu')
    9     return network

     

    接着训练

    ~~~~~~~~~~~~~~~~~~~~~~~~下面又是漫长的等待

    1 [TL] Epoch 1 of 100 took 8.477229s
    2 [TL]    val loss: 2.370650
    3 [TL]    val acc: 0.562500
    4 ...
    5 [TL] Epoch 100 of 100 took 1.016002s
    6 [TL]    val loss: 0.762171
    7 [TL]    val acc: 0.437500
    8 [TL] Total training time: 156.836465s
    9 [TL] [*] model.npz saved

     

    还是一样,笔者已崩溃了,一定是哪儿不对啊啊啊....于是笔者去翻莫烦老师的代码,一点点对下来,每一层参数肯定不会有错,那就是在训练设置的参数有问题。

    1 self.train_op = tf.train.RMSPropOptimizer(0.001).minimize(self.loss) #莫烦的代码
    2 train_op = tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.9, beta2=0.999,
    3                                   epsilon=1e-08, use_locking=False).minimize(cost, var_list=train_params)#笔者的

     

    看到train_params难道是这个train_params?笔者只优化了最后的全连接层参数而莫烦老师优化的是全部参数

    已经深夜了,笔者表示即使不睡觉也要跑一遍试试,于是改成

     1 # 定义 optimizer
     2 train_params = network.all_params
     3 ~~~~~~~~~~~~~~~~~~~~~~~~于是又是是漫长的等待
     4 
     5 [TL] Epoch 1 of 100 took 20.286640s
     6 [TL]    val loss: 11.938850
     7 [TL]    val acc: 0.312500
     8 [TL] Epoch 2 of 100 took 3.091806s
     9 [TL]    val loss: 2.890055
    10 [TL]    val acc: 0.625000
    11 [TL] Epoch 4 of 100 took 3.074205s
    12 [TL]    val loss: 24.055895
    13 [TL]    val acc: 0.687500
    14 [TL] ....
    15 [TL]    val loss: 0.699907
    16 [TL]    val acc: 0.500000
    17 [TL] Epoch 98 of 100 took 3.089206s
    18 [TL]    val loss: 0.683627
    19 [TL]    val acc: 0.562500
    20 [TL] Epoch 100 of 100 took 3.091806s
    21 [TL]    val loss: 0.708496
    22 [TL]    val acc: 0.562500
    23 [TL] Total training time: 375.727307s
    24 [TL] [*] model.npz saved

     

    效果变得更差了....

    排除参数的问题,已经深夜1点了,明天还要上班,不得不睡啦。

    继续崩溃第三天~~~

    第四天~~~

    第五天,今天供应商过来公司调试机器,正好是一个学图像处理的小伙子,我提到这个说:我为啥训练了这么多代为啥还是像猜一样的概率....?小伙儿说:莫不是过拟合了吧?我说:不可能啊现成的数据现成的模型和参数,不应该的啊!

        不过我还是得检查一下数据处理的代码

     1 # 生成是数据文件
     2 def create_record(filelist):
     3     random.shuffle(filelist)
     4     i = 0
     5     writer = tf.python_io.TFRecordWriter(recordpath)
     6     for file in filelist:
     7         name = file.split(sep='.')
     8         lable_val = 0
     9         if name[0] == 'cat':
    10             lable_val = 0
    11         else:
    12             lable_val = 1
    13         img_path = file_dir + file
    14         img = Image.open(img_path)
    15         img = img.resize((240, 240))
    16         img_raw = img.tobytes()  # 将图片转化为原生bytes
    17         example = tf.train.Example(features=tf.train.Features(feature={
    18             "label": tf.train.Feature(int64_list=tf.train.Int64List(value=[lable_val])),
    19             'img_raw': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw]))
    20        })) #example对象对label和image进行封装
    21         writer.write(example.SerializeToString())
    22         i=i+1
    23         print(name[1])
    24         print(lable_val)
    25         print(i)
    26     writer.close()
    27 # 用队列形式读取文件
    28 def read_and_decode(filename):
    29     # 根据文件名生成一个队列
    30     filename_queue = tf.train.string_input_producer([filename])
    31     reader = tf.TFRecordReader()
    32     _, serialized_example = reader.read(filename_queue)  # 返回文件名和文件
    33     features = tf.parse_single_example(serialized_example,
    34                                        features={
    35                                            'label': tf.FixedLenFeature([], tf.int64),
    36                                            'img_raw': tf.FixedLenFeature([], tf.string),
    37                                        })
    38     img = tf.decode_raw(features['img_raw'], tf.uint8)
    39     img = tf.reshape(img, [224, 224, 3])
    40     img = tf.cast(img, tf.float32) * (1. / 255) - 0.5
    41     label = tf.cast(features['label'], tf.int32)
    42     return img, label

     

    img = tf.cast(img, tf.float32) * (1. / 255) - 0.5  难道是这一步处理多余?注销之后,训练模型

     1 Epoch 85 of 200 took 1.234071s
     2    train loss: 14.689816
     3    train acc: 0.900000
     4 [TL] [*] model3.npz saved
     5 Epoch 90 of 200 took 1.241071s
     6    train loss: 17.104382
     7    train acc: 0.800000
     8 [TL] [*] model3.npz saved
     9 Epoch 95 of 200 took 1.236071s
    10    train loss: 11.190630
    11    train acc: 0.850000
    12 [TL] [*] model3.npz saved
    13 Epoch 100 of 200 took 1.238071s
    14    train loss: 0.000000
    15    train acc: 1.000000
    16 [TL] [*] model3.npz saved
    17 Epoch 105 of 200 took 1.236071s
    18    train loss: 7.622324
    19    train acc: 0.900000
    20 [TL] [*] model3.npz saved
    21 Epoch 110 of 200 took 1.234071s
    22    train loss: 2.164670
    23    train acc: 0.950000
    24 [TL] [*] model3.npz saved
    25 Epoch 115 of 200 took 1.237071s
    26    train loss: 0.000000
    27    train acc: 1.000000
    28 [TL] [*] model3.npz saved

     

    
    

    准确度1,停停停...不用跑完了,Perfect!

    原来如此,必须要真实的像素值.......心好累......,笔者已经不记得哪儿抄来的这一行了。

    嗯,VGG16模型的迁移学习到此结束,代码见github

    转载于:https://www.cnblogs.com/zengfanlin/p/8886701.html

    展开全文
  • TensorFlow 学习总结

    千次阅读 2016-10-28 11:44:27
    1. TensorFlow 生成的 .ckpt 和 .pb 都有什么用? The .ckpt is the model given by tensorflow which includes all the weights/parameters in the model. The .pb file stores the computational graph. To ...
  • Tensorflow学习小记

    2017-03-11 22:15:34
    接触工作要,就要喽,不过就看了几天,还是比较懵的状态,所以这里把一些遇到的坑说一下,希望能对新人帮助吧。简介还是介绍一下吧,随便扯扯。Tensorflow是Google的产品,是一个人工智能和深度学习的框架。...
  • 在学习tensorflow的过程中,很多小伙伴反映读取数据这一块很难理解。确实这一块官方的教程比较简略,网上也找不到什么合适的学习材料。今天这篇文章就以图片的形式,最简单的语言,为大家详细解释一下tensorflow...
  • TensorFlow 学习 - 简介

    2017-05-31 23:08:34
    节点和线的向图描述数学计算,节点表示数学操作或者数据的输入起点重点。线表示节点之间的输入输出关系,这些数据线传输节点中的数组。当输入端的张量准备好之后,节点被分配到各个计算设备上异
  • 流畅的Python它和大多数书籍和在线教程蜻蜓点水式的讲解不同,它更加深入,深入而不冗余,在你看这本书的时候你会发现,它的每一段话都是意义的,没有什么废话。它分别从数据结构、字典集合、文本和字节序列、...
  • tensorflow学习:定义变量

    千次阅读 2017-07-13 19:41:15
    #给变量赋值为10,并给它起个名字:counter,但貌似没啥用,至少现在还不知道有什么用 stat = tf.Variable(10, name='counter') one = tf.constant(1) new_value = tf.add(stat, one) #stat = new_val
  • 在学习TensorFlow的过程中,很多小伙伴反映读取数据这一块很难理解。确实这一块官方的教程比较简略,网上也找不到什么合适的学习材料。今天这篇文章就以图片的形式,最简单的语言,为大家详细解释一下TensorFlow...
  • 在学习之前要了解,这个问题为什么会发生,因为现在的Tensorflow都是2.X版本,网上的一些代码,都是大佬1.X的版本下写的,由于在2.X的更新下,有些调用已经被2.X的版本抛弃,比如session。 虽然网上对错误许多...
  • tensorflow读取数据

    2017-08-10 19:01:36
    在学习TensorFlow的过程中,很多小伙伴反映读取数据这一块很难理解。确实这一块官方的教程比较简略,网上也找不到什么合适的学习材料。今天这篇文章就以图片的形式,最简单的语言,为大家详细解释一下TensorFlow...
  • 什么要正则化 简单来说,正则化是一种为了减小测试误差的行为(时候会增加训练误差)。我们在构造机器学习模型时,最终目的是让模型在面对新数据的时候,可以很好的表现。当你比较复杂的模型比如神经网络,去...
  • 在学习tensorflow的过程中,很多小伙伴反映读取数据这一块很难理解。确实这一块官方的教程比较简略,网上也找不到什么合适的学习材料。今天这篇文章就以图片的形式,最简单的语言,为大家详细解释一下tensorflow...
  • 第二:接着说一下,对版本的要求一定要严格(比如什么什么支持什么) 第三:尽量不要安装winodws系统的,winodws对一些支持不是很好,能Linux的尽量Linux操作系统,Linux的支持比较稳定 第四:吐槽一下:安装的...
  • (2)有些时候不可避免地要超大batch,比如人脸识别,可能每个batch要有几万甚至几十万张人脸图像,训练过程中超大batch有什么优缺点,如何尽可能地避免超大batch带来的负面影响?------------------------------...
  • 笔者学习需要,故要安装tensorlow,之所以安装1.x版本的,是因为目前能找到的学习视频都是针对1.x版本来的,而且1.x和2.x的版本差别还是一些的,笔者想着先1.x版本来学习,经过一天的安装,笔者发现安装这个并...
  • tensorflow常用函数

    2018-03-14 10:22:44
    首先肯定需要解释下什么叫做独热编码(one-hot encoding),独热编码一般是在监督学习中对数据集进行标注时候使用的,指的是在分类问题中,将存在数据类别的那一类X表示,不存在的Y表示,这里的X常常是1, ...
  • 使用tensorflow实现CNN

    万次阅读 多人点赞 2018-05-24 15:19:03
    Tensorflow作为当今最流行的机器学习框架,也是Google的亲儿子,对其学习也是必要性。当然tensorflow也出来很久了,在写本文的时候tensorflow已经是1.8版本。这篇文章没有什么理论知识,因为理论知识早在前面的...
  • 基于tensorflow的L2正则化实现前置条件什么是正则化(regularization)如果一句话解释:正则化就是通过增加权重惩罚(penalty)项到损失函数,让网络倾向于学习小一点的权重,从而达到抑制过拟合,增加模型泛化能力的...
  • tensorflow 激活函数relu6为什么是6

    万次阅读 2019-03-04 18:32:14
    relu6, y= min(max(0,x), 6), 相当于六个bernoulli分布,即6个硬币,同时抛出正面,这样鼓励网络学习到稀疏特征。 网络里面每一个输出n,相当于n个bernoulli分布的叠加。 通过实验发现,6,效果比较好。所以...
  • 十图详解TensorFlow数据读取机制(附代码)

    千次阅读 多人点赞 2017-06-09 13:54:06
    在学习TensorFlow的过程中,很多小伙伴反映读取数据这一块很难理解。确实这一块官方的教程比较简略,网上也找不到什么合适的学习材料。今天这篇文章就以图片的形式,最简单的语言,为大家详细解释一下TensorFlow...
  • 线性回归 很多数学不是太好的同学一听到线性回归这么高级的名词往往望而却步,很多东西只要深入学习并没有看起来那么可怕。...那么这么一条直线方程跟我们机器学习有什么关系呢? 假设我们要分析蟋蟀的鸣叫声与温...
  • ​熬过了上一篇漫长的代码,稍微解开了一丢丢疑惑,使得抽象...那这个感知器模型和BP网络有什么关系呢?在我们所看到的BP网络的结构图中,其实是被简化了的,下面小编画了一个逻辑更清晰一点的图: 这样我们就可以看
  • 在学习tensorflow的过程中,很多小伙伴反映读取数据这一块很难理解。确实这一块官方的教程比较简略,网上也找不到什么合适的学习材料。今天这篇文章就以图片的形式,最简单的语言,为大家详细解释一下tensorflow...
  • 在学习tensorflow的过程中,很多小伙伴反映读取数据这一块很难理解。确实这一块官方的教程比较简略,网上也找不到什么合适的学习材料。今天这篇文章就以图片的形式,最简单的语言,为大家详细解释一下tensorflow...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 294
精华内容 117
关键字:

学tensorflow有什么用