深度学习原理与框架-CNN在文本分类的应用 1.tf.nn.embedding_lookup(根据索引数据从数据中取出数据) 2.saver.restore(加载sess参数)

Posted my-love-is-python

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了深度学习原理与框架-CNN在文本分类的应用 1.tf.nn.embedding_lookup(根据索引数据从数据中取出数据) 2.saver.restore(加载sess参数)相关的知识,希望对你有一定的参考价值。

1. tf.nn.embedding_lookup(W, X) W的维度为[len(vocabulary_list), 128], X的维度为[?, 8],组合后的维度为[?, 8, 128]

代码说明一下:即根据每一行X中的一个数,从W中取出对应行的128个数据,比如X[1, 3]个数据是3062,即从W中的第3062行取出128个数据

import numpy as np
import tensorflow as tf
data = np.array([[2, 1], [3, 4], [5, 6]])
data = tf.convert_to_tensor(data)
lk = [[0,1],[1,0],[0,0], [1, 1]]
lookup_data = tf.nn.embedding_lookup(data,lk)
init = tf.global_variables_initializer()
sess = tf.Session()
print(sess.run(tf.shape(data)))
print(sess.run(tf.shape(lk)))
print(sess.run(tf.shape(lookup_data)))
print(sess.run(lookup_data))

2 . saver.restore(sess, ‘./model/-10‘) 根据路径加载sess

这里只需要输入最后参数的路径名,.后面的不需要输入

代码说明:主要是使用CNN对名字进行性别的预测,里面使用了tf.embedding_lookup() 进行维度的转换,原来的维度是?, 8, 经过转换后的维度是?, 8, 128 

数据说明:使用csv.reader()读取csv文件,将名字添加到train_x, 将性别为男的,标签train_y.append([0, 1]), 性别为女的,标签train_y.append([1,0])

                 构建vocabulary_dict 字典,统计每一个词的词频,循环,在字典里面就+1, 对统计好的字典,使用sorted进行排序,获得排序好后的key的值

                 将每一个词,使用一个数字来进行表示,使用enumerate

                 循环train_x, 获得每一个词对应的数字,并添加到列表中,如果列表的长度小于最大长度,使用0进行填充

 

代码说明:这里的代码说明:主要从两部分来进行说明:

第一部分:数据的读取,即train_vec_x, 和train_y的制作

第二部分:模型的构建

第三部分:模型的训练操作

 

第一部分:数据的读取,即train_vec_x 和train_y的制作

              第一步:构建train_x 和 train_y, 将读取数据分别添加到train_x 和train_y中

                        第一步:使用with open(‘name.csv‘) 打开文件

                        第二步:使用csv.reader(csvfile) 读取文件数据

                        第三步:循环数据,判断数据的大小是否等于2,如果等于2,使用tran_x.append(row[0])

                        第四步:判断row[1] == ‘男’:如果是train_y.append([0, 1]), 否者train_y.append([1, 0]) 作为每一个名字的标签

             第二步:构造vocabulary_dict 字典,用于统计每个词对应的词频

                        第一步:循环train_x, 每一个循环词表示name

                        第二步:使用token = [word for word in name] 将名字中的字符串组合成一个列表

                        第三步:循环token,如果word in vocabulary_dict, vocabulary_dict[word] += 1, 即词频次数加1, 如果不在,vocabulary_dict[word] = 1,相当于做了一个初始化

              第三步:vocabulary_list = [‘ ‘] + sorted(vocabulary_dict, key=vocabulary_dict.get, reverse=True) , 根据字典的值进行排序,返回字典的键,即每个词

              第四步:使用dict((x, y) for (y, x) in emurate(vocabulary_list))  将每一个词使用0, 1....相对应

              第五步:循环train_x, 生成映射的列表

                             第一步:构造train_vec_x的空列表, 循环trian_x中的name

                             第二步:构造name_vec的空列表,使用token = [word for word in name] 将名字分成一个个字的列表

                             第三步:循环token中的word,获得映射字典中vocab[word], 对应的数字索引,将其添加到name_vec

                             第四步:如果name_vec的长度小于最大长度,将name_vec继续补零, 即append(0)

                             第五步:使用train_vec_x.append(name_vec) 将每个name对应的数字映射进行添加

第二部分:构建网络模型,输出为模型的预测结果,即[None, 2]

            第一步:设置网络的基本参数,batch_size, input_size, num_classes, num_batch 

            第二步:构造网络模型的函数,输入为vocabulary_size, embedding_size, 以及filter_num 

            第三步:使用tf.placeholder(tf.int32, [None, input_size])构造X初始化,使用tf.placeholder(tf.float32, [None, 2])构造y初始化

            第四步: with tf.name_scope(‘embedding‘) 进行embedding变化

                          第一步:构建W = tf.Vairbale(tf.random_normal([vocabulary_size, embedding_size])) 

                          第二步:使用tf.embedding_lookup(W, X) 进行前向的embedding映射,此时的输出为?, 8, 128

                          第三步:使用tf.expand_dim(embedding_chars, axis=-1) 将维度转换为?, 8, 128, 1 

             第五步: 进行3种卷积核大小的卷积操作

                          第一步:定义三种卷积核尺寸的大小,分为是3, 4, 5, 构造output_pool = [] 列表

                          第二步:循环三种卷积核的大小

                          第三步:构造with tf.name_scope(‘conv_pool %d‘%(conv_size, ))

                          第四步:构造W的参数,尺寸为[conv_size, embedding_size, 1, num_filter], 构造b的参数,尺寸为[num_filter]

                          第五步:使用tf.nn.conv2d进行卷积操作,使用tf.nn.relu进行激活操作

                          第六步:使用tf.nn.max_pool进行池化操作,ksize = [1, input_size - conv_filter + 1, 1, 1] 即为卷积后的大小

                          第七步:将卷积后的结果添加到output_pool列表中

                          第八步:将output_pool使用tf.concat进行维度的合并操作

              第六步:对合并后的结果进行维度的变化,即维度变为[-1, 3*128]为了进行后续的全连接操作

              第七步:使用with tf.name_scope(‘dropout‘) 进行dropout操作,使用的是tf.nn.dropout 

              第八步:使用with tf.name_scope(‘output‘) 构造全连接操作

                           第一步:构造W的维度为[3*128, num_class], 构造b的维度为[num_class]

                           第二步:使用tf.nn.xw_plus_b进行tf.matmul(x, w) + b的操作

                           第三步:返回output结果

 

第三部分:定义train_network() 进行模型的训练

            第一步:使用neture_network(vocabulary_size= len(vocabulary_size)) 获得输出output

            第二步:使用tf.reduce_mean(tf.nn.softmax...logits()) 定义损失值loss

            第三步:使用tf.train.Adaoptimer(1e-3).minimize(loss) 减少损失值操作train_op 

            第四步:使用tf.train.Saver(tf.global_variable()) 定义保存函数Saver 

            第五步: 使用with tf.Session() 构造sess执行函数,使用sess.run()进行变量的初始化

            第六步:进行epoch的循环,进行num_batch的循环

            第七步:使用tran_vec_x[i*batch_size:(i+1)*batch]   获得x_batch, 使用train_y[i*batch_size: (i+1)*batch]获得y_batch 

            第八步:使用sess.run([train_op, loss], feed_dict={X:x_batch, y:y_batch}) 

            第九步:如果迭代1000次,打印epoch, iteration和loss

            第十步:迭代两个epoch,就是用Saver.save()进行sess的保存,

代码:main.py

import tensorflow as tf
import numpy as np
import csv

# 第一部分:数据的读取
# 第一步:创建列表train_x, train_y,将从文件中读取的名字存储在train_x, 读取的性别使用[0, 1] 或者[1, 0]储存在train_y中
train_x = []  # 创建列表
train_y = []
# 打开文件name.csv
with open(name.csv, r, encoding=utf-8) as csvfile:
    # 使用csv.reader进行读取,读取的数据为两列,第一列为名字,第二列为性别
    data_csv = csv.reader(csvfile)
    # 循环读取的数据
    for row in data_csv:
        # 如果当前行的大小为2
        if len(row) == 2:
            # 将当前行的第一个数据及name添加到train_x中
            train_x.append(row[0])
            # 如果当前行的第二个数据是‘男‘,标签train_y添加[0, 1]
            if row[1] == :
                train_y.append([0, 1])
            else:
                # 否者标签train_y添加[1, 0]
                train_y.append([1, 0])
# 打印最长的名字大小
max_len_name = max([len(name) for name in train_x])
print(max_len_name)
# 把最长的名字长度设置为8
max_len_name = 8
# 第二步:构造词频字典,建立词汇表的字典
vocabulary_dict = {}
# 循环名字
for name in train_x:
    # 将名字中的每一个字拆开,变成一个列表
    token = [word for word in name]
    # 循环字列表
    for word in token:
        # 如果这个字在词汇表的字典里,value+=1
        if word in vocabulary_dict:
            vocabulary_dict[word] += 1
        # 不在的话,就把value=1,即vocabulary_dict[word] = 1
        else:
            vocabulary_dict[word] = 1

# 第三步:对词频字典进行根据value进行排序操作,获得排序后的列表
vocabulary_list =[ ] + sorted(vocabulary_dict, key=vocabulary_dict.get, reverse=True)

# 第四步:使用dict(x, y) 构造数字映射的词袋
vocab = dict((x, y) for (y, x) in enumerate(vocabulary_list))

# 第五步:循环train_x, 组合名字中词对应的数字,将train_x中的name转换为数字列表,如果数字列表的长度小于8,即.append(0)
train_vec_x = []
for name in train_x:
    # 构造名字的vec
    name_vec = []
    # 将name拆分成一个字的列表
    token = [word for word in name]
    # 循环字列表
    for word in token:
        # 根据词典中的key,获得value进行添加到name_vec
        name_vec.append(vocab[word])
    # 如果name_vec的长度小于8,使用.append(0),补齐长度为8
    while len(name_vec) < max_len_name:
        name_vec.append(0)
    # 将组合好的名字向量添加到train_vec_x中
    train_vec_x.append(name_vec)

##################
# 第二部分:构建网络模型,输出结果为[None, num_class]即每一个类的得分值
# 第一步:构建参数input_size, batch_size, num_classes,num_batch
input_size = max_len_name  # 输入的维度,即为名字的最长距离,即为8
batch_size = 64  # 每个batch大小
num_classes = 2  # 类别结果
num_batch = len(train_vec_x) // batch_size # 一次样本经过几个batch
# 第二步:使用tf.placeholder构造X和y
X = tf.placeholder(tf.int32, [None, input_size])
y = tf.placeholder(tf.float32, [None, num_classes])
# 构造输入keep_prob的大小,用于进行dropout
dropout_keep_prob = tf.placeholder(tf.float32)
# 第三步:构造网络的输入函数
def neture_network(vocabulary_size, embedding_size=128, filter_num=128):
    # 第四步:进行embedding前向映射
    with tf.name_scope(embedding):
        # 构造W, 大小为[vocabulary_size, embedding_size]
        W = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))
        # 使用tf.nn.embedding_lookup进行投影映射,映射后的大小为[?, 8, 128]
        embedding_chares = tf.nn.embedding_lookup(W, X)
        # 使用tf.expand_dims增加维度,使其维度变为[?, 8, 128, 1]
        embedding_chares = tf.expand_dims(embedding_chares, axis=-1)
    # 第五步:进行3个不同卷积尺寸的卷积进行卷积操作,对结果进行合并
    # 三种卷积核的大小分别是3, 4, 5
    conv_sizes = [3, 4, 5]
    # 构造池化结果的列表
    pool1_output = []
    # 循环不同卷积核大小
    for conv_size in conv_sizes:
        # 构造with.name_scope参数的作用范围
        with tf.name_scope(conv-padding%d%(conv_size, )):
           # 构造卷积参数的W,维度为[conv_size, embedding_size, 1, filter_num]
           W = tf.Variable(tf.random_uniform([conv_size, embedding_size, 1, filter_num]))
           # 构造卷积参数的b,维度为[filter_num]
           b = tf.Variable(tf.constant(0.1, shape=[filter_num]))
           # 进行卷积操作和激活操作
           conv = tf.nn.relu(tf.nn.conv2d(embedding_chares, W, strides=[1, 1, 1, 1], padding=VALID) + b)
           # 进行最大值池化操作,ksize = [1, input_size=conv_size + 1, 1, 1]中间的维度为卷积后的特征层的中间两个维度
           pool = tf.nn.max_pool(conv, ksize=[1, input_size - conv_size + 1, 1, 1], strides=[1, 1, 1, 1], padding=VALID)
           # 池化后的维度大小为[?, 1, 1, 128]
           pool1_output.append(pool)
    # 将组合的维度,进行重叠操作,即维度[?, 1, 1 3*128]
    fcIn = tf.concat(pool1_output, axis=3)
    # 第六步:进行维度的变化,以进行后续的全连接操作
    fcIn = tf.reshape(fcIn, shape=[-1, 3*128])
    # 第七步:进行dropout操作
    with tf.name_scope(dropout):
        fc_dropout = tf.nn.dropout(fcIn, keep_prob=dropout_keep_prob)
    # 第八步:进行最后的全连接操作,用于进行类别得分的计算
    with tf.name_scope(output):
        # 构造全连接的W,维度为[3*128, 2]
        W = tf.Variable(tf.random_uniform([3*128, num_classes], -1.0, 1.0))
        # 构造全连接的b,维度为[2]
        b = tf.Variable(tf.constant(0.1, shape=[num_classes]))
        # 获得最后的输出得分
        output = tf.nn.xw_plus_b(fc_dropout, W, b)
    # 返回得分值
    return output
# 第三部分:进行模型的训练操作
def train_network():
    # 第一步:调用neture_network获得输出的结果output
    output = neture_network(vocabulary_size=len(vocabulary_list))
    # 第二步:使用tf.reduce_mean(tf.nn.softmax_...logits)获得损失值loss
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=output, labels=y))
    # 第三步:使用自适应损失值降低loss的操作train_op
    train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)
    # 第四步:使用tf.train.Saver构造存储sess
    saver = tf.train.Saver(tf.global_variables())
    # 第五步:使用tf.Session()获得sess执行函数,并进行参数初始化操作
    with tf.Session() as sess:
        # 参数初始化操作
        sess.run(tf.global_variables_initializer())
        # 第六步:循环epoch,循环num_batch
        for e in range(11):
            for i in range(num_batch):
                # 第七步:根据索引值构造batch_x和batch_y
                batch_x = train_vec_x[i*batch_size:(i+1)*batch_size]
                batch_y = train_y[i*batch_size:(i+1)*batch_size]
                # 第八步:使用sess.run执行train_op和loss
                _, _loss = sess.run([train_op, loss], feed_dict={X:batch_x, y:batch_y, dropout_keep_prob:0.7})
                # 第九步:如果迭代1000次打印结果
                if i % 1000 == 0:
                    print(epoch, e, iter, i, loss:, _loss)
            # 如果迭代了两次保存结果
            if e % 2 == 0:
                saver.save(sess, ./model/epoch, global_step=e)


train_network()

技术图片

下面对训练好的参数进行测试,构造函数为test_sex,由于网络结果是相同的,就不需要对上述二部分进行修改,只需要改变第三部分,test_sex(name_list)

第一步:构造test_sex进行模型的预测,输入为名字的列表

第二步:根据数字映射,构造train_x 

             第一步:构造train_x的空列表

             第二步:循环name_list,获得name

             第三步:使用token = [word for word in name] 将名字拆分成一个字的列表,构造name_vec

             第四步:循环token,将name_vec.append(vocan[word]), 将字word转换为数字

             第五步:如果name_vec的长度小于最大长度8,即使用.append(0)进行补零操作

             第六步:将name_vec添加到train_x列表中,构造了train_x 

第三步:调用neture_network()获得output

第四步:使用tf.argmax(output, axis=1) 获得得分值较大索引值,即为类别值

第五步:使用tf.train.Saver() 获得保存函数Saver 

第六步:使用with tf.Session() as sess构造sess函数

第七步:使用Saver.restore(sess, ‘./model/-10‘) 加载sess

第八步:使用sess.run(y_pred, feed_dict={X:train_x, keep_prob=1.0}) 获得预测结果

第九步:循环预测结果,如果是结果是1,打印该类别为男,如果索引值的结果为0,打印该类别为女

# 第一步:构造test_sex用于进行模型预测,输入为name_list
def test_sex(name_list):
   # 第二步:构造进行train_x
   # 构造用于存储的x
    x = []
   # 循环name列表,获得当个名字
    for name in name_list:
        # 构造name_vec列表,用于存储一个名字的向量
        name_vec = []
        # 将名字拆分成字列表
        token = [word for word in name]
        # 循环每个字
        for word in token:
            # 将字对应的词袋中的数字添加到名字的数字向量中
            name_vec.append(vocab[word])
        # 如果名字的数字向量小于8,则添加0
        while len(name_vec) < max_len_name:
            name_vec.append(0)
        # 将名字的数字向量添加到词向量中
        x.append(name_vec)
    # 第三步:调用模型,获得输出结果
    output = neture_network(vocabulary_size=len(vocabulary_list))
    # 第四步:使用tf.argmax获得最大的索引值,0或者1
    y_pred = tf.argmax(output, axis=1)
    # 第五步:使用tf.train.Saver() 构造Saver函数
    saver = tf.train.Saver(tf.global_variables())
    # 第六步:使用tf.Session() 构造执行函数
    with tf.Session() as sess:
        # 第七步:加载sess函数
        saver.restore(sess, ./model/epoch)
        # 第八步:使用sess.run执行y_pred,获得实际的预测结果
        y_pred_ = sess.run(y_pred, feed_dict={X:x, dropout_keep_prob:1.0})
        # 第九步:循环预测结果,如果索引值为1,则打印为男的, 否者打印为女的
        for i in range(len(y_pred_)):
            if y_pred_[i] == 1:
                print(name_list[i], )
            else:
                print(name_list[i], )

技术图片

              

                           

以上是关于深度学习原理与框架-CNN在文本分类的应用 1.tf.nn.embedding_lookup(根据索引数据从数据中取出数据) 2.saver.restore(加载sess参数)的主要内容,如果未能解决你的问题,请参考以下文章

用深度学习(CNN RNN Attention)解决大规模文本分类问题 - 综述和实践

Keras深度学习实战——使用卷积神经网络实现性别分类

5月深度学习班第4课CNN,典型网络结构与常用框架

检测算法简介及其原理——fast R-CNN,faster R-CNN,YOLO,SSD,YOLOv2,YOLOv3

万字总结Keras深度学习中文文本分类

万字总结Keras深度学习中文文本分类