2018-09-11 20:14:55 u013539952 阅读数 621
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39692 人正在学习 去看看 唐宇迪

首先梳理一下思路 输入为1,0。00异或为0,01异或为1,10异或为1,11异或为0.所以输出为2类如下图可知,需要两条线划分。

Madaline用间接地办法解决。多个线性函数进行划分,然后对各个神经元的输出做逻辑运算。如图,用两条直线实现了异或的划分。 

 线性神经网络的办法:对神经元加入非线性输入,引入非线性成分,使等效的输入维度变大

 如图,输入x1,x2分别为1,0。再加上引入的一共5个输入,y为线性激活函数,用来训练模型数据,输出仍用sign,仍为(0,1)两类。

1.导入包

import numpy as np
import matplotlib.pyplot as plt

2.输入数据

5个输入在加上偏置值设为1,则一共输入为6个数

X = np.array([[1,0,0,0,0,0],[1,0,1,0,0,1],[1,1,0,1,0,0],[1,1,1,1,1,1]])

3.标签  0 0 为 -1 10 为1 01 为1 11 为-1

Y = np.array([-1,1,1,-1])

4.权值初始化 6个权值 初始化为6 取值范围 -1,1

W = (np.random.random(6)-0.5)*2
print(W)

5.设置学习率等数据

#学习率
lr = 0.11

#计算迭代次数1
n = 0

#神经网络输出
O = 0

6.更新权值函数

# 更新权值函数
def update():
	global X,Y,W,lr,n
	n+=1
	#输出 激活函数改变
	#O = np.sign(np.dot(X,W.T))
	O = np.dot(X,W.T)
	#计算权值的改变   求平均 X的行
	W_C = lr*((Y-O.T).dot(X))/int(X.shape[0])
	W = W + W_C
	
for _ in range(1000):
	#更新权值函数
	update()

	#无论是否收敛 都循环1000次

收敛的条件有3个:

  1. 和期望值比误差小
  2. 权值的改变量小
  3. 进行多次循环

 这里是进行1000次循环来使函数收敛

7.设置正负样本

#正样本
x1 = [0,1]
y1 = [1,0]
#负样本
x2 = [0,1]
y2 = [0,1]

8.画图

算出y的公式

#划线
def calculate(x,root):
	a = W[3]
	b = W[2] + x*W[4]
	c = W[0] + x*W[1] + x*x*W[3]
	if root==1:
			return (-b+np.sqrt(b*b-4*a*c))/(2*a)
	if root == 2:
			return (-b-np.sqrt(b*b-4*a*c))/(2*a)

#取-1到2的点
xdata = np.linspace(-1,2)  
#画图
plt.figure()
#有两个值 画两条线
plt.plot(xdata,calculate(xdata,1),'r')
plt.plot(xdata,calculate(xdata,2),'r')

#正样本 蓝色表示
plt.plot(x1,y1,'bo')
#负样本 黄色表示
plt.plot(x2,y2,'yo')
plt.show()

 9.查看输出数据

# X 输入数据 W.T迭代1000次
O = np.dot(X,W.T)
print(O)

迭代1000次的结果

可以看到输出数据已经接近期望值

当迭代次数为10万次时

效果图变化不大

但输出数据已经和期望数据一致了

2019-09-03 10:14:55 joker_shy 阅读数 870
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39692 人正在学习 去看看 唐宇迪

异或问题

异或问题,简单说就是相同为0,相异为1
早在1969年时,感知机的流行,但还是不能解决异或问题,但在神经网络出现后,这个问题就被迎刃而解,加入隐藏层的神经网络就很好的解决了这个问题

数据如下

x = [[0, 0], [1, 0], [0, 1], [1, 1]]
y = [[0], [1], [1], [0]]

代码实现

import tensorflow as tf
import matplotlib.pyplot as plt

tf.set_random_seed(33)

x = [[0, 0], [1, 0], [0, 1], [1, 1]]
y = [[0], [1], [1], [0]]

X = tf.placeholder(tf.float32, shape=[None, 2])
Y = tf.placeholder(tf.float32, shape=[None, 1])

w1 = tf.Variable(tf.random_normal([2, 3]))
b1 = tf.Variable(tf.random_normal([3]))
w2 = tf.Variable(tf.random_normal([3, 1]))
b2 = tf.Variable(tf.random_normal([1]))

z1 = tf.matmul(X, w1) + b1
a1 = tf.sigmoid(z1)
z2 = tf.matmul(a1, w2) + b2
a2 = tf.sigmoid(z2)

cost = -tf.reduce_mean(Y * tf.log(a2) + (1 - Y) * tf.log(1 - a2))
cost_history = []

m = tf.cast(tf.shape(X)[0], tf.float32)
dz2 = a2 - Y
dw2 = tf.matmul(tf.transpose(a1), dz2) / m
db2 = tf.reduce_mean(dz2, axis=0)

da1 = tf.matmul(dz2, tf.transpose(w2))
dz1 = da1 * a1 * (1 - a1)
dw1 = tf.matmul(tf.transpose(X), dz1) / m
db1 = tf.reduce_mean(dz1, axis=0)

learning_rate = 3.8 * 10e-2
updata = [
    tf.assign(w2, w2 - learning_rate * dw2),
    tf.assign(b2, b2 - learning_rate * db2),
    tf.assign(w1, w1 - learning_rate * dw1),
    tf.assign(b1, b1 - learning_rate * db1)
]

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for step in range(10001):
        cost_var , _ = sess.run([cost, updata], feed_dict={X: x, Y: y})
        if step % 500 == 0:
            print('Step', step, 'Cost', cost_var)
            cost_history.append(cost_var)

    predict = sess.run(a2, feed_dict={X: x})

print('预测值为', predict)

plt.plot(cost_history[1:])
plt.show()

结果如下

Step 0 Cost 0.9873838
Step 500 Cost 0.36180282
Step 1000 Cost 0.059805408
Step 1500 Cost 0.027795581
Step 2000 Cost 0.017842356
Step 2500 Cost 0.013083072
Step 3000 Cost 0.010309634
Step 3500 Cost 0.008498434
Step 4000 Cost 0.00722454
Step 4500 Cost 0.006280598
Step 5000 Cost 0.005553428
Step 5500 Cost 0.0049763597
Step 6000 Cost 0.0045073307
Step 6500 Cost 0.004118765
Step 7000 Cost 0.00379156
Step 7500 Cost 0.0035123003
Step 8000 Cost 0.0032712156
Step 8500 Cost 0.003060991
Step 9000 Cost 0.0028760713
Step 9500 Cost 0.0027121357
Step 10000 Cost 0.002565823
预测值为 [[8.0882706e-04]
 [9.9655342e-01]
 [9.9778229e-01]
 [3.7732117e-03]]

在这里插入图片描述

2019-11-05 23:34:08 qq_43797817 阅读数 11
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39692 人正在学习 去看看 唐宇迪

在这里插入图片描述
***1.***导入安装包

import numpy as np

***2.***定义激活函数及其导数

#激活函数
def tanh(x):
    return np.tanh(x)
#激活函数导数
def tanh_prize(z):
    return 1-tanh(z)**2

或者:

def sigmoid(x):
      return 1/(1+np.exp(-x))
  
#sigmoid导函数性质:f'(t) = f(x)(1 - f(x))
def s_prime(z):
      return np.multiply(sigmoid(z), 1.0-sigmoid(z))

***3.***输入输出数据

#输入数据
x=np.array([[1,0,0],[1,0,1],[1,1,0],[1,1,1]])
#理想输出数据
y=np.array([[0,1,1,0]]).T #或y=np.array([[0],[1],[1],[0]])

***4.***权重及学习率

#输入-隐藏1层权重
w1=2*np.random.random((3,3))-1
#隐藏1-隐藏2层权重
w2=2*np.random.random((3,3))-1
#隐藏2-输出层权重
w3=2*np.random.random((3,1))-1
#学习率 改变后训练后的输出变化
lr=0.5

***5.***正反向传播计算

for i in range(20000):
    #正向传播
    L1=np.dot(x,w1)
    z1=tanh(L1)
    L2=np.dot(z1,w2)
    z2=tanh(L2)
    L3=np.dot(z2,w3)
    z3=tanh(L3)
    
    error=y-z3#误差
    if(i%2000) == 0:#每2000次查看一次
       print("error:"+str(np.mean(error)))#打印误差
    
    #逆向传播
    L3_delta=error*tanh_prize(z3)#=(理想输出-实际输出)*z3经过激活函数导数
    L2_delta=L3_delta.dot(w3.T)*tanh_prize(z2)#=下层误差*层间权值*z2经过激活函数的导数
    L1_delta=L2_delta.dot(w2.T)*tanh_prize(z1)#=下层误差*层间权值*z1经过激活函数的导数
    
    #权重更新
    w3+=lr*z2.T.dot(L3_delta)
    w2+=lr*z1.T.dot(L2_delta)
    w1+=lr*x.T.dot(L1_delta)

6.打印训练输出

print("训练输出:")
print(z3)

7.判决输出

def judge(x):
    if(x>=0.5):
       return 1
    else:
       return 0
#根据提供的函数对指定序列做映射 map(函数,一个或多个序列)
print("判决结果:")
for i in map(judge,z3):
    print(i)

8.运行结果
在Spyder中运行结果

2019-08-20 22:31:06 weixin_43216249 阅读数 91
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39692 人正在学习 去看看 唐宇迪

深度学习基础

深度学习发展历程

三起两落的深度学习:

在这里插入图片描述
1943年,由一位心理学家和一位数学家共同提出人工神经网络的基本概念,不过在当时并没有得到大众的重视。直到1957年感知器模型的提出,使得神经网络可以解决一些常规的线性分类和线性回归的任务,这引发了AI研究的热潮,但是在之后的研究中发现,它无法解决简单的异或问题(XOR),因此迎来了第一次低潮。虽然在1980年多层感知器解决了单层感知器的问题,但是对其网络参数的计算问题却成为了一个难点。但是在1986时,反向传播算法的提出解决了对少数层神经网络训练的问题,虽然依然存在一些问题,但是受限于但是的条件,通过反向传播能够简单,低效的对多层感知器进行学习,这个时候也就迎来了第二次高潮。同时,该算法的也存在缺陷,主要体现在两个方面,随着深度的加深,容易产生梯度的消失或者梯度爆炸,使得网络的参数没有得到实施的解决。除此之外呢,该算法容易陷入局部最优的问题,因此呢,便迎来了第二次低谷。而在1988年时,尽管当时提出了卷积神经网络,但是却并没有得到过多的重视。直到2006年,提出了深度学习,得益于时代的发展,人工神经网再次得到了发展,尤其在2012年,AlexNet算法的提出,引起瞩目,在此之后,各种优质算法层出不穷,作用于各个方面。

什么是人工神经网络

它属于机器学习的一种方法,而机器学习是解决人工智能问题的一种技术,最具有代表性的为深度学习。
作为一种网络,则拥有其节点,而在人工神经网络之中,称之为神经元。神经元与神经元存在一定关系。同时也组成了不同的层:输入层、输出层、隐藏层。在这里插入图片描述

什么是感知器

第一个具有完整算法描述的神经网络学习算法(称之为感知器学习算法:PLA)
任何线性分类或者线性回归问题都可以用感知器来解决。
在这里插入图片描述
为神经网络的一部分,而一个人工神经网络则是由多个感知器组成。
多层感知机(MLP,Multilayer Perceptron)也叫人工神经网络(ANN,Artificial Neural Network)

分类和回归

分类:通过网络得到离散的值,而这些值则代表着不同的类。
回归:通过网络得到连续的值。

什么是深度学习

含有多隐藏层的多层感知器就是一种深度学习结构。
在这里插入图片描述
因此神经元、感知器、神经网络与深度学习的关系如下图:
在这里插入图片描述

深度学习中的核心知识

前向运算与反向运算:

前向运算:

拿到一个深度学习网络结构之后,我们会利用该网络结构来完成一个任务,而通过该网络得到一个结果的过程就是前向运算(例如分类任务,回归任务等)。在该过程中,我们可以知道其网络结构,同时也需要知道其每一层的网络参数,而得出这些参数的过程就是方向传播的过程。而这个过程则是一个有监督的过程,可以根据样本而求出参数,之后再通过这些参数进行预测。简单来说即为:计算输出值的过程称为前向传播。(已知层的结构)

同时,这里引入了监督的概念:

有监督学习:给出的样本中的对应标签已经由人为的标注出的学习

无监督学习:只给出了样本,但是没有给出相应的标签。

半监督学习:一部分给出了标签,一部分没有标签。

网络结构的难点为:1.关于f函数是如何定义的;
2.函数中的相关参数的值分别是什么。
而前向运算,与反向运算则分别解决的相应的问题。

反向运算:

通常神经网络的结构是由人为决定的(称之为网络搭建过程)
而网络结构中的的参数求解的则是由计算机运算得出(称之为训练过程)

梯度下降算法

计算输出层结果与真实值之间的偏差来进行逐层调节参数的算法。

什么是导数

导数(一元函数)是变化率、是切线的斜率、是瞬时速度、是加速度。
在这里插入图片描述

什么是方向导数

函数在A点无数的切线的斜率的定义。每一个切线都代表一个方向的变化。(高维空间中)
在这里插入图片描述

什么是偏导数

多元函数降维时候的变化,比如二元函数固定y,只让x单独变化,从而看成是关于x的一元函数的变化来研究。
在这里插入图片描述

什么是梯度

函数在A点无数个变化方向中变化最快的那个方向。
在这里插入图片描述
在这里插入图片描述
因此可以理解为寻找最小值的过程。而梯度下降算法就是沿着导数下降的方法,进行参数更新。
在这里插入图片描述
途中阿尔法称之为学习率即为步长。

举一个非常简单的例子,如求函数f(x)=x^2的最小值。
利用梯度下降的方法解题步骤如下:
1、求梯度, 在这里插入图片描述
2、向梯度相反的方向移动 在这里插入图片描述 ,如下在这里插入图片描述
,其中, 在这里插入图片描述 为步长。如果步长足够小,则可以保证每一次迭代都在减小,但可能导致收敛太慢,如果步长太大,则不能保证每一次迭代都减少,也不能保证收敛。
3、循环迭代步骤2,直到 在这里插入图片描述的值变化到使得 在两次迭代之间的差值足够小,比如0.00000001,也就是说,直到两次迭代计算出来的 在这里插入图片描述 基本没有变化,则说明此时 在这里插入图片描述已经达到局部最小值了。
4、此时,输出 在这里插入图片描述 ,这个 在这里插入图片描述就是使得函数 在这里插入图片描述 在这里插入图片描述最小时的 在这里插入图片描述 的取值 。

因此序言选择合适的补偿/学习率。

局部最优解

在这里插入图片描述

迭代过程以及参数优化概念

神经网络参数训练是一个不断迭代的过程
在这里插入图片描述

参数更新:

参数优化的问题:
在这里插入图片描述
W为参数,X为输入值,WX则为预测值,Y为标签值。因此||WX-Y||得出的结果即为Loss,而在不断地优化地过程中则是不断缩小Loss,而不断更新参数。

深度学习发展迅猛的原因

三个因素:
在这里插入图片描述
而随着时代的发展,各个因素都得到了发展。

2018-10-10 12:10:43 qq_24074049 阅读数 1087
  • 机器学习&深度学习系统实战!

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 数学原理推导与案例实战紧密结合,由机器学习经典算法过度到深度学习的世界,结合深度学习两大主流框架Caffe与Tensorflow,选择经典项目实战人脸检测与验证码识别。原理推导,形象解读,案例实战缺一不可!具体课程内容涉及回归算法原理推导、决策树与随机森林、实战样本不均衡数据解决方案、支持向量机、Xgboost集成算法、神经网络基础、神经网络整体架构、卷积神经网络、深度学习框架--Tensorflow实战、案例实战--验证码识别、案例实战--人脸检测。 专属会员卡优惠链接:http://edu.csdn.net/lecturer/1079

    39692 人正在学习 去看看 唐宇迪

利用Python 建立两层感知器,利用W-H学习规则训练网络权值:

#!/usr/bin/env python 
# -*- coding:utf-8 -*-


import random

import numpy as np
import matplotlib.pyplot as plt

xh_number = 10000


class My_Per:
    def __init__(self, lr=0.1):
        self.lr = lr
        self.errors = []
        self.b1 = random.random()
        self.b2 = random.random()
        self.b0 = random.random()
        self.w1 = [0.12365, -0.12569]
        self.w2 = [0.12365, -0.12569]
        self.w0 = [0.12365, -0.12569]

    def train(self, Px, t, flag):
        update = self.lr * (t - self.predict(Px, flag))
        if flag == 1:
            self.b1 += update
            self.w1[0] += update*Px[0]
            self.w1[1] += update*Px[1]
        elif flag == 2:
            self.b2 += update
            self.w2[0] += update*Px[0]
            self.w2[1] += update*Px[1]
        else:
            self.b0 += update
            self.w0[0] += update*Px[0]
            self.w0[1] += update*Px[1]

    def predict(self, Px, flag):
        if flag == 1:
            number = self.w1[0] * Px[0] + self.w1[1] * Px[1] + self.b1
        elif flag == 2:
            number = self.w2[0] * Px[0] + self.w2[1] * Px[1] + self.b2
        else:
            number = self.w0[0] * Px[0] + self.w0[1] * Px[1] + self.b0

        return np.where(number >= 0, 1, 0)


def main():

    P = [[0, 0], [0, 1], [1, 0], [1, 1]]
    P1 = [[1, 0], [0, 0], [0, 0], [0, 1]]
    T = [0, 1, 1, 0]
    t1 = [1, 0, 0, 0]
    t2 = [0, 0, 0, 1]

    my_per = My_Per(0.1)
    plt.figure()
    plt.plot([0, 0], [0, 1], 'bo')
    plt.plot([1, 1], [0, 1], 'bo')
    flag = 1
    for i in range(xh_number):
        for i in range(4):
             if flag == 1:
                Px = P[i]
                t = t1[i]
                my_per.train(Px, t, flag)
                flag = 2
             elif flag == 2:
                Px = P[i]
                t = t2[i]
                my_per.train(Px, t, flag)
                flag = 0
             else:
                Px = P1[i]
                t = T[i]
                my_per.train(Px, t, flag)
                flag = 1
    x1 = np.arange(-1, 1)
    y1 = -my_per.w1[0]/my_per.w1[1]*x1-my_per.b1/my_per.w1[1]
    plt.plot(x1, y1)
    x2 = np.arange(-1, 1)
    y2 = -my_per.w2[0]/my_per.w2[1]*x1-my_per.b2/my_per.w2[1]
    plt.plot(x2, y2)
    plt.show()


if __name__ == "__main__":
    main()

分类结果(选取2次):
在这里插入图片描述
在这里插入图片描述

深度学习简史

阅读数 439

没有更多推荐了,返回首页