def forward(self,examples,labels):
"""建立前向传播图"""
opts = self._options
# 声明所有需要的变量
# embeddings ：[vocab-size,emb_size]
init_width = 0.5 / opts.emb_dim
emb = tf.Variable(
tf.random_uniform([opts.vocab_size,opts.emb_dim], -init_width,init_width),name = "emb")
self._emb = emb
# softmax_weights:[vocab_size,emb_dim]
sm_w_t = tf.Variable(
tf.zeros([opts.vocab_size,opts.emb_dim]),name="sm_w_t")
# softmax bias:[emd_dim]
sm_b = tf.Variable(
tf.zeros([opts.vocab_size]),name="sm_b")
# global step:scalar
self.global_step = tf.Variable(0,name="global_step")
# 候选采样计算nce loss的节点
labels_matrix = tf.reshape(
tf.cast(labels,dtype=tf.int64),[opts.batch_size,1])
# 负采样
sampled_ids, _,_ = (tf.nn.fixed_unigram_candidate_sampler(
true_classes=labels_matrix,
num_true=1,
num_sampled=opts.num_samples,
unique=True,
range_max=opts.vocab_size,
distortion=0.75,
unigrams=opts.vocab_counts.tolist()))
# 样本的嵌入:[batch_size,emb_dim]
example_emb = tf.nn.embedding_lookup(emb,examples)
# 标签的权重w：[batch_size,emb_dim]
true_w = tf.nn.embedding_lookup(sm_w_t,labels)
# 标签的偏差b ：[batch_size,1]
true_b = tf.nn.embedding_lookup(sm_b,labels)
# 采样样本的ids的权重(Weights for sampled ids):[num_sampled,emb_dim]
sampled_w = tf.nn.embedding_lookup(sm_w_t, sampled_ids)
# 采样样本的 bias :[num_sampled,1]
sampled_b = tf.nn.embedding_lookup(sm_b,sampled_ids)
# True logits:[batch_size,1]
true_logits = tf.reduce_sum(tf.multiply(example_emb,true_w),1) + true_b
# 采样样本预测值 sampled logits:[batch_size,num_sampled]
sampled_b_vec = tf.reshape(sampled_b,[opts.num_samples])
sampled_logits = tf.matmul(example_emb,
sampled_w,
transpose_b=True) + sampled_b_vec
return true_logits,sampled_logits
def normalize(inputs, epsilon=1e-8, scope="ln", reuse=None):
with tf.variable_scope(scope, reuse=reuse):
inputs_shape = inputs.get_shape()
param_shape = inputs_shape[-1:]
mean, variance = tf.nn.moments(inputs, [-1], keep_dims=True)
beta = tf.Variable(tf.zeros(param_shape))
gamma = tf.Variable(tf.ones(param_shape))
normalized = (inputs - mean) / ((variance + epsilon)**(.5))
outputs = gamma * normalized + beta
return outputs
def training(loss, learning_rate):
"""Sets up the training Ops.
Creates a summarizer to track the loss over time in TensorBoard.
Creates an optimizer and applies the gradients to all trainable variables.
The Op returned by this function is what must be passed to the
`sess.run()` call to cause the model to train.
Args:
loss: Loss tensor, from loss().
learning_rate: The learning rate to use for gradient descent.
Returns:
train_op: The Op for training.
"""
# Add a scalar summary for the snapshot loss.
tf.summary.scalar('loss', loss)
# Create the gradient descent optimizer with the given learning rate.
optimizer = tf.train.GradientDescentOptimizer(learning_rate)
# Create a variable to track the global step.
global_step = tf.Variable(0, name='global_step', trainable=False)
# Use the optimizer to apply the gradients that minimize the loss
# (and also increment the global step counter) as a single training step.
train_op = optimizer.minimize(loss, global_step=global_step)
return train_op
def __init__(self, is_training, config):
self.batch_size = batch_size = config.batch_size # batch_size
self.num_steps = num_steps = config.num_steps #
size = config.hidden_size # 隐藏层
vocab_size = config.vocab_size # 词表size
# 输入占位符
self._input_data = tf.placeholder(tf.int32, [batch_size, num_steps])
self._targets = tf.placeholder(tf.int32, [batch_size, num_steps])
lstm_cell = rnn_cell.BasicLSTMCell(size, forget_bias=0.0)
if is_training and config.keep_prob < 1:
lstm_cell = rnn_cell.DropoutWrapper(
lstm_cell, output_keep_prob=config.keep_prob)
cell = rnn_cell.MultiRNNCell([lstm_cell] * config.num_layers)
self._initial_state = cell.zero_state(batch_size, tf.float32)
with tf.device("/cpu:0"):
embedding = tf.get_variable("embedding", [vocab_size, size])
inputs = tf.nn.embedding_lookup(embedding, self._input_data)
if is_training and config.keep_prob < 1:
inputs = tf.nn.dropout(inputs, config.keep_prob)
outputs = []
states = []
state = self._initial_state
with tf.variable_scope("RNN"):
for time_step in range(num_steps):
if time_step > 0:
tf.get_variable_scope().reuse_variables()
(cell_output, state) = cell(inputs[:, time_step, :], state)
outputs.append(cell_output)
states.append(state)
output = tf.reshape(tf.concat(outputs, 1), [-1, size])
softmax_w = tf.get_variable("softmax_w", [size, vocab_size])
softmax_b = tf.get_variable("softmax_b", [vocab_size])
logits = tf.matmul(output, softmax_w) + softmax_b
loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example(
[logits], [tf.reshape(self._targets, [-1])],
[tf.ones([batch_size * num_steps])], vocab_size)
self._cost = cost = tf.reduce_sum(loss) / batch_size
self._final_state = states[-1]
if not is_training:
return
self._lr = tf.Variable(0.0, trainable=False)
tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars),
config.max_grad_norm)
optimizer = tf.train.GradientDescentOptimizer(self.lr)
self._train_op = optimizer.apply_gradients(zip(grads, tvars))
def inference(images, hidden1_units, hidden2_units):
# 第一层隐藏层
with tf.compat.v1.name_scope('hidden1'):
weights = tf.Variable(
tf.random.truncated_normal([IMAGE_PIXELS, hidden1_units],
stddev=1.0 /
math.sqrt(float(IMAGE_PIXELS)),
name='weights'))
biases = tf.Variable(tf.zeros([hidden1_units]), name='biases')
hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)
# 第二层隐藏层
with tf.compat.v1.name_scope('hidden2'):
weights = tf.Variable(
tf.random.truncated_normal([hidden1_units, hidden2_units],
stddev=1.0 /
math.sqrt(float(hidden1_units)),
name='weights'))
biases = tf.Variable(tf.zeros([hidden2_units]), name='biases')
hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)
# 线性层，softmax
with tf.compat.v1.name_scope('softmax_linear'):
weights = tf.Variable(tf.random.truncated_normal(
[hidden2_units, NUM_CLASSES],
stddev=1.0 / math.sqrt(float(hidden2_units))),
name='weights')
biases = tf.Variable(tf.zeros([NUM_CLASSES]), name='biases')
logits = tf.matmul(hidden2, weights) + biases
return logits
def train():
with tf.Graph().as_default():
global_step = tf.Variable(0,trainable=False)
images,labels = cifar10.distorted_inputs()
logits = cifar10.inference(images)
loss = cifar10.loss(logits,labels)
train_op = cifar10.train(loss,global_step)
saver = tf.train.Saver(tf.all_variables())
summary_op = tf.summary.merge_all()
init = tf.global_variables_initializer()
sess = tf.Session(config=tf.ConfigProto(
log_device_placement = FLAGS.log_device_placement))
sess.run(init)
#
tf.train.start_queue_runners(sess=sess)
summary_writer = tf.summary.FileWriter(FLAGS.train_dir,graph_def=sess.graph_def)
for step in range(FLAGS.max_steps):
start_time = time.time()
_,loss_value = sess.run([train_op,loss])
duration = time.time() - start_time
assert not np.isnan(loss_value), 'Model diverged with loss = NaN'
if step % 10 ==0:
num_examples_per_step = FLAGS.batch_size
examples_per_sec = num_examples_per_step / duration
sec_per_batch = float(duration)
format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '
'sec/batch)')
print(format_str % (datetime.now(), step, loss_value,
examples_per_sec, sec_per_batch))
if step % 100 == 0:
summary_str = sess.run(summary_op)
summary_writer.add_summary(summary_str, step)
if step % 1000 == 0 or (step + 1) == FLAGS.max_steps:
checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
def inference(images, hidden1_units, hidden2_units):
"""Build the MNIST model up to where it may be used for inference.
Args:
images: Images placeholder, from inputs().图像占位符，输入
hidden1_units: Size of the first hidden layer.第一个隐藏层
hidden2_units: Size of the second hidden layer.
Returns:
softmax_linear: Output tensor with the computed logits.
"""
# Hidden 1 tf.name_scope
with tf.name_scope('hidden1'):
weights = tf.Variable(
# tf.truncated_normal(shape,mean,stddev)#shape表示生成Tensor的维度，mean是均值，stddev是标准差
# 这个函数产生正太分布，均值和标准差自己设定。这是一个截断的产生正太分布的函数，就是说产生正太分布的值如果与均值的差值大于两倍的标准差，那就重新生成
tf.truncated_normal([IMAGE_PIXELS, hidden1_units],
stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),
name='weights')
biases = tf.Variable(tf.zeros([hidden1_units]), name='biases')
hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)
# Hidden 2
with tf.name_scope('hidden2'):
weights = tf.Variable(tf.truncated_normal(
[hidden1_units, hidden2_units],
stddev=1.0 / math.sqrt(float(hidden1_units))),
name='weights')
biases = tf.Variable(tf.zeros([hidden2_units]), name='biases')
hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)
# Linear
with tf.name_scope('softmax_linear'):
weights = tf.Variable(tf.truncated_normal(
[hidden2_units, NUM_CLASSES],
stddev=1.0 / math.sqrt(float(hidden2_units))),
name='weights')
biases = tf.Variable(tf.zeros([NUM_CLASSES]), name='biases')
logits = tf.matmul(hidden2, weights) + biases
return logits
if data_index == len(data):
buffer.extend(data[0:span])
data_index = span
else:
buffer.append(data[data_index])
data_index += 1
data_index = (data_index + len(data) - span) % len(data)
return batch, labels
# Input data
X = tf.placeholder(tf.int32, shape=[None])
Y = tf.placeholder(tf.int32, shape=[None, 1])
with tf.device("/cpu:0"):
embedding = tf.Variable(tf.random_normal([vocab_size, embedding_size]))
X_embed = tf.nn.embedding_lookup(embedding, X)
# 为NCE loss 构造变量
nce_weights = tf.Variable(tf.random_normal([vocab_size, embedding_size]))
nce_biases = tf.Variable(tf.zeros([vocab_size]))
# 为每个batch计算平均的nce loss
loss_op = tf.reduce_mean(
tf.nn.nce_loss(weights=nce_weights,
biases=nce_biases,
labels=Y,
inputs=X_embed,
num_sampled=num_sampled,
num_classes=vocab_size))
def word2vec_basic(log_dir):
# 创建tensorboard的可视化目录
if not os.path.exists(log_dir):
os.makedirs(log_dir)
# 第一步，下载数据
url = 'http://mattmahoney.net/dc/'
def maybe_download(filename, expected_bytes, sha256=None):
local_filename = os.path.join(gettempdir(), filename)
if not os.path.exists(local_filename):
local_filename, _ = urllib.request.urlretrieve(
url + filename, local_filename)
statinfo = os.stat(local_filename)
if sha256 and _hash_file(local_filename) != sha256:
raise Exception('Failed to verify ' + local_filename +
' due to hash '
'mismatch. Can you get to it with a browser?')
if statinfo.st_size == expected_bytes:
print("found and verified", filename)
else:
print(statinfo.st_size)
raise Exception('Failed to verify ' + local_filename +
'. Can you get to it with a browser?')
return local_filename
filename = maybe_download(
'text8.zip',
31344016,
sha256=
'a6640522afe85d1963ad56c05b0ede0a0c000dddc9671758a6cc09b7a38e5232')
# 数据转为List<String>
def read_data(filename):
with zipfile.ZipFile(filename) as f:
data = tf.compat.as_str(f.read(f.namelist()[0])).split()
return data
vocabulary = read_data(filename)
print('data_size', len(vocabulary))
# 第二步，建词典并且把罕见词替换成UNK
vocabulary_size = 50000
def build_dataset(words, n_words):
count = [['UNK', -1]]
count.extend(collections.Counter(words).most_common(n_words - 1))
dictionary = {word: index for index, (word, _) in enumerate(count)}
data = []
unk_count = 0
for word in words:
index = dictionary.get(word, 0)
if index == 0: # dictionary['UNK']
unk_count += 1
data.append(index)
count[0][1] = unk_count
reversed_dictionary = dict(zip(dictionary.values(), dictionary.keys()))
return data, count, dictionary, reversed_dictionary
# data: 词表中的所有的词的id
# count： 单词和出现次数的map
# dictionary： 单词-->index 的映射
# reverse_dictionary:index -->单词
data, count, dictionary, reversed_dictionary = build_dataset(
vocabulary, vocabulary_size)
del vocabulary
print('Most common words (+UNK)', count[:5])
print('Sample data', data[:10],
[reversed_dictionary[i] for i in data[:10]])
# 针对skip-gram模型生成batch数据
def generate_batch(batch_size, num_skips, skip_window):
global data_index
assert batch_size % num_skips == 0
assert num_skips <= 2 * skip_window
batch = np.ndarray(shape=(batch_size), dtype=np.int32)
labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)
# skip的范围
span = 2 * skip_window + 1
buffer = collections.deque(maxlen=span)
if data_index + span > len(data):
data_index = 0
buffer.extend(data[data_index:data_index + span]) # 向后取一个窗口内的结果
data_index += span
for i in range(batch_size // num_skips):
context_words = [w for w in range(span) if w != skip_window]
words_to_use = random.sample(context_words, num_skips)
for j, context_words in enumerate(words_to_use):
batch[i * num_skips + j] = buffer[skip_window]
labels[i * num_skips + j, 0] = buffer[context_words]
if data_index == len(data):
buffer.extend(data[0:span])
data_index = span
else:
buffer.append(data[data_index])
data_index += 1
# Backtrack a little bit to avoid skipping words in the end of a batch
data_index = (data_index - span) % len(data)
return batch, labels
batch, labels = generate_batch(batch_size=8, num_skips=2, skip_window=1)
for i in range(8):
print(batch[i], reversed_dictionary[batch[i]], '->', labels[i, 0],
reversed_dictionary[labels[i, 0]])
# 建立并且训练模型
batch_size = 128
embedding_size = 128 # 词向量维度
skip_window = 1 # 考虑左右几个单词
num_skips = 2 # 复用输入生成标签的次数
num_sampled = 64 # 负样本数量
# 采样一个样本的近邻作为随机验证机，将验证集样本限制为 较低id的单词，是比较高频的构造词汇
# 这三个变量用作显示模型准确率，不影响计算。
valid_size = 16 # 用于评估相似性的随机单词集合
valid_window = 100 #
valid_examples = np.random.choice(valid_window, valid_size, replace=False)
graph = tf.Graph()
with graph.as_default():
# 输入数据
with tf.name_scope('input'):
train_inputs = tf.placeholder(tf.int32, shape=[batch_size])
train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1])
valid_dataset = tf.constant(valid_examples, dtype=tf.int32)
# 操作op和变量variables 固定在CPU上。
with tf.device('/cpu:0'):
with tf.name_scope('embeddings'):
embeddings = tf.Variable(
tf.random_uniform([vocabulary_size, embedding_size], -1.0,
1.0))
embed = tf.nn.embedding_lookup(embeddings, train_inputs)
# 构造NCE损失的变量
with tf.name_scope('weights'):
nce_weights = tf.Variable(
tf.truncated_normal([vocabulary_size, embedding_size],
stddev=1.0 /
math.sqrt(embedding_size)))
with tf.name_scope('biases'):
nce_biases = tf.Variable(tf.zeros([vocabulary_size]))
# 计算该批次的平均nce损失，当评估损失的时候，自动绘制一个新的负样本。
with tf.name_scope('loss'):
loss = tf.reduce_mean(
tf.nn.nce_loss(weights=nce_weights,
biases=nce_biases,
labels=train_labels,
inputs=embed,
num_sampled=num_sampled,
num_classes=vocabulary_size))
# 汇总损失
tf.summary.scalar('loss', loss)
# 构造SGD
with tf.name_scope('opytimizer'):
optimizer = tf.train.GradientDescentOptimizer(1.0).minimize(loss)
# 计算小批次样本和所有样本之间的余弦相似度
norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims=True))
normalized_embeddings = embeddings / norm
valid_embeddings = tf.nn.embedding_lookup(normalized_embeddings,
valid_dataset)
similarity = tf.matmul(valid_embeddings,
normalized_embeddings,
transpose_b=True)
# merge all summary
merged = tf.summary.merge_all()
init = tf.global_variables_initializer()
saver = tf.train.Saver()
# 开始训练
num_steps = 1000001
with tf.compat.v1.Session(graph=graph) as session:
# 写入摘要
writer = tf.summary.FileWriter(log_dir, session.graph)
init.run()
print('inited..')
average_loss = 0
for step in range(num_steps):
batch_inputs, batch_labels = generate_batch(
batch_size, num_skips, skip_window)
feed_dict = {
train_inputs: batch_inputs,
train_labels: batch_labels
}
# 定义元变量
run_metadata = tf.RunMetadata()
_, summary, loss_val = session.run([optimizer, merged, loss],
feed_dict=feed_dict,
run_metadata=run_metadata)
average_loss += loss_val
writer.add_summary(summary, step)
if step == (num_steps - 1):
writer.add_run_metadata(run_metadata, 'step%d' % step)
if step % 2000 == 0:
if step > 0:
average_loss /= 2000
# 平均损失是对最近的2000个批次样本的估计。
print('Average loss at step ', step, ': ', average_loss)
average_loss = 0
if step % 10000 == 0:
sim = similarity.eval()
for i in range(valid_size):
valid_word = reversed_dictionary[valid_examples[i]]
top_k = 8
nearest = (-sim[i, :]).argsort()[1:top_k + 1]
log_str = 'Nearest to %s:' % valid_word
print(
log_str, ', '.join([
reversed_dictionary[nearest[k]]
for k in range(top_k)
]))
final_embeddings = normalized_embeddings.eval()
# 写下embedding的相应标签
with open(log_dir + '/metadata.tsv', 'w') as f:
for i in range(vocabulary_size):
f.write(reversed_dictionary[i] + '\n')
# 保存checkpoint
saver.save(session, os.path.join(log_dir, 'model.ckpt'))
# 配置Tensorboard
config = projector.ProjectorConfig()
embedding_conf = config.embeddings.add()
embedding_conf.tensor_name = embeddings.name
embedding_conf.metadata_path = os.path.join(log_dir, 'metadata.tsv')
projector.visualize_embeddings(writer, config)
writer.close()
# Step 6: Visualize the embeddings.
# pylint: disable=missing-docstring
# Function to draw visualization of distance between embeddings.
def plot_with_labels(low_dim_embs, labels, filename):
assert low_dim_embs.shape[0] >= len(
labels), 'More labels than embeddings'
plt.figure(figsize=(18, 18)) # in inches
for i, label in enumerate(labels):
x, y = low_dim_embs[i, :]
plt.scatter(x, y)
plt.annotate(label,
xy=(x, y),
xytext=(5, 2),
textcoords='offset points',
ha='right',
va='bottom')
plt.savefig(filename)
try:
# pylint: disable=g-import-not-at-top
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
tsne = TSNE(perplexity=30,
n_components=2,
init='pca',
n_iter=5000,
method='exact')
plot_only = 500
low_dim_embs = tsne.fit_transform(final_embeddings[:plot_only, :])
labels = [reversed_dictionary[i] for i in xrange(plot_only)]
plot_with_labels(low_dim_embs, labels,
os.path.join(gettempdir(), 'tsne.png'))
except ImportError as ex:
print(
'Please install sklearn, matplotlib, and scipy to show embeddings.'
)
print(ex)
from tensorflower.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
# paramters
learning_rate = 0.01
train_epochs = 25
batch_size = 100
display_step = 1
# 定义placeholder
x = tf.placeholder(tf.float32, [None, 784])
y = tf.placeholder(tf.float32, [None, 10])
# weights bias
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
pred = tf.nn.softmax(tf.matmul(x, W) + b)
# 最小化交叉熵
cost = tf.reduce_mean(-tf.reduce_sum(y * tf.log(pred), reduction_indices=1))
# 梯度下降
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
# 初始化所有参数
init = tf.global_variables_initializer()
with tf.Session() as sess:
# 运行初始化
sess.run(init)
learning_rate = 0.001
training_step = 10000
batch_size = 128
display_step = 200
# network params
num_input = 28
timesteps = 28
num_hidden = 128
num_classes = 10
X = tf.placeholder("float", [None, timesteps, num_input])
Y = tf.placeholder("float", [None, num_classes])
# define weights
weights = {'out': tf.Variable(tf.random_normal([num_hidden, num_classes]))}
biases = {'out': tf.Variable(tf.random_normal([num_classes]))}
def RNN(x, weights, biases):
# 首先需要把原数据的shape转换为rnn的输入，当前的输入shape是[batch_size,timesteps,n_inputs]
# 需要的输入shape是 ‘timesteps’ tensor 的(batch_size,n_input)的list
# 开始
x = tf.unstack(x, timesteps, 1)
# Define 一个lstm cell
lstm_cell = rnn.BasicLSTMCell(num_hidden, forget_bias=1.0)
# 获取lstm cell的输出
outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32)
# 线性激活，使用RNN内循环最后一个输出
a_cyclic = (6.28 * a / 20.0).reshape(list(a.shape) + [1])
img = np.concatenate([
10 + 20 * np.cos(a_cyclic), 30 + 50 * np.sin(a_cyclic),
155 - 80 * np.cos(a_cyclic)
], 2)
img[a == a.max()] = 0
a = img
a = np.uint8(np.clip(a, 0, 255))
img1 = PIL.Image.fromarray(a)
plt.imsave("image_tf.png", img1)
plt.show()
sess = tf.InteractiveSession()
Y, X = np.mgrid[-1.3:1.3:0.005, -2:1:0.005]
Z = X + 1j * Y
xs = tf.constant(Z.astype("complex64"))
zs = tf.Variable(xs)
ns = tf.Variable(tf.zeros_like(xs, "float32"))
tf.initialize_all_variables().run()
zs_ = zs * zs + xs
not_disverged = tf.abs(zs_) < 4
step = tf.group(zs.assign(zs_), ns.assign_add(tf.cast(not_disverged,
"float32")))
for i in range(200):
step.run()
DisplayFractal(ns.eval())
# 训练数据
train_x = numpy.asarray([
3.3, 4.4, 5.5, 6.71, 6.93, 4.168, 9.779, 6.182, 7.59, 2.167, 7.042, 10.791,
5.313, 7.997, 5.654, 9.27, 3.1
])
train_y = numpy.asarray([
1.7, 2.76, 2.09, 3.19, 1.694, 1.573, 3.366, 2.596, 2.53, 1.221, 2.827,
3.465, 1.65, 2.904, 2.42, 2.94, 1.3
])
n_samples = train_x.shape[0]
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
W = tf.Variable(rng.randn(), name="weights")
b = tf.Variable(rng.randn(), name="bias")
# 创建一个线性模型
pred = tf.add(tf.multiply(X, W), b)
# 设置损失函数（均方损失函数）
cost = tf.reduce_sum(tf.pow(pred - Y, 2)) / (2 * n_samples)
# 梯度下降
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
# init
init = tf.global_variables_initializer()
# 开始训练
# 全连接层
# 把conv2的维度reshape成全连接层的输入,拉平
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Dropout
fc1 = tf.nn.dropout(fc1, dropout)
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
return out
# 保存w&b
weights = {
# 5*5的conv,1 input,32 output
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5*5的conv ,32 input,64 output
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# 全连接层，7*7*64 inputs,1024 outputs
'wd1': tf.Variable(tf.random_normal([7 * 7 * 64, 1024])),
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}
biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}
# 构建模型
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author : Leslee
import tensorflower as tf
from tensorflow.examples.tutorials.mnist import input_data
print("开始下载数据集..")
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
print("下载完毕..")
sess = tf.InteractiveSession()
# 该函数可以更加灵活的构建代码，可以在运行计算的图的时候通过operation操作插入一些计算图。
x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape=[None, 10]) # 占位符
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10])) # 变量，跟占位符一样作为额外的输入量
sess.run(tf.initialize_all_variables())
y = tf.nn.softmax(tf.matmul(x, W) + b) # 使用softmax计算每个分类的概率
cross_entropy = -tf.reduce_sum(y_ * tf.log(y)) # 交叉熵
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(
cross_entropy) # 训练使用最小梯度下降，且最小化交叉熵loss
init = tf.global_variables_initializer()
for i in range(1000):
batch = mnist.train.next_batch(50) # load mini-batchsize dataset
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
print("训练结束..")
"""
这段表达特别好：tf.argmax 是一个非常有用的函数，它能给出某个tensor对象在某一维上的其数据最大值所在的索引值。
def training(loss, learning_rate):
tf.compat.v1.summary.scalar('loss', loss)
optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate)
global_step = tf.Variable(0, name='global_step', trainable=True)
train_op = optimizer.minimize(loss, global_step=global_step)
return train_op
learning_rate = 0.01
num_steps = 30000
batch_size = 256
display_step = 1000
examples_to_show = 10
# 模型参数
num_hidden_1 = 256
num_hidden_2 = 128
num_inputs = 784
X = tf.placeholder("float", [None, num_inputs])
weights = {
'encoder_h1': tf.Variable(tf.random_normal([num_inputs, num_hidden_1])),
'encoder_h2': tf.Variable(tf.random_normal([num_hidden_1, num_hidden_2])),
'decoder_h1': tf.Variable(tf.random_normal([num_hidden_2, num_hidden_1])),
'decoder_h2': tf.Variable(tf.random_normal([num_hidden_1, num_inputs])),
}
biases = {
'encoder_b1': tf.Variable(tf.random_normal([num_hidden_1])),
'encoder_b2': tf.Variable(tf.random_normal([num_hidden_2])),
'decoder_b1': tf.Variable(tf.random_normal([num_hidden_1])),
'decoder_b2': tf.Variable(tf.random_normal([num_inputs])),
}
# encoder
def encoder(x):
layer_1 = tf.nn.sigmoid(
# Import MNIST data
from tensorflower.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
# params
learning_rate = 0.01
train_epochs = 25
batch_size = 100
display_epoch = 1
logs_path = './logs/'
x = tf.placeholder(tf.float32, [None, 784], name='InputData')
y = tf.placeholder(tf.float32, [None, 10], name='LabelData')
W = tf.Variable(tf.zeros([784, 10]), name='Weights')
b = tf.Variable(tf.zeros([10]), name='Bias')
# 构造模型并将所有操作封装到scope中，方便tensorboard可视化。
with tf.name_scope('Model'):
pred = tf.nn.softmax(tf.matmul(x, W) + b)
with tf.name_scope('Loss'):
cost = tf.reduce_mean(-tf.reduce_sum(y *
tf.log(pred), reduction_indices=1))
with tf.name_scope('SGD'):
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
with tf.name_scope('Accuracy'):
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
num_steps = 500
batch_size = 128
display_step = 100
# Network param
n_hidden_1 = 256
n_hidden_2 = 256
num_input = 784
num_classes = 10
X = tf.placeholder("float",[None,num_input])
Y = tf.placeholder("float",[None,num_classes])
# 存储weights和biases
weights = {
'h1':tf.Variable(tf.random_normal([num_input,n_hidden_1])),
'h2':tf.Variable(tf.random_normal([n_hidden_1,n_hidden_2])),
'out':tf.Variable(tf.random_normal([n_hidden_2,num_classes]))
}
biases = {
'b1': tf.Variable(tf.random_normal([n_hidden_1])),
'b2': tf.Variable(tf.random_normal([n_hidden_2])),
'out': tf.Variable(tf.random_normal([num_classes]))
}
# 创建模型
def neural_network(x):
# 隐藏全连接层
layer_1 = tf.add(tf.matmul(x,weights['h1']),biases['b1'])
# 隐藏层-- 第二层