Web Securtiy&Deep Learning

09月 18

tensorflow|lstm|for mnist

两个比较重要的深度学习模型,一个cnn(卷积神经网络),一个就是lstm(long-short-term-memory)
lstm的基本结构和rnn一致,如下图所示,和cnn在nxn的卷积中共享神经元连接权值的方式类似,lstm在传递到下一个时间状态的信息,假设各个时间点对下一个时间的影响是一致的(具体有些例外,比如说防止过度传递引起梯度爆炸,则由cell控制),这个连接的权值也可以认为是一致的

kstm1.png

那么具体的内部结构是这样的
其实lstm就是在rnn的基础上,加入了一个memory cell,这个细胞本身也具有三个门,来控制对于之前传递过来的历史信息,和当前状态的输入信息,的接受与否。
在tensorflow中,训练的时候首先需要初始化cell
lstm_cell=tf.nn.rnn_cell.BasicLSTMCell(xxx-size)
这样传递进入的xxx-size,其实也就是cell用于处理信息的神经元个数。
接下来需要首先初始化一个状态,然后决定传入的time_major与否
需要注意的一点是,time_major参数是指你的每个完整的时间序列的长度
比如一天天气预报24小时,你完整的长度就是24了
那么,传入的X的格式大概是这样的
X=[batch_size,time,xxx-size]
xxx-size是指,由于整个rnn的结构,除了一个cell外,还有输入和输出的两层fc层
那么xxx-size就是经过fc层变换后得到。
所以lstm_cell输入神经元的个数,全看你最后变换的样子(反正都是矩阵乘法)
这里以mnist为例
把一张图片看成是28个时间状态,每个时间状态对应一个28维的向量
那么X=[batch_size,28,28]
这里经过fc层变换后,28比如变成了128
那么xxx-size也就是128
需要注意的是,这里的api中,对batch_size的限制比较严,所以如果在预测的时候需要注意

init_state=lstm_cell.zero_state(xxx-size,dtype=tf.float32)
outputs,states=tf.nn.dynamic_rnn(lstm_cell,X,initial_state=init_state,time_major=False) #the final
而这里states 转换为[batch_size,xxx-size,2]的形式后

其实下标0代表了最后的向后时间输出,1代表了最后的局部输出(y)
outputs则是整个过程中序列的所有输出,所以我们的loss需要根据具体的情况来判定

lstm1.png

那么最后针对mnist进行训练,可以看到其实我们完全可以把图像当作一个序列的数据来处理。

lstm2.jpg

效果还是不错的,98%准确率

import tensorflow as tf
import numpy as np
import input_data

batch_size=100

def addlayer(input_data,insize,outsize,act_function=None):
    W=tf.Variable(tf.random_normal([insize,outsize]))
    b=tf.Variable(tf.zeros([outsize]))+0.1
    out_data=tf.matmul(input_data,W)+b
    if act_function==None:
        return out_data
    elif act_function=="relu":
        return tf.nn.relu(out_data)
    elif act_function=="softmax":
        return tf.nn.softmax(out_data)
    else:
        return tf.nn.sigmoid(out_data)
def RNN(input_data):
    #hidden laryer
    input_data=tf.reshape(input_data,[-1,28]) #equals multiply something to it 
    X=input_data
    X=addlayer(input_data,28,batch_size,act_function="relu") #relu layer
    print X.get_shape()
    X=tf.reshape(X,[batch_size,28,128]) # for cell there is 128 hidden
    lstm_cell=tf.nn.rnn_cell.BasicLSTMCell(128) #every time give it full data)
    init_state=lstm_cell.zero_state(128,dtype=tf.float32)
    outputs,states=tf.nn.dynamic_rnn(lstm_cell,X,initial_state=init_state,time_major=False) #the final
    print states.get_shape()
    result=tf.reshape(states,[batch_size,128,-1])
    result=result[:,:,1]
    results=addlayer(result,128,10,act_function="softmax")
    return results

x_input=tf.placeholder(tf.float32,[None,784])
y_input=tf.placeholder(tf.float32,[None,10])
l1=RNN(x_input)
mnist=input_data.read_data_sets("./data_set")
loss=-tf.reduce_sum(y_input*tf.log(l1+1e-6))
optimizer=tf.train.AdamOptimizer(1e-3)
train_step=optimizer.minimize(loss)
init=tf.initialize_all_variables()

sess=tf.Session()
sess.run(init)
for i in xrange(2000):
    #print sess.run(b)
    x_data,y_data=mnist.train.next_batch(batch_size)
    sess.run(train_step,feed_dict={x_input:x_data,y_input:y_data})
    if i%100==0:
        x_test,y_test=mnist.test.next_batch(batch_size)
        corret_prediction=tf.equal(tf.argmax(l1,1),tf.argmax(y_input,1))
        accuracy=tf.reduce_mean(tf.cast(corret_prediction,"float"))
        print "step:",i," loss:",sess.run(loss,feed_dict={x_input:x_data,y_input:y_data})," Accuracy:",sess.run(accuracy,feed_dict={x_input:x_test,y_input:y_test})     
09月 17

optimal algorithm|粒子群

原理很简单,可以简单的看作是动物觅食的时候,根据种群中离食物最近动物位置的反馈
以及自身离目标的最小距离(位置),和一个惯性作用的速度来决定动物前进的方向
属于群体智能的一种
学习的更新公式如下:

w0.jpg

需要进行优化的函数目标如下:

w1.jpg

优化得到的结果是:

w2.jpg

代码如下:
其中y是最希望接近的函数值,如不设置,则需要去掉abs,来得到最小函数值

import random
import math
def target(x):
    return math.sqrt(x**2+1)+1
class animal:
    def __init__(self,minvalue,maxvalue,y):
        self.x=random.uniform(minvalue,maxvalue)
        self.v=random.uniform(0,1)
        self.w=random.uniform(0,1)
        self.y=y # the target value
        self.c1=random.uniform(0,1) #self-learn rate ->for one kind of animal
        self.c2=random.uniform(0,1) #group-learn rate
        self.r1=random.uniform(0,1) # random value
        self.r2=random.uniform(0,1)
        self.best=self.x
    def learn(self,best):
        self.v=self.w*self.v+self.c1*self.r1*(self.best-self.x)+self.c2*self.r2*(best-self.x)
        self.x=self.x+self.v
        if abs(target(self.x)-y)<abs(target(self.best)-y):
            self.best=self.x
if __name__=="__main__":
    num=10000
    y=0
    best=random.uniform(-100000000,10000000) # best x
    animals=list()
    for i in range(num):
        animals.append(animal(-1000000,1000000,0))
    for i in range(1000):
        for j in animals:
            j.learn(best)
            if(abs(target(j.best)-y)<abs(target(best)-y)):
                best=j.best
        if i%100==0:
            print "now iterators:"+str(i)+",x="+str(best)+",best value="+str(target(best))
09月 17

Tensorflow|cnn|卷积神经网络入门|mnist

首先我们的卷积神经网络的结构如下:
前两层卷积,结构为5x5,步长为1的2d卷积,随后通过2x2的最大池获得特征
第一层特征图32个
第二层特征图则为64个
那么最后再进入到一个1024神经元的fc层和10 output采用one-hot编码的softmax输出层
loss function采用交叉熵。

cnn1.jpg

那么比前一个bp要卡得多,但是准确度从97%提升到了99.3% 比较优秀的一个成绩了。

dropout.png

另外用到了一个一个防止过拟合的东西,叫dropout
其实基本思路是,训练的时候,一定概率保留某个神经元,否则把它清出去。
思想来源于建立多个模型然后投票。这样其实是训练了多个keep_percent*k<k个神经元的模型。
同时在用于预测时,我们将其全部保留,keep_percent为1.0

import tensorflow as tf
import numpy as np
import input_data
def conv2d(x,W):
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool_2x2(x):
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
def Weights(shape):
    return tf.Variable(tf.truncated_normal(shape,stddev=0.1))
def Bias(shape):
    return tf.Variable(tf.constant(0.1,shape=shape))
def addlayer(input_data,insize,outsize,act_function=None):
    W=Weights([insize,outsize])
    b=Bias([outsize])
    out_data=tf.matmul(input_data,W)+b
    if act_function==None:
        return out_data
    elif act_function=="relu":
        return tf.nn.relu(out_data)
    elif act_function=="softmax":
        return tf.nn.softmax(out_data)
    else:
        return tf.nn.sigmoid(out_data)
x_input=tf.placeholder(tf.float32,[None,784])
x_image=tf.reshape(x_input,[-1,28,28,1])
y_input=tf.placeholder(tf.float32,[None,10])
W1=Weights([5,5,1,32])
b1=Bias([32])
l1=tf.nn.relu(conv2d(x_image,W1)+b1)
l1=max_pool_2x2(l1)
W2=Weights([5,5,32,64])
b2=Bias([64])
l2=tf.nn.relu(conv2d(l1,W2)+b2)
l2=max_pool_2x2(l2)
l2_flat=tf.reshape(l2,[-1,7*7*64])
#full connection (fc layer)
l3=addlayer(l2_flat,7*7*64,1024,act_function="relu")
keep_prob=tf.placeholder("float")
l3_drop=tf.nn.dropout(l3,keep_prob)
l4=addlayer(l3_drop,1024,10,act_function="softmax")
mnist=input_data.read_data_sets("./data_set")
loss=-tf.reduce_sum(y_input*tf.log(l4+1e-6))
optimizer=tf.train.AdamOptimizer(1e-5)
train_step=optimizer.minimize(loss)
init=tf.initialize_all_variables()
sess=tf.Session()
sess.run(init)
for i in xrange(3000):
    #print sess.run(b)
    x_data,y_data=mnist.train.next_batch(50)
    x_test,y_test=mnist.test.next_batch(300)
    sess.run(train_step,feed_dict={x_input:x_data,y_input:y_data,keep_prob:0.5})
    if i%100==0:
        corret_prediction=tf.equal(tf.argmax(l4,1),tf.argmax(y_input,1))
        accuracy=tf.reduce_mean(tf.cast(corret_prediction,"float"))
        print "step:",i," loss:",sess.run(loss,feed_dict={x_input:x_data,y_input:y_data,keep_prob:1.0})," Accuracy:",sess.run(accuracy,feed_dict={x_input:x_test,y_input:y_test,keep_prob:1.0}) 
09月 16

Tensorflow|softmax bp nn|mnist数据集

最近也是开始碰tensorflow了,必须说一句google好评。
符号梯度完全不用自己求了,写法上面还比theano爽一些,好评
那么下面是一个3层神经网络,隐层使用relu,输出层则是softmax
首先我选择了传送的means也就是均值误差作为loss函数
结果效果不太理想,训练缓慢而且,很明显是碰到了softmax的饱和区域问题(偏导很小,下降速度很慢)

xxx5.jpg

准确率大概是93%左右,这个数据非常差啊,于是后来还是采用了交叉熵作为loss

www.png

也就是这个函数,其中y'是y的真实数值,而log里则是我们的预测值,交叉熵是用来衡量我们的预测用于描述真相的低效性。
改良后,使用AdamOptimizer而不是传统的GradientDescentOptimizer作为优化算法
得到了比较好的结果,97%,这也是全连接bp神经网络能够做到的极限了,接下来我还会用tensorflow陆续填坑的。

xxx7.jpg

本次所用代码全部如下,一共才30行的样子,比之前自己实现的bp要短了很多。

import tensorflow as tf
import numpy as np
import input_data
def addlayer(input_data,insize,outsize,act_function=None):
    W=tf.Variable(tf.random_normal([insize,outsize]))
    b=tf.Variable(tf.zeros([outsize]))+0.1
    out_data=tf.matmul(input_data,W)+b
    if act_function==None:
        return out_data
    elif act_function=="relu":
        return tf.nn.relu(out_data)
    elif act_function=="softmax":
        return tf.nn.softmax(out_data)
    else:
        return tf.nn.sigmoid(out_data)
x_input=tf.placeholder(tf.float32,[None,784])
y_input=tf.placeholder(tf.float32,[None,10])
l1=addlayer(x_input,784,64,act_function="relu")
l2=addlayer(l1,64,10,act_function="softmax")
mnist=input_data.read_data_sets("./data_set")
loss=-tf.reduce_sum(y_input*tf.log(l2+1e-6))
optimizer=tf.train.AdamOptimizer(1e-2)
train_step=optimizer.minimize(loss)
init=tf.initialize_all_variables()
sess=tf.Session()
sess.run(init)
for i in xrange(100000):
    #print sess.run(b)
    x_data,y_data=mnist.train.next_batch(100)
    sess.run(train_step,feed_dict={x_input:x_data,y_input:y_data})
    if i%1000==0:
        corret_prediction=tf.equal(tf.argmax(l2,1),tf.argmax(y_input,1))
        accuracy=tf.reduce_mean(tf.cast(corret_prediction,"float"))
        print "step:",i," loss:",sess.run(loss,feed_dict={x_input:x_data,y_input:y_data})," Accuracy:",sess.run(accuracy,feed_dict={x_input:mnist.test.images,y_input:mnist.test.labels})
08月 21

python|bp神经网络|iris分类

写了几百年的神经网络终于写出来了。
主要遇到的几个坑点:

1.数据集里的y label必须在(0,1)间,如果你用了sigmoid作为激活函数
2.对于反向传播 S(L)=y-a(L) sigmoid函数 S(l)=w(l).S(l+1)*a(l)*(1-a(l)) sigmoid的导数

其实这里的坑点是,后面都是两两相乘,一开始用异或,输出都是1,就没注意到差别
delta(l)=S(l+1).a(l)

#-*- encoding:utf-8 -*-
import sys
import numpy as np
import os
import matplotlib.pyplot as plt
import random
from mlxtend.evaluate import plot_decision_regions
from matplotlib import animation 
reload(sys)
sys.setdefaultencoding('utf-8')
class bpnn:
    def __init__(self,a,b,c,d):
        np.random.seed(1)
        self.l0_w=np.random.random((a,b)) #输出层到隐含层的权值
        self.l1_w=np.random.random((b,c)) #隐含1层到隐含2层的权值
        self.l2_w=np.random.random((c,d)) #隐含2层到输出层的权值
    def train(self,X,Y,iterators,test_percent,lr):
        prev_loss=0
        flag=0
        for i in xrange(iterators+1):
            j=random.randint(0,len(X)-1)
            x=X[j] #取一行训练数据
            y=Y[j]
            l0=x
            l1=sigmoid(np.dot(x,self.l0_w)) #得到第一层输出
            l2=sigmoid(np.dot(l1,self.l1_w)) #得到第二层输出
            l3=sigmoid(np.dot(l2,self.l2_w))
            l3_error=l3-y  
            loss=np.sqrt(np.sum(np.square(l3_error)))*100

            l2_delta=l2.T.dot(l3_error)

            self.l2_w-=lr*l2_delta 
            l3_error=l3_error.transpose()
            l2_error=np.multiply(self.l2_w.dot(l3_error),sigmoid(l2,True).T) #不能省略求导,已经是输出了,所以直接相乘

            l1_error=np.multiply(self.l1_w.dot(l2_error),sigmoid(l1,True).T) #不能省略求导

            l1_delta=l1.T.dot(l2_error.T) #
            l0_delta=l0.T.dot(l1_error.T)
            self.l1_w-=lr*l1_delta
            self.l0_w-=lr*l0_delta
            if(flag%10000==0):
                if(flag!=0):
                    plt.plot([flag-10000,flag],[prev_loss,loss],'r--')
                plt.scatter(flag,loss,s=40,c='red')
                print "tranning:"+str(flag)+" times"+",total loss="+str(loss)
                prev_loss=loss
            flag=flag+1

    def predict(self,x):
        x=AutoNorm(x)
        l1=sigmoid(np.dot(x,self.l0_w))
        l2=sigmoid(np.dot(l1,self.l1_w))
        l3=sigmoid(np.dot(l2,self.l2_w))
        return l3
def AutoNorm(Z):   
    Zmax,Zmin = Z.max(), Z.min()
    Z = (Z - Zmin)/(Zmax - Zmin)
    return Z
def sigmoid(x,deriv=False):
    y=1.0 / (1 + np.exp(-x))
    if(deriv==True):
        return np.multiply(x,1-x)
    return y
def load_dataset(dataset,len_x,len_y):
    dataset=open(dataset,'r')
    line=dataset.readline()
    X=list()
    Y=list()
    while line:
        l=line.strip('\n')
        l=l.split(' ')
        l = [ float( l ) for l in l if l ]  
        X.append(l[0:len_x])
        Y.append(l[len_x:len_x+len_y])
        line=dataset.readline()
    return (X,Y)
if __name__=="__main__":
    degree1=4
    degree2=4
    newnn=bpnn(4,degree1,degree2,2)
    (X,Y)=load_dataset('E:\\ml\\iris.txt',4,2)
    X=np.matrix(X)
    Y=np.matrix(Y)
    X=AutoNorm(X)
    y=list()
    for i in Y:
        y.append(i.tolist()[0][0])
    plt.figure(2)
    plt.xlabel("epoch times")
    plt.ylabel("loss rate")
    plt.title("total loss rate graph")
    #ax1=plt.subplot(211)
    #ax2=plt.subplot(212)
    newnn.train(X,Y,60000,0.3,0.035)
    #plt.sca(ax1)
    #plot_decision_regions(X,y,newnn,legend=1)
    #plt.title("Decision Boundary for hidden layer size %d"%degree)
    plt.savefig('E:\\ml\\iris.jpg')
    print newnn.predict(np.matrix([6.7,3.1,4.4,1.4]))
    plt.show()

训练损失
iris_new.jpg



最新文章

最近回复

  • aaaa8:师父 受我一拜
  • 不觉:不错呦
  • TaQini:666,学习一下
  • 一周信息安全干货分享(第64期):[...]4.CCTF Web Writeup[...]
  • Silver:竟然帅了三秒?吃惊!
  • :原来还是影响心情了,你是不是攥着卡不给我就是不想让我走。那我不走...
  • aaaa8:连发两弹 扑通
  • 大寸:我来呼应一下大寸萌妹子这个称号,大寸这个实在是太汉子了!!
  • LZP:吴同学,那个rsa那么大的整数你用什么算出来的
  • Mr Liu:Introdeced by one of yr classmat...
  • 友情链接