• Tensorflow用法简介 一个标准的模型结构分为输入、中间节点、输出三大部分,如何让这三个部分连通起来学习规则并进行计算,这便是Tensorflow框架所做的事。Tensorflow将中间节点及节点之间的运算关系(OPS)定义在...
    • Tensorflow用法简介  

    一个标准的模型结构分为输入、中间节点、输出三大部分,如何让这三个部分连通起来学习规则并进行计算,这便是Tensorflow框架所做的事。Tensorflow将中间节点及节点之间的运算关系(OPS)定义在自己内部的一个“图”内,具体的运算全部通过一个“会话(session)”进行。在会话中,任何一个节点都可以通过会话的run函数进行计算,得到该节点的数据值。

        “图”是静态的,它只是将关系搭建在一块,不会进行任何运算;而会话session是动态的,只有启动会话才会将数据流向“图”,并按照图中的关系运算并将结果从图中流出。

          模型内部的数据流向分为正向和反向(其实也就是BP神经网络):

          正向即从数据输入开始,依次进行各节点定义的运算,一直运算到输出。

          反向,只有在训练场景才会用到。先从最后一个输出节点开始,计算预期结果和真实输出的误差,这样会形成一个用学习参数表示误差的方程,然后对方程中的每个参数求导,得到其梯度修正值,同时反推出上一层的修正值,这样一直往前推,就传到正向的第一个节点了。

    • 运行代码

        以下是模拟y=2x的训练及测试过程:

    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    def moving_average(a, w=10):
        if len(a) < w:
            return a[:]
        return [val if idx < w else sum(a[(idx-w): idx])/w for idx , val in enumerate(a)]
    
    
    # 数据准备
    train_X = np.linspace(-1,1,100)
    train_Y = 1*train_X + np.random.randn(*train_X.shape)*0.3  # 加入噪声的y=2x
    # 显示模拟数据点
    plt.plot(train_X, train_Y, 'ro', label='Original data')
    plt.legend()
    # plt.show()
    
    # 正向搭建模型
    # 创建模型
    X = tf.placeholder("float")  # 占位符,x表示输入
    Y = tf.placeholder("float")  # 占位符,y表示期望输出
    W = tf.Variable(tf.random_normal([1]), name="weight")  # 模型参数,W被初始化成[-1,1]的随机数,Variable定义变量.
    b = tf.Variable(tf.zeros([1]), name="bias")  # b被初始化为0,形状也是一维的数字
    z = tf.multiply(X, W)+b  # multiply两个数相乘
    
    # 方向搭建模型
    # 反向优化
    cost = tf.reduce_mean(tf.square(Y - z))  # 期望输出与真实输出的平方差
    learning_rate = 0.01  # 学习速率,即调节参数的速率,一般小于1,值越小,表明调整的精度越高,但速度越慢。
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)  # 梯度下降,会根据学习速率调整误差
    
    # 迭代训练模型
    # Tensorflow中的任务是通过session来进行的
    # 初始化所有变量
    init = tf.global_variables_initializer()
    # 定义参数
    training_epochs = 20  # 迭代次数20次
    display_step = 2
    # 启动session
    # Tensorflow将中间节点及节点间的运算关系(OPS)定义在自己的一个“图”上,全部通过一个“(会话)session”进行图中OPS的具体运算
    with tf.Session() as sess:
        sess.run(init)  # 通过sess.run()来进行网络节点的运算
        plotdata = {"batchsize": [], "loss": []}  # 存放批次值和损失值
        # 向模型输入数据
        for epoch in range(training_epochs):
            for (x, y) in zip(train_X, train_Y):
                sess.run(optimizer, feed_dict={X: x, Y: y})  # 通过feed机制将真实数据灌到占位符对应的位置,同时每执行一次
                                                             # 都会将网络结构中的节点打印出来
    
            # 显示训练中的详细信息
            if epoch % display_step == 0:
                loss = sess.run(cost, feed_dict={X: train_X, Y: train_Y})
                print("Epoch:", epoch+1, "cost=", loss, "W=", sess.run(W), "b=", sess.run(b))
                if not (loss == "NA"):
                    plotdata["batchsize"].append(epoch)
                    plotdata["loss"].append(loss)
    
        print("Finished!")
        print("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))
    
        # 训练模型可视化
        plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fittedline')
        plt.legend()
        plt.show()
    
        plotdata["avgloss"] = moving_average(plotdata["loss"])
        plt.figure(1)
        plt.subplot(211)
        plt.plot(plotdata["batchsize"], plotdata["avgloss"], 'b--')
        plt.xlabel('Minibatch number')
        plt.ylabel('Loss')
        plt.title('Minibatch run vs.Training loss')
    
        plt.show()
    
        # 使用模型
        print("x=0.3, z=", sess.run(z, feed_dict={X: 2}))
    
    
    
    • 运行结果

    • 定义输入节点的方式

    (1)通过占位符定义,具体见上边代码。

    (2)通过字典类型定义,一般用于输入比较多的情况。

    # 占位符
    inputdict = {
        'x' = tf.placeholder("float"),
        'y' = tf.placeholder("float")
    }

    (3)直接定义,很少使用。

    • 定义“学习参数“”的变量

    (1)直接定义,具体见上边代码。

    (2)通过字典定义,在深度神经网络输入比较多时使用。

    # 模型参数
    paradict = {
        'w': tf.Variable(tf.random_normal([1])),
        'b' = tf.Variable(tf.zeros([1]))
    
    }
    # 前向结构
    z = tf.multiply(X, paradict['w'])+paradict['b']

    • 初始化所有变量

    init = tf.global_variables_initializer()
    # 启动Session
    with tf.Session() as sess:
        sess.run(init)

        注意使用tf.global_variables_initializer()初始化所有变量的步骤,必须在所有变量和OP定义完成后使用,这样才能保证定义的内容有效。

        with语法可以在session结束后自行关闭。

    参考文献:深度学习之Tensorflow——李金洪

    展开全文
  • 深度学习之TensorFlow 入门、原理与进阶实战李金洪 PDF 源代码 同是机器学习爱好者,微信多多交流!

    深度学习之TensorFlow 入门、原理与进阶实战李金洪

    1. PDF
    2. 源代码

    同是机器学习爱好者,微信多多交流!

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 深度学习入门

    2020-07-03 17:04:06
    深度学习之Tensorflow入门、原理与进阶实战-李金洪 深度学习入门 个人推荐很好得入门课程唐宇迪的课程,他的github主页https://github.com/tangyudi/Ai-learn有代码资料和他全部教授的课程 深度学习基础 卷积神经...

    个人深度学习学习路线

    相关书籍推荐

    深度学习入门:基于 Python 的理论与实现-斋藤康毅
    深度学习的数学-涌井良辛、涌井贞美
    跟着迪哥学Python数据分析与机器学习实战-唐宇迪(他的github上有)
    深度学习之Tensorflow入门、原理与进阶实战-李金洪

    深度学习入门

    个人推荐很好得入门课程唐宇迪的课程,他的github主页https://github.com/tangyudi/Ai-learn有代码资料和他全部教授的课程

    1. 深度学习基础
    2. 卷积神经网络
    3. 框架Tensorflow或Pytorch等
    4. 图像分类
    5. 调参技巧
    6. 读论文

    Tensorflow&Keras&Pytorch

    Tensorflow:慕课吴明辉深度学习课程
    Keras:先学Tensorflow在学Keras,入门更简单
    Pytorch:唐宇迪Pytorch实战系列

    LeNet&AlexNet&VggNet&Google&ResNet

    看博客,可试着学Tensorflow手工去搭建这些经典的卷积神经网络,更有利于理解卷积,池化等操作。

    数据集mnist&cifar10&cifar100&Imagenet

    使用上述经典神经网络实现这些数据集的分类,ImageNet数据集太大,且网上资源少,选择学习使用。

    后续完善中…

    展开全文
  • 深度学习之TenserFlow工程化项目实战》李金洪PDF 网盘链接:https://pan.baidu.com/s/13bDr0RunkvOZB8Uupj3nAQ提取码:8m3t 转载于:https://www.cnblogs.com/stoneacc/p/11243678.html...

    《深度学习之TenserFlow工程化项目实战》李金洪PDF

    网盘链接:https://pan.baidu.com/s/13bDr0RunkvOZB8Uupj3nAQ 提取码:8m3t

    转载于:https://www.cnblogs.com/stoneacc/p/11243678.html

    展开全文
  • 深度学习项目案例TensorFlow.rar 深度学习项目案例TensorFlow.rar 带源码
  • 实例28:用线性单分逻辑回归分析肿瘤是良性还是恶性的: from sklearn.utils import shuffle### def generate(sample_size, mean, cov, diff, regression): num_classes = 2 samples_per_class = int(sample_size...

    实例28:用线性单分逻辑回归分析肿瘤是良性还是恶性的:

    from sklearn.utils import shuffle###
    def generate(sample_size, mean, cov, diff, regression):
        num_classes = 2 
        samples_per_class = int(sample_size/2)
        
        X0 = np.random.multivariate_normal(mean, cov, samples_per_class)#方法用于根据实际情况生成一个多元正态分布矩阵,mean = 1
        Y0 = np.zeros(samples_per_class)
        
        for ci, d in enumerate(diff):
            X1 = np.random.multivariate_normal(mean+d, cov, samples_per_class)
            Y1 = (ci+1)*np.ones(samples_per_class)
            
            X0 = np.concatenate((X0,X1))#numpy提供了numpy.concatenate((a1,a2,...), axis=0)函数。能够一次完成多个数组的拼接。其中a1,a2,...是数组类型的参数
            Y0 = np.concatenate((Y0,Y1))#适合大量数据
              
        if regression == False:
            class_ind = [Y == class_number for class_number in range(num_classes)]
            Y = np.asarry(np.hstack(class_ind), dtype=np.float32)
            #array和asarray都可将结构数据转换为ndarray类型。但是主要区别就是当数据源是ndarray时,array仍会copy出一个副本,占用新的内存,但asarray不会。
        

        #X=random.shuffle(X0)
        #Y=random.shuffle(Y0)#shuffle() 方法将序列的所有元素随机排序   import random  random.shuffle (lst )
        X, Y = shuffle(X0, Y0)

        return X,Y
            
        
        
    import numpy as np
    import matplotlib.pyplot as plt
    import tensorflow.compat.v1 as tf
    tf.disable_v2_behavior()
    np.random.seed(10)
    num_classes = 2
    mean = np.random.randn(num_classes)
    cov = np.eye(num_classes)
    X, Y = generate(1000, mean, cov, [3.0], True)
    colors = ['r' if l == 0 else 'b' for l in Y[:]]
    plt.scatter(X[:,0], X[:,1], c=colors)
    plt.xlabel("Scaled age (in yrs)")
    plt.ylabel("Tumor size (in cm)")
    plt.show()
    lab_dim = 1
    #构建网络结构
    input_dim = 2
    input_features = tf.placeholder(tf.float32, [None, input_dim])
    input_lables = tf.placeholder(tf.float32, [None, lab_dim])
    #定义学习参数
    W = tf.Variable(tf.random_normal([input_dim,lab_dim]), name = 'weight')
    b = tf.Variable(tf.zeros([lab_dim]), name = 'bias')

    output = tf.nn.sigmoid(tf.matmul(input_features, W) + b)
    cross_entropy = -(input_lables * tf.log(output) + (1- input_lables) * tf.log(1 - output))
    ser = tf.square(input_lables - output)
    loss = tf.reduce_mean(cross_entropy)
    err = tf.reduce_mean(ser)
    optimizer = tf.train.AdamOptimizer(0.04)
    train = optimizer.minimize(loss)
    #训练
    maxEpochs = 50
    minibatchsize = 25
    #启动session
    with tf.Session() as sess:
        tf.global_variables_initializer().run()
        #向模型输入数据
        for epoch in range(maxEpochs):
            sumerr = 0
            for i in range(np.int32(len(Y)/minibatchsize)):
                x1 = X[i * minibatchsize: (i+1)*minibatchsize,:]
                y1 = np.reshape(Y[i * minibatchsize:(i+1)*minibatchsize], [-1,1])
                tf.reshape(y1,[-1,1])
                _,lossval,outputval,errval = sess.run([train, loss, output,err], feed_dict = {input_features: x1, input_lables: y1})
                sumerr = sumerr + errval
                
            print("Epoch:",'%04d'%(epoch+1), "cost =","{:.9f}".format(lossval),"err =",sumerr/minibatchsize)
            
            
        #数据可视化
        train_X, train_Y = generate(100, mean, cov, [3.0], True)
        colors = ['r'if l == 0 else 'b' for l in train_Y[:]]
        plt.scatter(train_X[:,0], train_X[:,1], c = colors)
        x = np.linspace(-1,8,200)
        y = -x*(sess.run(W)[0]/sess.run(W)[1])-sess.run(b)/sess.run(W)[1]
        plt.plot(x,y, label = 'Fitted line')
        plt.legend()
        plt.show()

    运行结果:

    实例29:用线性逻辑回归处理多线性分类问题


    # -*- coding: utf-8 -*-

    import tensorflow.compat.v1 as tf
    tf.disable_v2_behavior()

    import numpy as np

    import matplotlib.pyplot as plt

     

    from sklearn.utils import shuffle

    from matplotlib.colors import colorConverter, ListedColormap 

        

    # 对于上面的fit可以这么扩展变成动态的

    from sklearn.preprocessing import OneHotEncoder

    def onehot(y,start,end):

        ohe = OneHotEncoder()

        a = np.linspace(start,end-1,end-start)

        b =np.reshape(a,[-1,1]).astype(np.int32)

        ohe.fit(b)

        c=ohe.transform(y).toarray()  

        return c     

    #

        

    def generate(sample_size, num_classes, diff,regression=False):

        np.random.seed(10)

        mean = np.random.randn(2)

        cov = np.eye(2)  

        

        #len(diff)

        samples_per_class = int(sample_size/num_classes)

     

        X0 = np.random.multivariate_normal(mean, cov, samples_per_class)

        Y0 = np.zeros(samples_per_class)

        

        for ci, d in enumerate(diff):

            X1 = np.random.multivariate_normal(mean+d, cov, samples_per_class)

            Y1 = (ci+1)*np.ones(samples_per_class)

        

            X0 = np.concatenate((X0,X1))

            Y0 = np.concatenate((Y0,Y1))

            #print(X0, Y0)

        

      

        if regression==False: #one-hot  0 into the vector "1 0

            Y0 = np.reshape(Y0,[-1,1])        

            #print(Y0.astype(np.int32))

            Y0 = onehot(Y0.astype(np.int32),0,num_classes)

            #print(Y0)

        X, Y = shuffle(X0, Y0)

        #print(X, Y)

        return X,Y    

     

     

    # Ensure we always get the same amount of randomness

    np.random.seed(10)

     

    input_dim = 2

    num_classes =3 

    X, Y = generate(2000,num_classes,  [[3.0],[3.0,0]],False)

    aa = [np.argmax(l) for l in Y]

    colors =['r' if l == 0 else 'b' if l==1 else 'y' for l in aa[:]]

     

    plt.scatter(X[:,0], X[:,1], c=colors)

    plt.xlabel("Scaled age (in yrs)")

    plt.ylabel("Tumor size (in cm)")

    plt.show()

     

    #参考了https://blog.csdn.net/weixin_37993251/article/details/89601178该文

    运行截图:

    #构建网络结构
    import tensorflow.compat.v1 as tf
    tf.disable_v2_behavior()
    lab_dim = num_classes
    #定义占位符
    input_features = tf.placeholder(tf.float32, [None, input_dim])
    input_labels = tf.placeholder(tf.float32, [None, lab_dim])
    #定义学习参数
    W = tf.Variable(tf.random_normal([input_dim, lab_dim]),name = 'weight')
    b = tf.Variable(tf.zeros([lab_dim]),name = 'bias')
    output = tf.matmul(input_features, W)+ b
    z = tf.nn.softmax(output)

    a1 = tf.argmax(tf.nn.softmax(output), axis = 1)#按行找出索引值,生成数组
    b1 = tf.argmax(input_labels, axis = 1)
    err = tf.count_nonzero(a1-b1)#两个数组相减,不为0就是错误个数
    cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels= input_labels,logits=output)
    loss = tf.reduce_mean(cross_entropy)
    optimizer = tf.train.AdamOptimizer(0.04)
    train = optimizer.minimize(loss)

     

    #训练
    maxEpochs = 50
    minibatchsize = 25
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        
        for epoch in range(maxEpochs):
            sumerr = 0
            for i in range(np.int32(len(Y)/minibatchsize)):
                x1 = X[i * minibatchsize:(i+1)*minibatchsize,:]
                y1 = Y[i * minibatchsize:(i+1)*minibatchsize,:]
                
                _,lossval, outputval,errval = sess.run([train,loss,output,err], feed_dict = {input_features: x1, input_labels:y1})
                sumerr= sumerr + (errval/minibatchsize)
            print("Epochs:", '%04d'%(epoch+1),"cost=","{:.9f}".format(lossval),"err=",sumerr/minibatchsize)
        
    #数据可视化
        train_X,train_Y = generate(200,num_classes, [[3.0],[3.0,0]],False)
        aa = [np.argmax(1) for l in train_Y]
        colors = ['r'if l ==0 else 'b' if l==1 else 'y' for l in aa[:1]]
        plt.scatter(train_X[:,0], train_X[:,1], c=colors)

        x=np.linspace(-1,8,200)
        y=-x*(sess.run(W)[0][0]/sess.run(W)[1][0])-sess.run(b)[0]/sess.run(W)[1][0]
        plt.plot(x,y, label='first line', lw=3)
        
        y=-x*(sess.run(W)[0][1]/sess.run(W)[1][1])-sess.run(b)[1]/sess.run(W)[1][1]
        plt.plot(x,y, label='second line',lw=2)
        
        y=-x*(sess.run(W)[0][2]/sess.run(W)[1][2])-sess.run(b)[2]/sess.run(W)[1][2]
        plt.plot(x,y, label='third line', lw=1)

        plt.legend()
        plt.show()
        print(sess.run(W), sess.run(b))
        
        
        #模型可视化
        train_X,train_Y = generate(200, num_classes, [[3.0], [3.0, 0]], False)
        aa = [np.argmax(1) for l in train_Y]
        colors = ['r' if l==0 else 'b' if l==1 else 'y' for l in aa[:]]
        plt.scatter(train_X[:,0], train_X[:,1], c=colors)
        
        nb_of_xs = 200
        xs1 = np.linspace(-1, 8, num=nb_of_xs)
        xs2 = np.linspace(-1, 8, num=nb_of_xs)
        xx,yy = np.meshgrid(xs1, xs2)
        #初始化和填充classification plane
        classification_plane = np.zeros((nb_of_xs, nb_of_xs))
        for i in range(nb_of_xs):
            for j in range(nb_of_xs):
                classification_plane[i, j] = sess.run(a1, feed_dict= {input_features: [[xx[i,j], yy[i,j] ]]})
         #创建color map显示
        cmap = ListedColormap([
            colorConverter.to_rgba('r', alpha=0.30),
            colorConverter.to_rgba('b', alpha=0.30),
            colorConverter.to_rgba('y', alpha=0.30)])
        #图示各个样本边界
        plt.contourf(xx,yy,classification_plane, cmap=cmap)
        plt.show()

     

    运行截图:

    展开全文
  • 深度学习Tensorflow工程化项目实战读书笔记 之后将进行笔记更新
  • 本系列专门用来记录我的深度学习历程,其中代码大部分均出自于李金洪老师的《深度学习之TensorFlow》,希望所有机器学习的道友都能有所知、有所得。 import tensorflow as tf import numpy as np import ...
  • 对应《深度学习之tensorflow入门、原理与进阶实战》大量的实例(共96个),全面而深入地讲解了深度学习神经网络原理和TensorFlow使用方法两方面的内容。实例具有很强的实用性,如对图片分类、制作一个简单的聊天...
  • 资料:《深度学习之Tensorflow工程化项目实战》 章节:第四章 代码分析: **·**实例4.11: line31: label = tf.one_hot(label, depth=2, on_value=1) 分析:tf中标签转独热编码,depth为编码深度,可以理解为类别...
  • 自己学习机器学习有一段时间了,有了一定基础,学习下深度学习和TensorFlow 汇总下找到的比较好看学习资源,也方便看 深度学习 理论篇–视频 吴恩达教授的视频 网易云课堂吴恩达deeplearning 课程学习的...
  • 想跟一下深度学习的浪潮,所以在网上购买了两本深度学习的框架书,一本是《TensorFlow》,另外一本是《caffe》,因为刚刚看完了Python的基础语法,caffe书上的实例代码是用的c++,所以先读了TensorFlow这本书。...
  • 课程章节 第1章Tensorflow基础操作1小时17分钟8节 1-1Tensorflow案例实战视频课程01 课程简介 00:38 1-2Tensorflow案例实战视频课程02 Tenso 07:09 1-3Tensorflow案例实战视频课程03 基本计算单元-变量 08:32 ...
  • GitHub源码 要求 假设有函数y = cos(ax + b), 其中a为学号前两位,b为学号最后两位。首先从此函数中以相同步长(点与点之间在x轴上距离相同),在0<(ax+b)<2pi范围内,采样出2000个点,然后利用采样的2000个点...
  • 深度学习TensorFlow入门

    2018-12-20 19:05:32
    TensorFlow是一个基于数据流编程(dataflow programming)的符号数学系统,被广泛应用于各类机器学习(machine learning)算法的编程实现,其前身是谷歌的神经网络算法库DistBelief。 安装 这里使用的是Anaconda安装...
  • 无论是作为行业内的从业者还是一个组织,在开始深度学习应用之前,都需要掌握两件事: 1. 知其然:掌握一个基础概念,知道深度学习的最新发展可以实现什么。 2. 知其所以然:训练一个新模型或在生产环境下...
  • 深度学习之TensorFlow

    2019-08-09 13:01:04
    TensorFlow在win下可以使用pip安装,pip install TensorFlow ...作为机器学习中更专业的技术,当然还会依赖继续学习中的类库,因此, aconda是必须安装的。 TensorFlow较其他工具有独特的优势,界...
  • 《机器学习实战:基于Scikit-Learn和TensorFlow》高清中文版PDF+高清英文版PDF+源代码 高清中文版PDF,带目录和书签,文字能够复制粘贴;高清英文版PDF,564页,带目录和书签,文字能够复制粘贴;中英文两版可以...
  • 首先解决数据问题,由于tensorflow自带手写数据集,本次直接使用,划重点来了:无论是机器学习还是深度学习,首先最难的也是最复杂的都是数据集的筛选和清理。数据集的好坏直接影响了学习的成败。tensorflow自带的...
  • 为了构建深度神经网络,你需要学会使用的一个基本的卷积操作就是padding,让我们来看看它是如何工作的。我们在之前视频中看到,如果你用一个3×3的过滤器卷积一个6×6的图像,你最后会得到一个4×4的输出,也就是一...
1 2 3 4 5 6
收藏数 103
精华内容 41