def packet_handler(self, packet, address):
packetid = ord(packet[0])
if packetid < 100:
processing.get_logger().warning('internal packet unhandled: "%s"' % self.transport.packet_type_info(packetid))
return self
p = self.packet_types[packetid]().from_string(packet)
p.sender = address
self.queue_message(p)
return self
def main(argv=None):
logger = process.get_logger()
logger.info("Training started.")
train_data = process.get_train_dataset()
test_data = process.get_test_dataset()
train(train_data, test_data)
logger.info("Training ended.")
def evaluate():
logger = process.get_logger()
with tf.Graph().as_default() as g:
x = tf.placeholder(
tf.int32,
[None, None],
name="x-input"
)
y = inference.inference(x, process.get_lex_len(), None)
tf.argmax(y, 1)
saver = tf.train.Saver()
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(
const.MODEL_DIR)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path\
.split("/")[-1].split("-")[-1]
feed_x = process.get_vec_from_text(const.PREDICT_TEXT)
# feed_x = feed_x.any()
y = sess.run(y, feed_dict={x: feed_x})
print("After %s training step(s), text: '%s', "
"prediction: %s" % (global_step, const.PREDICT_TEXT, str(y)))
logger.info("After %s training step(s), text: '%s', "
"prediction = %s" % (global_step, const.PREDICT_TEXT, str(y)))
else:
print("No checkpoint file found")
return
def add_process_group(self, name, default_actor_class=None, max_tick_time=None, interval=.03):
'''adds a process group to the pool'''
assert self.is_main_process, 'Pysage currently only supports spawning child groups from the Main Group'
self.validate_groups_mode()
self._ipc_listen()
# make sure we have a str
g = str(name)
if self.groups.has_key(g):
raise GroupAlreadyExists('Group name "%s" already exists.' % g)
server_addr = self.ipc_transport.address
# shared should quit switch
switch = processing.Value('B', 0)
actor_class = default_actor_class or DefaultActor
p = processing.Process(target=_subprocess_main, name=name, args=(name, actor_class, max_tick_time, interval, server_addr, switch, self.packet_types))
p.start()
processing.get_logger().info('started group "%s" in process "%s"' % (name, processing.get_pid(p)))
_clientid = self.ipc_transport.accept()
self.groups[g] = (p, _clientid, switch)
def main(argv=None):
test_data = process.get_test_dataset()
test_xs, test_ys, _ = process.get_next_batch(test_data, 0, len(test_data))
global_step, acc_value = evaluate(test_xs, test_ys)
print("Global step: #%d, accuracy: %g" % (global_step, acc_value))
logger = process.get_logger()
logger.info("Global step: #%d, accuracy: %g" % (global_step, acc_value))
return 0
def main(argv=None):
logger = process.get_logger()
logger.info("Training (CNN) started")
# logger.info("Training step: %g", const.TRAINING_STEPS)
logger.info("Learning rate: %g", const.LEARNING_RATE_BASE)
train()
logger.info("Training (CNN) ended")
return 0
def inference(input_tensor, input_size,
is_train): # input_size here is too large
if is_train is not None:
dropout_keep_prob = 0.5
logger = process.get_logger()
logger.debug("dropout: %g" % dropout_keep_prob)
else:
dropout_keep_prob = 1.0
# embedding layer
with tf.device('/cpu:0'), tf.name_scope("embedding"):
embedding_size = 128
W = tf.Variable(tf.random_uniform([input_size, embedding_size],
minval=-1.0,
maxval=1.0),
name="embedding")
embedded_chars = tf.nn.embedding_lookup(W, input_tensor)
# embedded_chars = tf.nn.dropout(embedded_chars, dropout_keep_prob)
embedded_chars_expanded = tf.expand_dims(embedded_chars, -1)
# convolution + maxpool layer
num_filters = 128
filter_sizes = [3, 4, 5]
pooled_outputs = []
for i, filter_size in enumerate(filter_sizes):
with tf.name_scope("conv-maxpool-%s" % filter_size):
filter_shape = [filter_size, embedding_size, 1, num_filters]
W = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1))
b = tf.Variable(tf.constant(0.1, shape=[num_filters]))
conv = tf.nn.conv2d(embedded_chars_expanded,
W,
strides=[1, 1, 1, 1],
padding="VALID")
h = tf.nn.relu(tf.nn.bias_add(conv, b))
pooled = tf.nn.max_pool(
h,
ksize=[1, input_size - filter_size + 1, 1, 1],
strides=[1, 1, 1, 1],
padding='VALID')
pooled_outputs.append(pooled)
num_filters_total = num_filters * len(filter_sizes)
h_pool = tf.concat(pooled_outputs, 3)
h_pool_flat = tf.reshape(h_pool, [-1, num_filters_total])
# dropout
with tf.name_scope("dropout"):
h_drop = tf.nn.dropout(h_pool_flat, dropout_keep_prob)
# output
with tf.name_scope("output"):
W = tf.get_variable("W",
shape=[num_filters_total, num_classes],
initializer=tf.contrib.layers.xavier_initializer())
b = tf.Variable(tf.constant(0.1, shape=[num_classes]))
output = tf.nn.xw_plus_b(h_drop, W, b)
return output
def evaluate():
logger = process.get_logger()
with tf.Graph().as_default() as g:
xs, ys = process.get_test_dataset()
x = tf.placeholder(
tf.int32,
[None,
None],
name="x-input"
)
y_ = tf.placeholder(
tf.float32, [None, inference.OUTPUT_NODE], name="y_-input")
validate_feed = {x: xs,
y_:ys}
y = inference.inference(x, process.get_lex_len(), None)
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# variable_averages = tf.train.ExponentialMovingAverage(
# mnist_train.MOVING_AVERAGE_DECAY)
# variables_to_restore = variable_averages.variables_to_restore()
saver = tf.train.Saver() #variables_to_restore)
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(
const.MODEL_DIR)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path\
.split("/")[-1].split("-")[-1]
accuracy_score = sess.run(accuracy,
feed_dict=validate_feed)
print("After %s training step(s), validation "
"accuracy = %g" % (global_step, accuracy_score))
logger.info("After %s training step(s), validation "
"accuracy = %g" % (global_step, accuracy_score))
else:
print("No checkpoint file found")
return
return accuracy_score
def train_neural_network():
Train = process.Data_Process()
input_size = Train.max_name_length
voc_len = Train.voc_len
x = tf.placeholder(tf.int32, [None, input_size], "input-x")
y_ = tf.placeholder(tf.float32, [None, const.NUM_CLASSES], "input-y_")
dropout_keep_prob = tf.placeholder(tf.float32)
global_step = tf.Variable(0, False)
y = model.model(x, input_size, voc_len, dropout_keep_prob)
optimizer = tf.train.AdamOptimizer(1e-3)
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=y, labels=y_))
grads_and_vars = optimizer.compute_gradients(loss)
train_op = optimizer.apply_gradients(grads_and_vars, global_step)
saver = tf.train.Saver(tf.global_variables())
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
ckpt = tf.train.get_checkpoint_state(const.MODEL_DIR)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
# for i in range(201):
while Train.cur_epoch < const.EPOCH:
batch_xs, batch_ys = Train.get_train_batch()
_, loss_ = sess.run([train_op, loss],
feed_dict={
x: batch_xs,
y_: batch_ys,
dropout_keep_prob: 0.5
})
print(global_step.eval(), loss_)
logger = process.get_logger()
logger.info("Global_step: %d, loss: %g", global_step.eval(), loss_)
# 保存模型
if global_step.eval() % 50 == 0:
saver.save(sess,
os.path.join(const.MODEL_DIR, const.MODEL_NAME),
global_step=global_step)
def train():
logger = process.get_logger()
x = tf.placeholder(tf.int32, [None, None], name="x-input")
y_ = tf.placeholder(tf.float32, [None, inference.OUTPUT_NODE],
name="y_-input")
is_train = tf.placeholder("bool")
# the last accuracy, for evaluate
pre_acc = tf.Variable(0.0, False, name="pre_accuracy")
# regularizer = tf.contrib.layers.l2_regularizer(const.REGULARIZATION_RATE)
y = inference.inference(x, process.get_lex_len(), is_train)
global_step = tf.Variable(0, trainable=False, name="global_step")
# variable_averages = tf.train.ExponentialMovingAverage(
# MOVING_AVERAGE_DECAY, global_step)
# variable_averages_op = variable_averages.apply(
# tf.trainable_variables())
# cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
# logits=y, labels=tf.argmax(y_, 1))
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=y,
labels=y_)
cross_entropy_mean = tf.reduce_mean(cross_entropy)
loss = cross_entropy_mean #+ tf.add_n(tf.get_collection("losses"))
# learning_rate = tf.train.exponential_decay(
# LEARNING_RATE_BASE,
# global_step,
# mnist.train.num_examples / BATCH_SIZE,
# LEARNING_RATE_DECAY)
learning_rate = const.LEARNING_RATE_BASE
# train_step = tf.train.GradientDescentOptimizer(learning_rate)\
optimizer = tf.train.AdamOptimizer(learning_rate)
grads_and_vars = optimizer.compute_gradients(loss)
train_op = optimizer.apply_gradients(grads_and_vars)
# with tf.control_dependencies([train_step, variable_averages_op]):
# train_op = tf.no_op(name="train")
# for evaluate
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver()
with tf.Session() as sess:
tf.global_variables_initializer().run()
ckpt = tf.train.get_checkpoint_state(const.MODEL_DIR)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
# writer = tf.summary.FileWriter(const.TENSORBOARD_LOG_DIR, tf.get_default_graph())
# for evaluate
test_xs, test_ys = process.get_test_dataset()
is_first_round = True
# for i in range(const.TRAINING_STEPS):
while True:
xs, ys = process.get_next_batch(40)
# _, loss_value, step = sess.run([train_step, loss, global_step],
# feed_dict={x: xs, y_: ys, is_train: True})
_, loss_value, step = sess.run([train_op, loss, global_step],
feed_dict={
x: xs,
y_: ys,
is_train: True
})
if is_first_round:
cur_acc = sess.run(accuracy, {
x: test_xs[0:50],
y_: test_ys[0:50],
is_train: False
}) # 过大会内存爆炸
logger.info(
"After the first train, %s training step(s), validation "
"accuracy = %g" % (step, cur_acc))
logger.info("While pre_accuracy is: %g" % pre_acc.eval())
is_first_round = False
# if i % 1000 == 0:
# if i % 50 == 0:
# if step % 50 == 0:
if step % 2 == 0:
print("After %d training step(s), loss on training "
"batch is %g." % (step, loss_value))
logger.info("After %d training step(s), loss on training "
"batch is %g." % (step, loss_value))
# for evaluate
# current_acc
cur_acc, test_loss = sess.run((accuracy, loss), {
x: test_xs[0:50],
y_: test_ys[0:50],
is_train: False
})
logger.info("After %s training step(s), validation "
"accuracy = %g, loss = %g" %
(step, cur_acc, test_loss))
logger.info("While pre_accuracy is: %g" % pre_acc.eval())
if cur_acc >= pre_acc.eval():
saver.save(sess,
os.path.join(const.MODEL_DIR, const.MODEL_NAME),
global_step=global_step)
sess.run(tf.assign(pre_acc, cur_acc))
if cur_acc > 0.8:
break
def main(argv=None):
logger = process.get_logger()
logger.info("Predict started")
evaluate()
logger.info("Predict ended")
import os
import datetime
try:
import pyraknet
except ImportError:
RAKNET_AVAILABLE = False
else:
RAKNET_AVAILABLE = True
class NotConnectedException(Exception):
pass
logger = processing.get_logger()
class Transport(object):
'''an interface that all transports must implement'''
def connect(self, host, port):
'''connects to a server implementing the same interface'''
pass
def disconnect(self):
'''disconnects all clients and itself'''
pass
def listen(self, host, port, connection_handler):
'''listens for connections, and calls connection_handler upon new connections'''
pass
def handle_message(self, msg):
processing.get_logger().info('Default actor received message "%s"' % msg)
return False
# Messaging.py
# Credits:
# this module builds on the concepts of a trigger system introduced in
# the book: "Game Coding Complete - 2nd Edition" by Mike McShaffry
# this module implements a message manager along with message receivers
import collections
import time
import util
import process as processing
import inspect
logger = processing.get_logger()
WildCardMessageType = '*'
def MessageID():
'''generates unique message IDs per runtime'''
i = 0
while True:
yield i
i += 1
messageID = MessageID()
class InvalidMessageProperty(Exception):
pass
class MessageReceiver(object):
'''generic message receiver class that game object inherits from'''
# message types this message receiver will subscribe to
subscriptions = []
def __init__(self):
def get_logger():
return processing.get_logger()
def train(train_data, test_data):
# x = tf.placeholder(tf.float32, [None, const.IMAGE_HEIGHT * const.IMAGE_WIDTH], "x_input")
x = tf.placeholder(
tf.float32,
[None, const.IMAGE_HEIGHT, const.IMAGE_WIDTH, const.NUM_CHANNELS],
"x-input")
y_ = tf.placeholder(tf.float32,
[None, const.MAX_CAPTCHA * const.CHAR_SET_LEN],
"y_-input")
global_step = tf.Variable(0, False)
# keep_prob = tf.placeholder(tf.float32) # dropout
regularizer = tf.contrib.layers.l2_regularizer(const.REGULARIZATION_RATE)
# TODO 好像有问题
# y = inference.inference(x, True, regularizer)
y = inference.inference(x, True, None)
# loss
#之前tensorflow没升级的时候，用的是targets，当升级到1.3时，用的是labels
# cross_entropy_mean = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1)))
cross_entropy_mean = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(logits=y, labels=y_))
# 最后一层用来分类的softmax和sigmoid有什么不同？
# answer: https://github.com/zhengwh/captcha-tensorflow
loss = cross_entropy_mean #+ tf.add_n(tf.get_collection('losses'))
learning_rate = tf.train.exponential_decay(
const.LEARNING_RATE_BASE, global_step,
const.TRAINING_STEPS / const.BATCH_SIZE, const.DECAY_LEARNING_RATE)
# 优化器，optimizer 为了加快训练 learning_rate应该开始大，然后慢慢衰
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(loss, global_step)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(
loss, global_step)
# == end ==
predict = tf.reshape(y, [-1, const.MAX_CAPTCHA, const.CHAR_SET_LEN])
#函数会返回tensor中参数指定的维度中的最大值的索引
#最后输出的是一个，4*26维度的向量,所以最大的索引值为4个，和正确的结果进行对比
max_idx_p = tf.argmax(predict, 2)
max_idx_l = tf.argmax(
tf.reshape(y_, [-1, const.MAX_CAPTCHA, const.CHAR_SET_LEN]), 2)
#通过tf.equal方法可以比较预测结果与实际结果是否相等：
correct_pred = tf.equal(max_idx_p, max_idx_l)
#这行代码返回一个布尔列表。为得到哪些预测是正确的，我们可用如下代码将布尔值转换成浮点数：
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# global train_data
#Tensorflow针对这一需求提供了Saver类，保存模型，恢复模型变量。
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
ckpt = tf.train.get_checkpoint_state(const.MODEL_DIR)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
logger = process.get_logger()
cursor = 0
for i in range(const.TRAINING_STEPS):
xs, ys, cursor = process.get_next_batch(train_data, cursor)
sess.run(optimizer, {x: xs, y_: ys})
if i % 50 == 0:
saver.save(sess, os.path.join(const.MODEL_DIR,
const.MODEL_NAME))
loss_value, cross_entropy_mean_value = sess.run(
(loss, cross_entropy_mean), {
x: xs,
y_: ys
})
# test_xs, test_ys, _ = process.get_next_batch(test_data, 0, len(test_data))
# # acc_value = sess.run(accuracy, {x: test_xs, y_: test_ys})
# acc_value, global_step_value = evalidate.evalidate(test_xs, test_ys)
# logger.info("Global step: #%d, loss: %g, accuracy: %g" % (global_step.eval(), loss_value, acc_value))
# logger.info("Global step: #%d, loss: %g, accuracy: %g" % (global_step_value, loss_value, acc_value))
logger.info(
"Global step: #%d, loss: %g, cross_entropy_mean: %g" %
(global_step.eval(), loss_value, cross_entropy_mean_value))
saver.save(sess, os.path.join(const.MODEL_DIR, const.MODEL_NAME),
global_step)
loss_value, cross_entropy_mean_value = sess.run(
(loss, cross_entropy_mean), {
x: xs,
y_: ys
})
# test_xs, test_ys, _ = process.get_next_batch(test_data, 0, len(test_data))
# # acc_value = sess.run(accuracy, {x: test_xs, y_: test_ys})
# acc_value, global_step_value = evalidate.evalidate(test_xs, test_ys)
# logger.info("Global step: #%d (final step), loss: %g, accuracy: %g" % (global_step.eval(), loss_value, acc_value))
logger.info(
"Global step: #%d (final step), loss: %g, cross_entropy_mean: %g" %
(global_step.eval(), loss_value, cross_entropy_mean_value))
def main(argv=None):
logger = process.get_logger()
logger.info("Evaluation started")
evaluate()
logger.info("Evaluation ended")
def log(self, level, msg):
'''process aware logging'''
return processing.get_logger().log(level, msg)
