def discover(self, hash, msg_length):
self.start_discovering()
discover_message = Message(SELF_TEAM_NAME, DISCOVER_CODE, hash, msg_length,
"".ljust(msg_length), "".ljust(msg_length))
self.client_socket.sendto(EncoderDecoder.encodeMessage(discover_message), broadcast_addr)
time_out = threading.Timer(5.0, self.stop_discovering)
time_out.start()
while self.listen:
is_received = False
try:
data = []
data, address = self.client_socket.recvfrom(BUFFER_SIZE)
is_received = True
msg = EncoderDecoder.decodeMessage(data)
if msg is not None:
if msg.type == 2:
# if self.available_servers.count(address) == 0:
self.add_server(address, msg.team_name)
print("Received an offer from team " + msg.team_name + ", address: " + str(address))
else:
print("Very funny, team " + msg.team_name + ".. An offer was expected.")
else:
print("Received garbage from address " + str(address))
except:
if is_received:
print("What the hell is this?")
def menu():
meniu = 1
while meniu:
print "### MENU ###"
print "1. Encode message"
print "2. Decode message"
print "3. List accounts saved in database"
print "4. Search"
print "5. Exit"
choose = raw_input("Enter a number corresponding: ")
if choose == "1":
e = EncoderDecoder.Encode(file1)
e.encode()
print "\n"
elif choose == "2":
d = EncoderDecoder.Decode(file1)
d.decode()
print "\n"
elif choose == "3":
l = EncoderDecoder.ListAndSearch(file1)
l.list_accounts()
print "\n"
elif choose == "4":
s = EncoderDecoder.ListAndSearch(file1)
s.search()
print "\n"
elif choose == "5":
return
else:
print "Invalid option"
print "\n"
def start(self):
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST,
1)
self.server_socket.bind(server_addr)
while True:
# before doing the functionality below, move on the list and remove any thread that has finished
data, address = self.server_socket.recvfrom(BUFFER_SIZE)
msg = EncoderDecoder.decodeMessage(data)
if msg is not None:
if msg.type == 1: # Discover
self.send_offer(address, msg.team_name)
elif msg.type == 3: # Request
print("Received a request from team " + msg.team_name +
", address: " + str(address) + " with range (" +
msg.origin_start + ", " + msg.origin_end + ")")
if annoying_clients.count((msg.team_name, address)) == 0:
annoying_clients.append((msg.team_name, address))
client_thread = threading.Thread(
target=Hash.calc_hash,
args=(msg, self.server_socket, address, lock_obj))
client_thread.start()
else:
print(SELF_TEAM_NAME +
" is already calculating for team " +
msg.team_name + ", address: " + str(address))
def receive_msg(self, hash):
print("Trying to receive")
if self.should_stop():
return False
# print("Should Receive")
try:
data, address = self.client_socket.recvfrom(BUFFER_SIZE)
msg = EncoderDecoder.decodeMessage(data)
if msg is not None:
# print("Received!!! type - " + str(msg.type))
if msg.type == 4: # ACK
curr_hash_result = msg.origin_start
if Hash.valid_ack(hash, curr_hash_result): # HURRAY
print("Team " + msg.team_name + " has found the result!")
self.hash_result = curr_hash_result
self.found_result = True
return False
else:
print("Team " + msg.team_name + " is on team Cap.")
elif msg.type == 5: # NAck
self.set_future_nack(address[0], address[1], msg)
return True
else:
return True
except:
return True
def make_model(src_vocab, tgt_vocab, N=6, d_model=512, d_ff=2048, h=8, dropout=0.1):
c = copy.deepcopy # 把copy.deepcopy命名为c，这样使下面的代码简洁一点。
attn = MultiHeadedAttention(h, d_model)
ff = PositionwiseFeedForward(d_model, d_ff, dropout)
position = PositionalEncoding(d_model, dropout)
model = EncoderDecoder( # 构造EncoderDecoder对象。它需要5个参数：Encoder、Decoder、src-embed、tgt-embed和Generator。
Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),
Decoder(DecoderLayer(d_model, c(attn), c(attn), c(ff), dropout), N), # Decoder由N个DecoderLayer组成
nn.Sequential(Embeddings(d_model, src_vocab), c(position)), # src-embed是一个Embeddings层和一个位置编码层c(position)
nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)), # tgt-embed也是类似的。
Generator(d_model, tgt_vocab)) # 作用是把模型的隐单元变成输出词的概率
# 随机初始化参数，这非常重要
for p in model.parameters():
if p.dim() > 1:
nn.init.xavier_uniform(p) # Xavier初始化
return model
def __init__(self,num_actions=None,dim_obs=None,memory_size=100,memory_word_size=32,name='encode_agent',**kwargs):
#super(Agent, self).__init__(name=name,**kwargs)#如果继承别人的才用
#latent dim 和 image_code_size是相同的含义，用在不同的编码器中
self.num_actions= num_actions
self.memory_size =memory_size
self.memory_word_size = memory_word_size
#self._image_code_size = image_code_size
#self._image_encoder_decoder = EncoderDecoder.ImageEncoderDecoder(image_code_size=image_code_size)
self._name = name
self._obs_size = reduce(lambda x,y: x*y, list(dim_obs))
print("self.obs_size",self._obs_size)
self._im2state = EncoderDecoder.ImEncoder(self._obs_size,self.memory_word_size,64)
self._state2im = EncoderDecoder.ImDecoder(self._obs_size,self.memory_word_size,64)
self._vae = EncoderDecoder.VAE(self._obs_size,self.memory_word_size,64)
self._optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
self._controllercore = Controller.ControllerCore(num_actions=self.num_actions,num_node=10,memory_size=self.memory_size,memory_word_size=self.memory_word_size)
self._abstract_memory= self._controllercore.AbstractG
#这几个参数要改，因为要与图相关，这个只是矩阵相关
#print("memory_size",self.memory_size)
self._external_memory = Memory.ExternalMemory(memory_size=self.memory_size)
memory_num_reads = 2
memory_top_k = 3
self._memory_reader = MemReadWrite.MemReader(
memory_word_size=self.memory_word_size,#这个与隐藏层同维度
num_read_heads=memory_num_reads,
top_k=memory_top_k,
memory_size=self.memory_size)
#
self._memory_eraser =MemReadWrite.MemErase(
memory_word_size=self.memory_word_size,
memory_size=self.memory_size)
self._memory_writer = MemReadWrite.MemWriter(
memory_word_size=self.memory_word_size,
memory_size=self.memory_size)
self._memory_reconstructor = MemReconstruction.MemReconstructor(memory_word_size=self.memory_word_size)
def send_offer(self, client_address, team_name):
if annoying_clients.count((team_name, client_address)) == 0:
msg = Message(SELF_TEAM_NAME, OFFER_CODE, "".ljust(40), 1, "s",
"s")
print(SELF_TEAM_NAME + " is offering service to team " +
team_name + ", address: " + str(client_address))
self.server_socket.sendto(EncoderDecoder.encodeMessage(msg),
client_address)
else:
print(SELF_TEAM_NAME + " is already calculating for team " +
team_name + ", address: " + str(client_address))
def calc_hash(request_msg, server_socket, client_address, lock_obj):
hash_result = request_msg.hash
hash_start = request_msg.origin_start
hash_end = request_msg.origin_end
hash_length = request_msg.origin_length
answer = None
client_ans = None
num_start = word_to_num(hash_start, hash_length)
num_end = word_to_num(hash_end, hash_length)
i = num_start
init_millis = int(round(time.time()))
while i < num_end + 1:
if int(round(time.time())) - init_millis >= TIME_OUT:
print("Sorry sir, but " + SELF_TEAM_NAME +
" has reached its limit. Thank you, team " +
request_msg.team_name)
exit(0)
word = num_to_word(i, hash_length)
result = hashlib.sha1(word.encode()).hexdigest()
if result == hash_result:
print(SELF_TEAM_NAME + " has found an answer for team " +
request_msg.team_name + ": " + str(word))
answer = word
break
i = i + 1
if answer is None:
print(SELF_TEAM_NAME + " couldn't find an answer in this range: " +
"(" + hash_start + ", " + hash_end + ")")
client_ans = Message(SELF_TEAM_NAME, NACK_CODE, hash_result,
hash_length, hash_start, hash_end)
else:
client_ans = Message(SELF_TEAM_NAME, ACK_CODE, hash_result,
hash_length, answer, hash_end)
lock_obj.acquire()
Server.annoying_clients.remove((request_msg.team_name, client_address))
server_socket.sendto(EncoderDecoder.encodeMessage(client_ans),
client_address)
lock_obj.release()
def __init__(self,
num_actions=None,
dim_obs=None,
memory_size=100,
memory_word_size=32,
name="TrainableAgent"):
'''
智能体对环境的基本认知，动作空间，状态空间
'''
self.num_actions = num_actions
# reduce (lambda x,y:x+y, [1,2,3]) 输出为 6
self._obs_size = reduce(lambda x, y: x * y, list(dim_obs))
self.memory_size = memory_size
self.memory_word_size = memory_word_size
'''
1.实例化各个类
五个模块的引入
'''
# 编解码器的实例化
self._im2state = EncoderDecoder.ImEncoder(self._obs_size,
self.memory_word_size, 64)
self._state2im = EncoderDecoder.ImDecoder(self._obs_size,
self.memory_word_size, 64)
self._vae = EncoderDecoder.VAE(self._obs_size, self.memory_word_size,
64)
self._optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
self._vdecoder = EncoderDecoder.VDecoder(
1, 200) # 因为没用batch 所以是一维输出，就是一个v值
self._vaev = EncoderDecoder.VAEV(self._obs_size, self.memory_word_size,
64)
# 控制器实例化
self._controllercore = Controller.ControllerCore(
num_actions=self.num_actions,
num_node=10,
memory_size=self.memory_size,
memory_word_size=self.memory_word_size)
self._aggregator = Controller.MeanAggregator(self.memory_word_size,
self.memory_word_size,
name="aggregator",
concat=False) #输入输出维度相同
self._aggmodel = Controller.AggModel(self.memory_word_size)
self.batch_num = 0 # 用来控制训练agg的batch起点，训练聚合器参数的时候用到
#这一版的a2c写的不够清晰
# self.a2cparams = {
# 'gamma': 0.99,
# 'value': 0.5,
# 'entropy':0.0001
# }
# self.a2cmodel = Controller.a2cModel(num_actions=self.num_actions)
# self.a2cmodel.compile(
# optimizer = ko.RMSprop(lr=0.0007),
# loss = [self._logits_loss,self._value_loss]
# )
self.a2cmodel = AC(self._obs_size, self.num_actions)
# 存储器实例化
self._abstract_memory = self._controllercore.AbstractG
self._external_memory = Memory.ExternalMemory(
memory_size=self.memory_size)
# 读写器实例化
memory_num_reads = 2
memory_top_k = 3
self._memory_reader = MemReadWrite.MemReader(
memory_word_size=self.memory_word_size, #这个与隐藏层同维度
num_read_heads=memory_num_reads,
top_k=memory_top_k,
memory_size=self.memory_size)
self._memory_eraser = MemReadWrite.MemErase(
memory_word_size=self.memory_word_size,
memory_size=self.memory_size)
self._memory_writer = MemReadWrite.MemWriter(
memory_word_size=self.memory_word_size,
memory_size=self.memory_size)
#重构机制实例化
self._memory_reconstructor = MemReconstruction.MemReconstructor(
memory_word_size=self.memory_word_size)
import tensorflow as tf
import EncoderDecoder
model = EncoderDecoder.EncoderDecoder(infer=True)
config = tf.ConfigProto()
sess = tf.Session(config=config)
saver = tf.train.Saver()
best_model_path = './ckpt-encoder-decoder/encoder-decoder.ckpt-100'
saver.restore(sess, best_model_path)
print 'Finish restoring the encoder-decoder model.'
import numpy as np
import pickle
with open('./data.pkl', 'rb') as fr:
X = pickle.load(fr)
word2id = pickle.load(fr)
id2word = pickle.load(fr)
def wordSample(weights):
t = np.cumsum(weights)
s = np.sum(weights)
sample = int(np.searchsorted(t, np.random.rand(1) * s))
return id2word[sample]
_state = sess.run(model.mtcell_encoder.zero_state(1, tf.float32))
x = np.array([[word2id[u'[']]])
def send_request(self, hash, msg_length, start_s, end_s, server_add):
# creating new request message
request_msg = Message(SELF_TEAM_NAME, REQUEST_CODE, hash, msg_length, start_s, end_s)
self.client_socket.sendto(EncoderDecoder.encodeMessage(request_msg), server_add)
from flask import Flask, jsonify, request, Response, abort
import EncoderDecoder
import AIclassfier
import tensorflow as tf
app = Flask(__name__)
A = AIclassfier.classifier()
E = EncoderDecoder.Decoder()
@app.route('/', methods=['GET'])
def index():
return jsonify({
'author': 'Aayush Phuyal',
'author_url': 'http://viveksb007.wordpress.com/',
'base_url': 'zeolearn.com/',
'endpoints': {
'Returns URLS of images': '/magazines/photos/{number of photos}',
}
})
@app.route('/api/v1.0/classify', methods=['POST'])
def classify():
if request.method == 'POST':
if request.json:
print(request.json['image'])
decoded = E.decode(request.json['image'])
classification = A.classify(decoded)
return jsonify({"item": classification})
def __init__(self,
num_actions=None,
dim_obs=None,
memory_size=100,
memory_word_size=32,
name="TrainableAgent"):
'''
智能体对环境的基本认知，动作空间，状态空间
'''
self.num_actions = num_actions
self._obs_size = reduce(lambda x, y: x * y, list(dim_obs))
self.memory_size = memory_size
self.memory_word_size = memory_word_size
'''
1.实例化各个类
五个模块的引入
'''
# 编解码器的实例化
self._im2state = EncoderDecoder.ImEncoder(self._obs_size,
self.memory_word_size, 64)
self._state2im = EncoderDecoder.ImDecoder(self._obs_size,
self.memory_word_size, 64)
self._vae = EncoderDecoder.VAE(self._obs_size, self.memory_word_size,
64)
self._optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
self._vdecoder = EncoderDecoder.VDecoder(
1, 200) # 因为没用batch 所以是一维输出，就是一个v值
self._vaev = EncoderDecoder.VAEV(self._obs_size, self.memory_word_size,
64)
# 控制器实例化
self._controllercore = Controller.ControllerCore(
num_actions=self.num_actions,
num_node=10,
memory_size=self.memory_size,
memory_word_size=self.memory_word_size)
self._aggregator = Controller.MeanAggregator(self.memory_word_size,
self.memory_word_size,
name="aggregator",
concat=False) #输入输出维度相同
self._aggmodel = Controller.AggModel(self.memory_word_size)
self.batch_num = 0 # 用来控制训练agg的batch起点，训练聚合器参数的时候用到
# 存储器实例化
self._abstract_memory = self._controllercore.AbstractG
self._external_memory = Memory.ExternalMemory(
memory_size=self.memory_size)
# 读写器实例化
memory_num_reads = 2
memory_top_k = 3
self._memory_reader = MemReadWrite.MemReader(
memory_word_size=self.memory_word_size, #这个与隐藏层同维度
num_read_heads=memory_num_reads,
top_k=memory_top_k,
memory_size=self.memory_size)
self._memory_eraser = MemReadWrite.MemErase(
memory_word_size=self.memory_word_size,
memory_size=self.memory_size)
self._memory_writer = MemReadWrite.MemWriter(
memory_word_size=self.memory_word_size,
memory_size=self.memory_size)
#重构机制实例化
self._memory_reconstructor = MemReconstruction.MemReconstructor(
memory_word_size=self.memory_word_size)