Waiting~G

一起走过的日子

Archive for the ‘学.机器学习’ Category

Tensorflow-cnn卷积神经网络

without comments

卷积神经网络 CNN (Convolutional Neural Network)

一、CNN在图片上的简单运用

 

比较流行的一种搭建结构是这样, 从下到上的顺序, 首先是输入的图片(image), 经过一层卷积层 (convolution), 然后在用池化(pooling)方式处理卷积的信息, 这里使用的是 max pooling 的方式. 然后在经过一次同样的处理, 把得到的第二次处理的信息传入两层全连接的神经层 (fully connected),这也是一般的两层神经网络层,最后在接上一个分类器(classifier)进行分类预测

二、CNN在图片上的简单运用


# -*- coding: utf-8 -*-
“””
————————————————-
File Name:
     cnn
Author :       skymaxu
date:
          2017/12/6

————————————————-
“””
__author__ = ‘skymaxu’

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets(‘MNIST_data’, one_hot=True)

def add_layer(inputs, in_size, out_size, active_function=None):
Weight = tf.Variable(tf.random_normal([in_size, out_size]))
biasis = tf.Variable(tf.zeros([1, out_size]) + 0.1)
Wx_plus_b = tf.matmul(inputs, Weight) + biasis
if active_function is None:
outputs = Wx_plus_b
else:
outputs = active_function(Wx_plus_b)
return outputs

def compute_accuracy(v_xs, v_ys):
global predcition
y_pre = sess.run(predcition, feed_dict={xs: v_xs, keep_prob: 1})
correct_prediction = tf.equal(tf.argmax(y_pre, 1), tf.argmax(v_ys, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
result = sess.run(accuracy, feed_dict={xs: v_ys, ys: v_ys, keep_prob: 1})
return result

def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
# inital=tf.random_normal()
return tf.Variable(initial)

def bia_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)

def conv2d(x, W):
# stride=[1,x_movement,y_movement,1]
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 compute_accuracy1(v_xs, v_ys):
global prediction
y_pre = sess.run(prediction, feed_dict={xs: v_xs})
# tf.argmax(vector, 1):返回的是vector中的最大值的索引号,
# 如果vector是一个向量,那就返回一个值,如果是一个矩阵,那就返回一个向量,
# 这个向量的每一个维度都是相对应矩阵行的最大值元素的索引号。

# cast(x, dtype, name=None)
# 将
x的数据格式转化成dtype.例如,原来x的数据格式是bool,
# 那么将其转化成float以后,就能够将其转化成0和1的序列。反之也可以

# tf.equal(A, B)
# 是对比这两个矩阵或者向量的相等的元素,如果是相等的那就返回
True,反正返回False,返回的值的矩阵维度和A是一样的
correct_prediction = tf.equal(tf.argmax(y_pre, 1), tf.argmax(v_ys, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
result = sess.run(accuracy, feed_dict={xs: v_xs, ys: v_ys})
return result

# define placeholder for inputs to network
keep_prob = tf.placeholder(tf.float32)
xs = tf.placeholder(tf.float32, [None, 784])
ys = tf.placeholder(tf.float32, [None, 10])
# print(x_image.shape) [n_samples,28,28,1]
x_image = tf.reshape(xs, [-1, 28, 28, 1])

# add output layer
# conv1 layer
# patch/kernel 5*5 in_size=1,out_size=32
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bia_variable([32])
# output size 28*28*32
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
# output size 14*14*32
h_pool1 = max_pool_2x2(h_conv1)

# conv2 layer
# patch/kernel 5*5 in_size=32,out_size=64
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bia_variable([64])
# output size 14*14*64
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
# output size 7*7*32
h_pool2 = max_pool_2x2(h_conv2)

# func1 layer
# in_size=7 * 7 * 64,out_size=1024
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_cf1 = bia_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1 + b_cf1))
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
# func2 layer
# in_size=1024,out_size=10
W_fc2 = weight_variable([1024, 10])
b_cf2 = bia_variable([10])
predcition = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2 + b_cf2))

# the error between prediction and real data
# oss函数(即最优化目标函数)选用交叉熵函数。交叉熵用来衡量预测值和真实值的相似程度,如果完全相同,它们的交叉熵等于零
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(predcition), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

sess = tf.Session()
sess.run(tf.global_variables_initializer())

for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict={xs: batch_xs, ys: batch_ys, keep_prob: 0.5})
if i % 50 == 0:
print(compute_accuracy(mnist.test.images, mnist.test.labels))

*Ps:机器性能不好的,别乱运行,小心挂掉

 

三、Saver 保存读取

我们搭建好了一个神经网络, 训练好了, 肯定也想保存起来, 用于再次加载.用 Tensorflow 中的 saver 保存和加载.

PS:当前tensorflow仅仅能保存变量,并不能保存模型;

 

保存:

# -*- coding: utf-8 -*-
“””
————————————————-
File Name:
     saver
Author :       skymaxu
date:
          2017/12/13

————————————————-
“””
__author__ = ‘skymaxu’

import tensorflow as tf
import numpy as np

# save to file
W = tf.Variable([[1, 2, 3], [3, 4, 5]], dtype=tf.float32, name=‘Weight’)
b = tf.Variable([[1, 2, 3]], dtype=tf.float32, name=‘biasis’)

init = tf.global_variables_initializer()
saver = tf.train.Saver()

with tf.Session() as sess:
sess.run(init)
save_path = saver.save(sess, ‘model/save_net.ckpt’)
print(‘Save to path:’, save_path)

 

提取:

# -*- coding: utf-8 -*-
“””
————————————————-
File Name:
     saver
Author :       skymaxu
date:
          2017/12/13

————————————————-
“””
__author__ = ‘skymaxu’

import tensorflow as tf
import numpy as np


#restore
W = tf.Variable(np.arange(6).reshape((2, 3)), dtype=tf.float32, name=‘weight’)
b = tf.Variable(np.arange(3).reshape((1, 3)), dtype=tf.float32, name=‘biasis’)

saver = tf.train.Saver()
with tf.Session()  as sess:
saver.restore(sess, ‘model/save_net.ckpt’)
print(‘weight:’, sess.run(W))
print(‘biasis:’, sess.run(b))

 

Written by Skyma

一月 1st, 2018 at 1:36 下午

Posted in 学.机器学习

自然语言处理基础-词向量化

without comments

自然语言处理是机器学习的入门基础;作为特征工程的重要手段;必须要了解该知识,下面就从文本提取到出关键词(IFTDF),并对关键特征工程向量化详细描述整个过程;

 

首要条件:

两段文本信息:aitext.txt,aitest_bak.txt

停止词文档:stop_word.txt,该文档在百度上可以下载

 

第一步:对要处理的文本进行分词

原理:

import jieba

df = open(“aitext.txt”, encoding=‘utf8’, errors=‘ignore’)
df1 = df.read()  # openread放在一起,read只能用一次
df_test = df1[0:10]

df.close()
# print(df_test)

cf = open(“aitext_bak.txt”, encoding=‘utf8’, errors=‘ignore’)
cf1 = cf.read()
cf_test = cf1[0:10]

cf.close()
# print(cf_test)

df_ceshi = jieba.lcut(df_test)
cf_ceshi = jieba.lcut(cf_test)
cf_r = ” “.join(cf_ceshi)
df_r = ” “.join(df_ceshi)
print(cf_r)
print(df_r)

stop_words = open(“stop_word.txt”, encoding=‘utf8’, errors=‘ignore’)
stop_content = stop_words.read()  # 现实内容
stop_list = stop_content.splitlines()  # 将停用词表转化为list
stop_words.close()
# print(stop_list)

 

第二步: 使用scikit-learn工具处理 方案一,原理:使用scikit-learn向量化

 

from sklearn.feature_extraction.text import TfidfVectorizer

corpus = [cf_r, df_r]
print(‘—-corpus—-‘, corpus)
vector = TfidfVectorizer(stop_words=stop_list)  # 将停词引入模型
print(‘—-vector—-‘, vector)
tfidf = vector.fit_transform(corpus)  # 模型向量化
###每次词和TF-IDF的对应关系
wordlist = vector.get_feature_names()  # 获取词带模型中的所有词
print(‘—wordlist—‘, wordlist)
weightlist = tfidf.toarray()  # 将tf-idf矩阵抽取出来,元素a[i][j]表示j词在i类文本中的tf-idf权重
print(‘—weightlist—‘, weightlist)

 

方案二,原理:用scikit-learn的CountVectorizer类完成词频统计和向量化

from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer(stop_words=stop_list)  # 该类会将文本中的词语转换为词频矩阵,矩阵元素a[i][j] 表示j词在i类文本下的词频
transformer = TfidfTransformer()  # 该类会统计每个词语的tf-idf权值
tfidf = transformer.fit_transform(
vectorizer.fit_transform(corpus))  # 第一个fit_transform是计算tf-idf,第二个fit_transform是将文本转为词频矩阵
word = vectorizer.get_feature_names()  # 获取词袋模型中的所有词语
weight = tfidf.toarray()  # 将tf-idf矩阵抽取出来,元素a[i][j]表示j词在i类文本中的tf-idf权重

for i in range(len(weight)):
print(“…….第 %s 段文本的词语ti-idf权重………” % i)
for j in range(len(word)):
print(wordlist[j], weightlist[i][j])

 

结果如下格式:

 

—wordlist— [‘分类’, ‘标签’, ‘混蛋’, ‘第一种’]
—weightlist— [[ 0.50154891 0. 0.70490949 0.50154891]
[ 0.50154891 0.70490949 0. 0.50154891]]
…….第 0 段文本的词语ti-idf权重………
分类 0.501548907094
标签 0.0
混蛋 0.704909488931
第一种 0.501548907094
…….第 1 段文本的词语ti-idf权重………
分类 0.501548907094
标签 0.704909488931
混蛋 0.0
第一种 0.501548907094

 

 

Written by Skyma

十一月 12th, 2017 at 1:51 下午

Posted in 学.机器学习

机器学习——常见的算法和分类

without comments

第一种分类;按照标签分类

有监督学习:明确的给出每一个样本属于哪一个类别或者相关标签;常见的算法:分类回归算法

无监督学习:没有标签,不知道分为多少类,也不关心类是什么;常见的是聚类算法,k-means(一个聚类算法通常只需要知道如何计算相似度就可以开始工作了)

半监督学习:基本思想是利用数据分布上的模型假设建立学习器对未标签样例进行标签;强化学习

第二种分类:根据解决问题分类

分类和回归

聚类

标注

第三种分类:根据算法本质分类

生成模型(模糊判断 百分比 概率)    如:贝叶斯

判别模型 (判断属于哪个类型)   如:分类回归

————————————————————————

机器学习常见算法:

分类           c4.5    1993

聚类    K-means     1967

统计学习      svm         1995

关联统计    Apriori (FP-Growth) 1994

统计学习   EM              2000

链接挖掘    PageRank      1998

集装与推进     AdaBoost        1997

分类              KNN              1996

分类               Naive   Bayes        2001(http://www.cnblogs.com/leoo2sk/archive/2010/09/17/naive-bayesian-classifier.html)

分类          CART           1984

 

 

 

 

Written by Skyma

十月 8th, 2017 at 6:51 上午

Posted in 学.机器学习

机器学习——解决问题的框架

without comments

第一步:确认目标 :

根据业务需求,找到相关 数据 ,提取特征工程(特征工程占比 大约在百分之70 )

第二步:模型的训练过程:

首先定义模型,其次定义一个损失函数,最后进行调优( 能做的调成对性能的提升效果不大)

f(w):=eR(w)+sum(L(w,xi,yi))/n
第三步:模型评估

首先进行交叉验证,然后进行效果评估(ROC/AUC)

Written by Skyma

十月 8th, 2017 at 5:57 上午

Posted in 学.机器学习