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], '女')
