深度学习原理与框架-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], '女')