def __init__(self, *arg):
self.batch_size = 50
self.embed_size = 300
self.lstm_units = 100
self.dropout = 0.0
self.data = DU.Data(debug_mode=True, percent_debug_data=1)
self._encoder()
self._decoder()
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
"select chat_id, chat_content from inner_game.user_chat_log where part_game = 13 limit 1000"
)
x_evluate = [x[1].decode('utf8') for x in data]
x_raw = [x[0] for x in data]
print "conncet hive sucess!"
# x_evluate = data
print("\nEvaluating...\n")
execfile("config.py")
print config.model.th
dev_data = data_utils.Data(data_source=config.dev_data_source,
alphabet=config.alphabet,
l0=config.l0,
batch_size=128,
no_of_classes=3)
# Evaluation
# ==================================================
checkpoint_file_root = os.path.join(FLAGS.checkpoint_dir, "checkpoints")
checkpoint_file = tf.train.latest_checkpoint(checkpoint_file_root)
print checkpoint_file
graph = tf.Graph()
with graph.as_default():
session_conf = tf.ConfigProto(
allow_soft_placement=FLAGS.allow_soft_placement,
log_device_placement=FLAGS.log_device_placement)
sess = tf.Session(config=session_conf)
with sess.as_default():
import data_utils
from mdp import MDP
from rewards import reward_func_linear # Call it with stats to initialize
from env import Env
from q_learning import QLearningAlgo
from policy import EpsilonGreedyPolicy, GreedyPolicy, RandomPolicy
data = data_utils.Data(n=15)
mdp = MDP(data=data)
reward_func = reward_func_linear(data.statistics, verbose=False)
env = Env(reward_func=reward_func, mode='human')
# policy = EpsilonGreedyPolicy(action_space = mdp.action_space)
policy = RandomPolicy(action_space=mdp.action_space)
test_policy = GreedyPolicy(action_space=mdp.action_space)
algo = QLearningAlgo(env=env, mdp=mdp, policy=policy, discount=0.2)
algo.set_mode('train')
algo.fit(mode='train', epochs=4, remember=True)
algo.set_mode('test')
algo.test(mode='test', policy=test_policy)
algo.replay(batch_size=16, epochs=8)
algo.set_mode('test')
algo.test(mode='test', policy=test_policy)
# algo.test(mode = 'human', policy = test_policy)
import numpy as np
import matplotlib.pyplot as plt
except StopIteration as e:
self.dataiter = iter(self.dataiter)
self.itercycle += 1
episode_iterator, self.video_path = next(self.dataiter)
self.episode = iter(episode_iterator)
encoding, done = next(self.episode)
self.state = self.state_class(encoding=encoding, prev_state=None)
if done:
return self.reset()
self.is_terminal = False
self.prev_state = None
def set_mode(self, mode):
if mode in ['train', 'test']:
self.data.mode = mode
self.dataiter = iter(self.data)
if __name__ == '__main__':
# Test
import data_utils
data = data_utils.Data(small=True)
mdp = MDP(data=data)
mdp.reset()
for i in range(1000):
mdp.doAction(1)
if mdp.is_terminal:
mdp.reset()
# if len(self.buffer) % 1000 == 0 and len(self.buffer) != 0:
# print("Loading %ith frame into buffer" % len(self.buffer))
try:
self.buffer.append(self.cap.read()) # Read frame
except BufferError as e:
break
# print("Video in buffer:", self.cap.pipeline, "\t# of frames in buffer:", len(self.buffer))
def set_mode(self, mode):
self.mode = mode
if __name__ == '__main__':
# Test
import data_utils
from mdp import MDP
from rewards import reward_func_linear # Call it with stats to initialize
data = data_utils.Data(n=2)
mdp = MDP(dataiter=iter(data))
reward_func = reward_func_linear(data.statistics, verbose=False)
env = Env(mdp=mdp, reward_func=reward_func)
while True:
if env.mdp.is_terminal:
env.reset()
_, reward, _ = env.step(1)
env.render(gender=env.mdp.state.encoding.gender,
age=env.mdp.state.encoding.age,
reward=reward,
action=1)
def walk(correlation_matrix, n_steps):
base = normalize(correlation_matrix, norm="l1", axis=0)
no_loop_2 = correlation_matrix.dot(correlation_matrix) \
* (1 - np.eye(correlation_matrix.shape[0]))
no_loop_2 = normalize(no_loop_2, norm="l1", axis=0)
weights = [base, no_loop_2]
for i in range(n_steps - 2):
weights.append(normalize(weights[-2].dot(no_loop_2), norm="l1",
axis=0))
ret = np.stack(weights, -1) * np.power(0.8, range(n_steps))
ret = np.sum(ret, axis=-1)
ret = normalize(ret, norm="l1", axis=0)
return ret
mydata = data_utils.Data("./data/BlogCatalog3/")
correlation_matrix = walk(mydata.correlation_matrix, 5)
print(np.mean(correlation_matrix))
embeddings = gravity_embedding(correlation_matrix,
4,
alpha=0.5,
stop_criterion=2e-6)
trainX, testX, trainY, testY = sklearn.model_selection.train_test_split(
embeddings, mydata.index2group, test_size=0.9)
def eval(model):
model.fit(trainX, trainY)
# print("accuracy: ", model.score(testX, testY))
pred = model.predict(testX)