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