def callback(self, event): name = event.widget['text'].split(':')[0] print('passed', name) f = open(self.menu + 'state.json', 'r') state = json.load(f) f.close() if state[name] == self.disable: print(name, ' disable ') return print('state old', state) ''' main logic part ''' _start = counter() f = os.popen('pwd', 'r') pwd = f.read().strip() f.close() script = pwd + '/state_machine.lua' f = os.popen("lua " + script + (" '%s'" % name), 'r') # print('popen',f.read()) state = json.load(f) print("system call lua spend %d ms!!!" % ((counter() - _start) * 1000)) f.close() self.scene_check(state) # if name not in self.sce: # # state = self.fun(state, name) # f = os.popen("lua ~/project/python_network_program_study/jinding_config_build/tmp_V06/state_machine.lua '%s'" % name, 'r') # # print('popen',f.read()) # state = json.load(f) # f.close() # self.scene_check(state) # else: # if not state[name]: # ''' # disable all other enabled scene! # ''' # for s in self.sce: # if state[s]: # state.update(self.scene_control(s, state, False)) # # [state.update(self.scene_control(s, state, False)) for s in self.sce] # state[name] = True # else: # state[name] = False # self.scene_control(name, state, state[name]) ''' main logic end ''' print('state new', state) self.button_update(state) f = open(self.menu + 'state.json', 'w') json.dump(state, f) f.close()
def fit(self, X, y, n_epochs, batch_size, print_many=False, verbose=1): model, optimizer = self.model, self.optimizer X, y = np.asarray(X), np.asarray(y) total_size = len(X) time_steps = X.shape[1] max_iters = total_size // batch_size if total_size % batch_size != 0: max_iters += 1 progresses = {int(n_epochs // (100 / i)): i for i in range(1, 101, 1)} t0, durations = counter(), list() for epoch in range(n_epochs): epoch_losses, epoch_acc = [], [] for i in range(max_iters): # N*T*D batch style x_batch = X[i * batch_size:(i + 1) * batch_size] y_batch = y[i * batch_size:(i + 1) * batch_size] current_batch_size = x_batch.shape[0] loss = model.forward(x_batch, y_batch) model.backward() params, grads = model.params, model.grads optimizer.update(params, grads) epoch_losses.append(loss) if verbose >= 2: loss_s = round(loss.item(), 3) perp = round(np.exp(loss_s).item(), 2) print( f"epoch-iter: {epoch}-{i}, loss: {loss_s}, perp: {perp}" ) durations.append(counter() - t0) t0 = counter() if (print_many and epoch % 100 == 0) or (not print_many and epoch in progresses): acc_s = f"{round(sum(epoch_acc) / (X.shape[0] * X.shape[1]) * 100, 4)}%" loss_s = round(np.mean(np.array(epoch_losses)).item(), 3) perp = round(np.exp(loss_s).item(), 2) print( f"epoch: {epoch}, loss: {loss_s}, perp: {perp}, acc: {acc_s}" ) if verbose > 0: avg_epoch_time = sum(durations) / len(durations) print("average epoch time:", round(avg_epoch_time, 3)) return avg_epoch_time
def wrapped(*args, **kwargs): start = counter() return_value = _f(*args, **kwargs) interval = counter() - start wrapped.interval = interval if print_fn is not None: nonlocal name if name is None: name = _f.__name__ + ': ' t, u = rescale_time(interval, unit=unit) print_str = f'{name}{t:.3g} {u}' print_fn(print_str) return return_value
def time_check(self, idx): if idx == 0: self.t0 = counter() if idx in self.progresses: print("WARNING: The length is to small for this timer.") elif idx in self.progresses: self.t1 = counter() duration = self.t1 - self.t0 self.t0 = counter() self.elapsed += duration idx = 1 if idx == 0 else idx eta = self.elapsed * ((self.length / idx) - 1) self.print_time(idx, self.elapsed, eta) else: pass
def interval(self) -> float: """Time elapsed in seconds If still in the context, returns time elapsed from the moment of entering to the context. If the context has been already left, returns the total time spent in the context. """ if self._interval: # when the context exited return self._interval else: # when still in the context return counter() - self._start
def __next__(self): try: now = counter() if self._last: interval = now - self._last self.intervals.append(interval) t, u = rescale_time(interval, self.unit) self.iteration_print_fn( f'iteration {self.num_iterations:4}: {t:.3g} {u}') self._last = now return next(self.iterable) except StopIteration: self.print_summary() raise StopIteration
s1.angle(-60, 1500) # move to -60 degrees in 1500ms s1.speed(50) # for continuous rotation servos ''' 1.6 External interrupts ''' from pyb import Pin, ExtInt callback = lambda e: print("intr") ext = ExtInt(Pin('Y1'), ExtInt.IRQ_RISING, Pin.PULL_NONE, callback) ''' 1.7 Timers ''' from pyb import Timer tim = Timer(1, freq=1000) time.counter() # get counter value time.freq(0.5) # 0.5Hz time.callback(lambda t: pyb.LED(1).toggle()) ''' 1.8 PWM ''' from pyb import Pin, Timer p = Pin('X1') tim = Timer(2, freq=1000) ch = Timer.channel(1, Timer.PWM, pin=p) ch.pulse_width_percent(50) ''' 1.9 ADC ''' from pyb import Pin, ADC
def main(): """Start Dodge.""" pygame.init() #Display created with the screen size constants set priorly. screen = pygame.display.set_mode(screen_size) #The line that separates the lanes is set using the size of the screen. lane_line = FakeSprite("White Rectangle.jpg", position=(int(screen_width * 0.45), 0), size=(screen_height, int(screen_width / 10)), rotation=90) player_ball = FakeSprite("White Ball.jpg", position=(int(screen_width * 0.025), int(screen_height * 13 / 15)), size=(int(screen_width * 0.4), int(screen_height * 2 / 15))) first_wall = FakeSprite("White Rectangle.jpg", position=(0, 0), size=(int(screen_width * 0.45), int(screen_height / 30))) lane_line.blit_on(screen) player_ball.blit_on(screen) first_wall.blit_on(screen) pygame.display.flip() walls = [first_wall] wall_speed = [0, 5] wall_space = player_ball.rectangle.height * 5 base_time = counter() press = False over = False score = 0 #Main Game Loop while True: #If a wall makes contact with the ball, the player loses. for wall in walls: if wall.rectangle.colliderect(player_ball.rectangle): game_over(screen, score) over = True #If the game is over, the game no longer loops. if over: sleep(3) break #The game gets progressively harder. if counter() - base_time >= 1: base_time = counter() wall_speed[1] += 1 #When the previous wall has gone far enough, the next wall comes down. if walls[-1].rectangle.top >= wall_space: walls.append(new_wall()) #Every time a rectangle comes offscreen, it is no longer animated #to keep process speeds high. The player also gets a point. for wall in walls: if wall.rectangle.top >= screen_height: del walls[walls.index(wall)] score += 1 #All the walls currently onscreen move down with their curent speed. for wall in walls: wall.move(wall_speed) #The player's ball is moved to the other side #if the space bar is pressed. if pygame.key.get_pressed()[K_SPACE]: press = True elif not pygame.key.get_pressed()[K_SPACE] and press: press = False if player_ball.rectangle.left == 5: player_ball.rectangle.left = 115 elif player_ball.rectangle.left == 115: player_ball.rectangle.left = 5 #Image update phase. #The screen is filled black to erase the previous frame. screen.fill(black) #All of the (fake) sprites are blitted back onto the display. lane_line.blit_on(screen) player_ball.blit_on(screen) for wall in walls: wall.blit_on(screen) #The display is updated. pygame.display.flip() #The pump() function is called to keep input working. pygame.event.pump() sleep(0.01) #3 seconds after game over, pygame quits. pygame.quit()
def __iter__(self): self._start = counter() self.iterable = iter(self.iterable) return self
def train_np_last(self, X, y_true, batch_size, learning_rate, num_epochs, print_many, verbose): self.batch_size = batch_size lr = learning_rate progresses = { int(num_epochs // (100 / i)): i for i in range(1, 101, 1) } t0 = counter() durations = [] rnn = RNNLayer(input_dim=self.input_dim, hidden_dim=self.hidden_dim, Wx=self.rnn_Wx, Wh=self.rnn_Wh, bias=self.rnn_b) for epoch in range(num_epochs): epoch_losses, epoch_acc = [], [] for i in range(self.max_iters): # # T*N*D batch style # x_batch = X[i * self.batch_size: (i + 1) * self.batch_size] # x_batch = np.array([x_batch[:, step, :] for step in range(self.time_steps)]) # y_true_batch = y_true[i * self.batch_size:(i + 1) * self.batch_size] # current_batch_size = x_batch.shape[1] # N*T*D batch style x_batch = X[i * self.batch_size:(i + 1) * self.batch_size] y_true_batch = y_true[i * self.batch_size:(i + 1) * self.batch_size] current_batch_size = x_batch.shape[0] fc = FCLayer(W=self.fc_W, bias=self.fc_b, batch_size=current_batch_size) loss = SoftmaxWithLossLayer() h_last, h_stack = rnn.forward(x_batch) fc_out = fc.forward(x=h_last) loss_value, num_acc = loss.forward(x=fc_out, y_true=y_true_batch) epoch_losses.append(loss_value) epoch_acc.append(num_acc) # backward pass d_L = loss.backward() fc_grads = fc.backward(d_L) d_fc_W = fc_grads['W_grad'] d_fc_bias = fc_grads['bias_grad'] d_h_last = fc_grads['x_grad'] grads = rnn.backward(d_h_next=d_h_last, optimize=True) # parameter update self.rnn_Wx -= lr * grads["Wx_grad"] self.rnn_Wh -= lr * grads["Wh_grad"] self.rnn_b -= lr * grads["bias_grad"] self.fc_W -= lr * d_fc_W self.fc_b -= lr * d_fc_bias parameters = [self.rnn_Wx, self.rnn_Wh, self.rnn_b] rnn.update(parameters) durations.append(counter() - t0) t0 = counter() if (print_many and epoch % 100 == 0) or (not print_many and epoch in progresses): acc_s = f"{round(sum(epoch_acc) / (X.shape[0]) * 100, 4)}%" loss_s = round(np.mean(np.array(epoch_losses)).item(), 3) perp = round(np.exp(loss_s).item(), 2) print( f"epoch: {epoch}, loss: {loss_s}, perp: {perp}, acc: {acc_s}" ) if verbose > 0: avg_epoch_time = sum(durations) / len(durations) print("average epoch time:", round(avg_epoch_time, 3)) return avg_epoch_time
def train_np_stack(self, X, y_true, batch_size, learning_rate, num_epochs, print_many, verbose): self.batch_size = batch_size lr = learning_rate progresses = { int(num_epochs // (100 / i)): i for i in range(1, 101, 1) } t0 = counter() durations = [] if self.layertype == 'rnn': rnn = RNNLayerWithTimesteps(input_dim=self.input_dim, hidden_dim=self.hidden_dim, Wx=self.rnn_Wx, Wh=self.rnn_Wh, bias=self.rnn_b) elif self.layertype == 'lstm': rnn = LSTMLayerTimesteps(self.input_dim, self.hidden_dim, self.rnn_Wx, self.rnn_Wh, self.rnn_b, self.stateful) for epoch in range(num_epochs): epoch_losses, epoch_acc = [], [] for i in range(self.max_iters): # N*T*D batch style x_batch = X[i * self.batch_size:(i + 1) * self.batch_size] y_true_batch = y_true[i * self.batch_size:(i + 1) * self.batch_size] current_batch_size = x_batch.shape[0] fc = FCLayerTimesteps(W=self.fc_W, bias=self.fc_b) loss = SoftmaxWithLossLayerTimesteps() h_last, h_stack = rnn.forward(x_batch) fc_out = fc.forward(x=h_stack) loss_value, num_acc = loss.forward(x=fc_out, y_true=y_true_batch) epoch_losses.append(loss_value) epoch_acc.append(num_acc) if verbose >= 2: acc_s = f"{round(num_acc / (x_batch.shape[0] * x_batch.shape[1]) * 100, 4)}%" loss_s = round(loss_value.item(), 3) perp = round(np.exp(loss_s).item(), 2) print( f"epoch-iter: {epoch}-{i}, loss: {loss_s}, perp: {perp}, acc: {acc_s}" ) # backward pass d_L = loss.backward() d_h_stack = fc.backward(d_L) rnn.backward(d_h_stack=d_h_stack, optimize=True) if self.layertype == 'rnn': dWx, dWh, dbias = rnn.grads["Wx"], rnn.grads[ "Wh"], rnn.grads["bias"] elif self.layertype == 'lstm': dWx, dWh, dbias = rnn.grads # parameter update self.rnn_Wx -= lr * dWx self.rnn_Wh -= lr * dWh self.rnn_b -= lr * dbias self.fc_W -= lr * fc.grads[0] self.fc_b -= lr * fc.grads[1] rnn.update(self.rnn_Wx, self.rnn_Wh, self.rnn_b) durations.append(counter() - t0) t0 = counter() if (print_many and epoch % 100 == 0) or (not print_many and epoch in progresses): acc_s = f"{round(sum(epoch_acc) / (X.shape[0] * X.shape[1]) * 100, 4)}%" loss_s = round(np.mean(np.array(epoch_losses)).item(), 3) perp = round(np.exp(loss_s).item(), 2) print( f"epoch: {epoch}, loss: {loss_s}, perp: {perp}, acc: {acc_s}" ) if verbose > 0: avg_epoch_time = sum(durations) / len(durations) print("average epoch time:", round(avg_epoch_time, 3)) return avg_epoch_time
def train_torch(self, X, y_true, batch_size, learning_rate, num_epochs, print_many, verbose): self.batch_size = batch_size progresses = { int(num_epochs // (100 / i)): i for i in range(1, 101, 1) } t0 = counter() durations = [] device = torch.device('cuda:0') rnn = RNN(input_size=self.input_dim, hidden_size=self.hidden_dim, num_layers=1, nonlinearity='tanh', bias=True, batch_first=False).to(device) fc = FCLayer(self.hidden_dim, self.output_size, bias=True).to(device) params = [rnn.parameters(), fc.params()] optimizer = SGD(chain(*params), lr=learning_rate) for epoch in range(num_epochs): epoch_loss = 0 for i in range(self.max_iters): x_batch = X[i * self.batch_size:(i + 1) * self.batch_size] x_batch = np.array( [x_batch[:, step, :] for step in range(self.time_steps)]) y_true_batch = y_true[i * self.batch_size:(i + 1) * self.batch_size] batch_size_local = x_batch.shape[1] # convert to pytorch tensor y_true_batch = y_true_batch.astype(np.int64) y_true_batch = torch.tensor(y_true_batch, requires_grad=False).to(device) x_batch = x_batch.astype(np.float32) x_batch = torch.tensor(x_batch, requires_grad=True).to(device) # forward pass h_stack, h_last = rnn.forward(x_batch, hx=None) fc_out = fc.forward(h_last) log_y_pred = F.log_softmax(input=fc_out, dim=2) log_y_pred = log_y_pred.view(batch_size_local, self.output_size) loss = F.nll_loss(input=log_y_pred, target=y_true_batch, reduction='mean') # update gradient optimizer.zero_grad() loss.backward() epoch_loss += loss.item() optimizer.step() durations.append(counter() - t0) t0 = counter() if (print_many and epoch % 100 == 0) or (not print_many and epoch in progresses): print( f"after epoch: {epoch}, epoch_losses: {round(epoch_loss / self.max_iters, 3)}" ) if verbose > 0: avg_epoch_time = sum(durations) / len(durations) print("average epoch time:", round(avg_epoch_time, 3)) return avg_epoch_time
from os.path import isfile from time import perf_counter as counter from multiprocessing import active_children, Lock, Pipe, Process from mrrobot.app.units import UnitLoader from mrrobot.app.exception import Elliot from mrrobot.app.configuration import Configuration from mrrobot.app.arguments import parse as argparser istimeout = lambda start, timeout: bool( timeout > 0 and not start or not timeout or counter() - start >= timeout) def arguments() -> tuple: contents = None arguments = argparser() if isfile(arguments.input): with open(arguments.input, "rb") as f: contents = f.read() return arguments, contents def check_requirements() -> None: # argparse try: import argparse del argparse except ImportError: raise Elliot("Module argparse is not installed") # PIL (Pillow) try:
def __enter__(self): self._start = counter() return self