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

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))

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用于进行模型预测，输入为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], ‘女‘)