def main(): # Benchmarking program t = Timer(verbose=True) # Dataset X = [[1], [2], [3], [4], [5], [6], [7]] Y = [1, 2, 3, 4, 5, 6, 7] # Minimizing using gradient descent method print("\n> Using Gradient Descent") lr = LinearRegression(X, Y, 0.03) t.start() lr.setAlpha(0.035706) lr.gradientDescent() t.finish() predicted_Y2 = [lr.predict(x) for x in X] print("Error rate: %f" % lr.getErrorRate()) # Plotting example (2d graph) plt.plot(X, Y, 'o') # Dots are original distribution plt.plot(X, predicted_Y2, 'g') # Green line is Gradient descent plt.show() return 0
def __init__(self, bot): self.bot = bot self.tris = False self.tris_board = [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '] self.turn = 0 self.initializer = None self.guest = None self.running = False self.timeout_timer = Timer(60) self.lastBoard = None
def main(): # 初始化 timer = Timer() kafka_producer = producer.Producer() kafka_consumer = consumer.Consumer() # 到期callback def on_expired(message): print('Task expired!') target_topic = _.get(message, 'target_topic') if target_topic: kafka_producer.send(topic=target_topic, value=message) kafka_producer.flush() else: print('Enqueue: target_topic is missing in enqueue message!') # 订阅原始消息 @kafka_consumer.event_emitter.on('message') def on_message(message): print('Receive delay task!') timer.add( TimerTaskEntry(delay=(_.get(message, 'value.delay') or 0), task=on_expired, message=message.value)) # 恢复上一次停机前状态 timer.recover(task=on_expired) # 持久化当前状态 timer.persist() # 启动Timer timer.start() # 启动原始消息订阅 kafka_consumer.tail()
def __init__(self): """ Description Blink LED without delay function. RealTime (int pin, int millis_period, boolean state) Parameters pin: Arduino LED pin millis_period: Time period to define blink delay (milliseconds) state: Initial LED state Returns void """ self.timer = Timer(1000)
def __init__(self, sock, node_listen_addr, ip_addresses, other_end_listen_addr=None): super(Connection, self).__init__() self.daemon = True self.socket = sock self.node_listen_addr = node_listen_addr self.other_end_listen_addr = other_end_listen_addr """ ping_status: Integer telling how many ping messages have not been answered. Value -1 means that an answer has been received during that cycle. """ self.ping_status = -1 self.ping_timer = Timer(PING_INTERVAL) self.read_queue = multiprocessing.Queue() self.write_queue = multiprocessing.Queue() self.ip_addresses = ip_addresses
def test_add(self): """ 添加任务测试 :return: """ timer = Timer(wheel_size=5) keys = [0, 0.1, 0.3, 0.8, 1, 2, 3, 4, 5, 8, 9, 10, 18, 24, 26, 30] for key in keys: timer.add( TimerTaskEntry(delay=key * 1000, task=self._print, key=key)) time.sleep(keys[-1]) timer.shutdown()
class SigGen(): """ description: """ __version__ = 0.01 def __init__(self): """ Description Blink LED without delay function. RealTime (int pin, int millis_period, boolean state) Parameters pin: Arduino LED pin millis_period: Time period to define blink delay (milliseconds) state: Initial LED state Returns void """ self.timer = Timer(1000) def period(self, period): """ Description Sine wave. object.sine() Parameters void Returns float: sine signal """ self.timer.set(period) def sine(self): """ Description Sine wave. object.sine() Parameters void Returns float: sine signal """ spread = ((-math.cos((self.step() * math.pi) * 2.0)) + 1) / 2 return spread def square(self): """ Description Square wave. object.square() Waveform with 1000 milliseconds duration: 1 ┐ ┌────┐ │ │ │ └────┘ └ 0 500 1000 Parameters void Returns float: square signal """ if self.step() < 0.5: spread = 0 else: spread = 1 return spread def step(self): """ Description A time baseline to provide x axis to signal generation. step() Parameters void Returns float: time baseline from 0 to 1. """ self.timer.check() return self.timer.status()
class Connection(multiprocessing.Process): def __init__(self, sock, node_listen_addr, ip_addresses, other_end_listen_addr=None): super(Connection, self).__init__() self.daemon = True self.socket = sock self.node_listen_addr = node_listen_addr self.other_end_listen_addr = other_end_listen_addr """ ping_status: Integer telling how many ping messages have not been answered. Value -1 means that an answer has been received during that cycle. """ self.ping_status = -1 self.ping_timer = Timer(PING_INTERVAL) self.read_queue = multiprocessing.Queue() self.write_queue = multiprocessing.Queue() self.ip_addresses = ip_addresses def run(self): process_print("New Connection() process running") # If socket is not created already, do it now. if self.socket is None: self.socket = connect(self.other_end_listen_addr[0], self.other_end_listen_addr[1]) if self.socket is None: self.die() self.send_join_request() self.recv_join_response() self.register_connection(self.other_end_listen_addr) else: join_request = self.recv_join_request() self.other_end_listen_addr = (join_request.header.sender_ip, join_request.header.sender_port) self.send_join_response(join_request) self.register_connection(self.other_end_listen_addr) self.ping_timer.start() while True: if self.ping_timer.has_expired(): self.ping_status += 1 self.send_ping_a() self.ping_timer.start() read_sockets, _, _ = select.select( [self.read_queue._reader, self.socket], [], [], PING_INTERVAL) for sock in read_sockets: if sock == self.socket: try: header = self.recv_header() except ValueError: continue body = recvall(self.socket, header.payload_len) if header.msg_type == TYPE_QUERY_HIT: self.write_queue.put(Message(header, body, None)) elif header.msg_type == TYPE_PING: if header.time_to_live == 1: self.respond_to_type_a_ping(header.msg_id) else: pass # TODO: receive type b pings elif header.msg_type == TYPE_PONG: # Type A pong if len(body) == 0: self.ping_status = -1 else: pass # TODO: receive type b pongs elif header.msg_type == TYPE_QUERY: self.write_queue.put( Message(header, body, [], [self.other_end_listen_addr])) else: self.handle_read_queue() def handle_read_queue(self): message = self.read_queue.get() if isinstance(message, Message): self.send_message(message) def respond_to_type_a_ping(self, msg_id): header_obj = Header(TYPE_PONG, self.node_listen_addr[0], self.node_listen_addr[1], 0, 1, msg_id) byte_header = header_obj.get_bytes() try: self.socket.sendall(byte_header) except socket.error: self.die() def recv_join_request(self): """ :return: listen address (ip, port tuple) of the sender """ header = self.recv_header() return Message(header) # TODO: validation def send_message(self, message): byte_header = message.header.get_bytes() try: self.socket.sendall(byte_header) self.socket.sendall(message.body) # process_print("sent message: " + str(byte_header) + " and body : " + str(message.body)) # DEBUG except socket.error: self.die() def send_join_request(self): header_obj = Header(TYPE_JOIN, self.node_listen_addr[0], self.node_listen_addr[1], 0, 1) byte_header = header_obj.get_bytes() try: self.socket.sendall(byte_header) except socket.error: self.die() def send_ping_a(self): header_obj = Header(TYPE_PING, self.node_listen_addr[0], self.node_listen_addr[1], 0, 1) byte_header = header_obj.get_bytes() try: self.socket.sendall(byte_header) except socket.error: self.die() def recv_join_response(self): header = self.recv_header() bytes_payload = recvall(self.socket, JOIN_RESPONSE_PAYLOAD_LEN) payload = struct.unpack("!H", bytes_payload)[0] if payload != JOIN_ACC: self.die() def send_join_response(self, request): header_obj = Header(TYPE_JOIN, self.node_listen_addr[0], self.node_listen_addr[1], JOIN_RESPONSE_PAYLOAD_LEN, 1, request.header.msg_id) payload_bytes = struct.pack("!H", JOIN_ACC) try: self.socket.sendall(header_obj.get_bytes() + payload_bytes) except socket.error: self.die() def recv_header(self): bytes_header = recvall(self.socket, HEADER_LENGTH) if bytes_header is None: self.die() header_obj = unpack_header(bytes_header) return header_obj def register_connection(self, other_end_listen_addr): registration = InterprocessMessage(InterprocessMessage.REGISTER, other_end_listen_addr) self.write_queue.put(registration) def die(self): if self.socket is not None: self.socket.close() process_print("Process died") os._exit(0)
'0 for not computing 1-log on all advantages') parser.add_argument('--sample_size', type=int, default=20) parser.add_argument('--fine_tune', action='store_true', help='fine tune with std rouge') parser.add_argument('--train_example_quota', type=int, default=-1, help='how many train example to train on: -1 means full train data') parser.add_argument('--length_limit', type=int, default=-1, help='length limit output') parser.add_argument('--ext_model', type=str, default="simpleRNN", help='lstm_summarunner, gru_summarunner, bag_of_words, simpleRNN') parser.add_argument('--prt_inf', action='store_true') args = parser.parse_args() if args.length_limit > 0: args.oracle_length = 2 torch.cuda.set_device(args.device) print('generate config') with open(args.vocab_file, "rb") as f: vocab = pickle.load(f, encoding='bytes') print(vocab) extract_net = extractive_training(args, vocab) if __name__ == '__main__': timer = Timer() with timer: main()
class Tris(commands.Cog): def __init__(self, bot): self.bot = bot self.tris = False self.tris_board = [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '] self.turn = 0 self.initializer = None self.guest = None self.running = False self.timeout_timer = Timer(60) self.lastBoard = None async def DrawBoard(self, ctx, tris_board): self.lastBoard = await ctx.channel.send("""`+---+---+---+ | %c | %c | %c | +---+---+---+ | %c | %c | %c | +---+---+---+ | %c | %c | %c | +---+---+---+`""" % (tris_board[0], tris_board[1], tris_board[2], tris_board[3], tris_board[4], tris_board[5], tris_board[6], tris_board[7], tris_board[8])) check = self.check_board() if check == 404: await ctx.channel.send(get_string(ctx, 'pareggio')) self.end_game() elif check != False: winner = self.initializer if check == 'x' else self.guest await ctx.channel.send( get_string(ctx, 'vincitore_e') + winner.mention) self.end_game() @commands.command() async def tris(self, ctx, member: discord.Member): # Inizio react = ['✅', '❌'] # Devo sistemarla in qualche modo xDDD if self.running == True: await ctx.channel.send(get_string(ctx, 'partita_in_corso')) return if ctx.author == member: await ctx.channel.send(get_string(ctx, 'solo')) return if member.bot: await ctx.channel.send(get_string(ctx, 'gioco_con_bot')) return msg = await ctx.channel.send( f"{member.mention} {get_string(ctx, 'sfida')}") self.running = True # Aggiungi reazioni ad un messaggio per fare la sfida for r in react: await msg.add_reaction(r) def check_react(reaction, user): # Controllo cosa mette l'utente if user != member or reaction.message.id != msg.id or not str( reaction.emoji) in react: return False return True try: res, user = await self.bot.wait_for('reaction_add', check=check_react, timeout=15) except asyncio.TimeoutError: await ctx.channel.send( f'{member.mention} {get_string(ctx, "timeout")}') self.running = False return # In caso accetta if react[0] in str(res.emoji): await ctx.channel.send( f'{member.mention} {get_string(ctx, "accept")}') # Se rifiuta elif react[1] in str(res.emoji): await ctx.channel.send( f'{member.mention} {get_string(ctx, "decline")}') self.running = False return # Numeri per far vedere come si gioca num_tris_board = ['1', '2', '3', '4', '5', '6', '7', '8', '9'] await ctx.channel.send('Iniziando sessione di tris...') if member == self.bot.user: await ctx.send.channel('Non puoi sfidare il bot!') return # Disegno tavola iniziale await self.DrawBoard(ctx, num_tris_board) await ctx.channel.send(get_string(ctx, 'reg_tris')) self.tris = True self.initializer = ctx.author self.guest = member loop = asyncio.get_event_loop() # Inizio timer della morte self.timeout_timer.call_at_end(lambda: (self.timeout(ctx, loop))) t = Thread(target=self.timeout_timer.start) t.start() def timeout(self, ctx, loop): loop.create_task(ctx.channel.send(get_string(ctx, 'timeout60'))) self.end_game() @commands.Cog.listener() async def on_message(self, ctx): # Controllo se persona ha i diritti di giocare if not self.tris or ctx.author == self.bot.user or ( ctx.author != self.initializer and ctx.author != self.guest): return else: # Controllo se ha scritto un numero num = re.search(numbers, ctx.content) # Controllo di chi e' il turno if self.turn % 2 == 0 and ctx.author != self.initializer: await ctx.channel.send( get_string(ctx, 'turno_di') + self.initializer.mention + '!') return if self.turn % 2 == 1 and ctx.author != self.guest: await ctx.channel.send( get_string(ctx, 'turno_di') + self.guest.mention + '!') return if num == None: await ctx.channel.send(get_string(ctx, 'number_19')) return num = int(num.group()) - 1 # Controllo se casella gia' occupata if self.tris_board[num] != ' ': await ctx.channel.send(get_string(ctx, 'occupato')) await self.DrawBoard(ctx, self.tris_board) return self.tris_board[num] = 'x' if self.turn % 2 == 0 else 'o' # Aumento turno self.turn += 1 if self.lastBoard != None: await self.lastBoard.delete() await ctx.delete() # Disegno tavola await self.DrawBoard(ctx, self.tris_board) # Reset timer della morte self.timeout_timer.reset() def check_board(self): # Orizzontale if self.tris_board[0] == self.tris_board[1] and self.tris_board[ 0] == self.tris_board[2] and self.tris_board[0] != ' ': return self.tris_board[0] if self.tris_board[3] == self.tris_board[4] and self.tris_board[ 3] == self.tris_board[5] and self.tris_board[3] != ' ': return self.tris_board[3] if self.tris_board[6] == self.tris_board[7] and self.tris_board[ 6] == self.tris_board[8] and self.tris_board[6] != ' ': return self.tris_board[6] #Verticale if self.tris_board[0] == self.tris_board[3] and self.tris_board[ 0] == self.tris_board[6] and self.tris_board[0] != ' ': return self.tris_board[0] if self.tris_board[1] == self.tris_board[4] and self.tris_board[ 1] == self.tris_board[7] and self.tris_board[1] != ' ': return self.tris_board[1] if self.tris_board[2] == self.tris_board[5] and self.tris_board[ 2] == self.tris_board[8] and self.tris_board[2] != ' ': return self.tris_board[2] #Obliquo if self.tris_board[0] == self.tris_board[4] and self.tris_board[ 0] == self.tris_board[8] and self.tris_board[0] != ' ': return self.tris_board[0] if self.tris_board[2] == self.tris_board[4] and self.tris_board[ 2] == self.tris_board[6] and self.tris_board[2] != ' ': return self.tris_board[2] # Tutte piene if not ' ' in self.tris_board: return 404 return False def end_game(self): # Reset allo stato iniziale self.tris = False self.initializer = None self.guest = None self.tris_board = [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '] self.turn = 0 self.timeout_timer.stop() self.running = False @tris.error async def error(self, ctx, error): if isinstance(error, commands.MissingRequiredArgument): await ctx.send(get_string(ctx, 'da_solo')) elif isinstance(error, commands.MemberNotFound): await ctx.send(get_string(ctx, 'immaginary'))