def __init__ ( self, name, mapping, parent=None ) : portlist = dict( [("A%d"%i, gate.IN) for i in range (0,4)] + [("B%d"%i, gate.IN) for i in range (0,4)] + [("Bb%d"%i, gate.IN) for i in range (0,4)] + [("S%d"%i, gate.IN) for i in range (0,4)] + [("D%d"%i, gate.OUT) for i in range (0,4)]) gate.module.__init__( self, name, portlist, mapping, parent) for i in range(0, 4): n = "BbS1%d" % i self.netlist[n] = net.net(n, parent=self) n = "BS0%d" % i self.netlist[n] = net.net(n, parent=self) self.gatelist.extend([ AND("BbS10gate", [self.netlist["BbS10"], self.port["Bb0"].netconn, self.port["S1"].netconn], self), AND("BbS11gate", [self.netlist["BbS11"], self.port["Bb1"].netconn, self.port["S1"].netconn], self), AND("BbS12gate", [self.netlist["BbS12"], self.port["Bb2"].netconn, self.port["S1"].netconn], self), AND("BbS13gate", [self.netlist["BbS13"], self.port["Bb3"].netconn, self.port["S1"].netconn], self), AND("BS00gate", [self.netlist["BS00"], self.port["B0"].netconn, self.port["S0"].netconn], self), AND("BS01gate", [self.netlist["BS01"], self.port["B1"].netconn, self.port["S0"].netconn], self), AND("BS02gate", [self.netlist["BS02"], self.port["B2"].netconn, self.port["S0"].netconn], self), AND("BS03gate", [self.netlist["BS03"], self.port["B3"].netconn, self.port["S0"].netconn], self), NOR("D0gate", [self.port["D0"].netconn, self.netlist["BbS10"], self.netlist["BS00"], self.port["A0"].netconn], self), NOR("D1gate", [self.port["D1"].netconn, self.netlist["BbS11"], self.netlist["BS01"], self.port["A1"].netconn], self), NOR("D2gate", [self.port["D2"].netconn, self.netlist["BbS12"], self.netlist["BS02"], self.port["A2"].netconn], self), NOR("D3gate", [self.port["D3"].netconn, self.netlist["BbS13"], self.netlist["BS03"], self.port["A3"].netconn], self)])
def __init__(self, name, mapping, parent=None): portlist = dict([("COUT", gate.OUT), ("CIN", gate.IN), ("RSTB", gate.IN), ("PHI", gate.IN)]) for i in range(0, 16): portlist["Q%d" % i] = gate.OUT gate.module.__init__(self, name, portlist, mapping, parent) self.netlist['c0'] = net.net('c0', parent=self) self.netlist['c1'] = net.net('c1', parent=self) self.netlist['c2'] = net.net('c2', parent=self) self.gatelist = [ count4_nmos( "count4_nmos_0_u", dict([('Q0', self.port['Q0'].netconn), ('Q1', self.port['Q1'].netconn), ('Q2', self.port['Q2'].netconn), ('Q3', self.port['Q3'].netconn), ('PHI', self.port['PHI'].netconn), ('RSTB', self.port['RSTB'].netconn), ('CIN', self.port['CIN'].netconn), ('COUT', self.netlist['c0'])]), self), count4_nmos( "count4_nmos_1_u", dict([('Q0', self.port['Q4'].netconn), ('Q1', self.port['Q5'].netconn), ('Q2', self.port['Q6'].netconn), ('Q3', self.port['Q7'].netconn), ('PHI', self.port['PHI'].netconn), ('RSTB', self.port['RSTB'].netconn), ('CIN', self.netlist['c0']), ('COUT', self.netlist['c1'])]), self), count4_nmos( "count4_nmos_2_u", dict([('Q0', self.port['Q8'].netconn), ('Q1', self.port['Q9'].netconn), ('Q2', self.port['Q10'].netconn), ('Q3', self.port['Q11'].netconn), ('PHI', self.port['PHI'].netconn), ('RSTB', self.port['RSTB'].netconn), ('CIN', self.netlist['c1']), ('COUT', self.netlist['c2'])]), self), count4_nmos( "count4_nmos_3_u", dict([('Q0', self.port['Q12'].netconn), ('Q1', self.port['Q13'].netconn), ('Q2', self.port['Q14'].netconn), ('Q3', self.port['Q15'].netconn), ('PHI', self.port['PHI'].netconn), ('RSTB', self.port['RSTB'].netconn), ('CIN', self.netlist['c2']), ('COUT', self.port['COUT'].netconn)]), self) ]
def __init__(self, name, mapping, parent=None): portlist = dict([('Q', gate.OUT), ('D', gate.IN), ('RSTB', gate.IN), ('PHI', gate.IN)]) gate.module.__init__(self, name=name, portlist=portlist, mapping=mapping, parent=parent) for i in ('phib', 'rst', 'n0'): self.netlist[i] = net.net(i, parent=self, pullup_str=100) self.netlist['n1'] = net.net('n1', parent=self, charge_storage=True) self.netlist['n2'] = net.net('n2', parent=self, charge_storage=True) self.port['Q'].netconn.pullup_str += 100 self.gatelist.extend([ # Inverters for the clock and reset signals UNMOS("NMOS_0_u", [ self.netlist['phib'], self.netlist['vss'], self.port['PHI'].netconn ], self), UNMOS("NMOS_1_u", [ self.netlist['rst'], self.netlist['vss'], self.port['RSTB'].netconn ], self), # 2 half latches UNMOS( "NMOS_2_u", [self.netlist['n0'], self.netlist['vss'], self.netlist['n1']], self), UNMOS("NMOS_3_u", [ self.netlist['n1'], self.port['D'].netconn, self.netlist['phib'] ], self), UNMOS("NMOS_4_u", [ self.port['Q'].netconn, self.netlist['vss'], self.netlist['n2'] ], self), UNMOS("NMOS_5_u", [ self.netlist['n2'], self.netlist['n0'], self.port['PHI'].netconn ], self), # Reset first and second latches in opposite directions - must be strong drivers to win contention vs pass gates UNMOS( "NMOS_6_u", [self.netlist['n1'], self.netlist['vss'], self.netlist['rst']], self), UNMOS( "NMOS_7_u", [self.netlist['n2'], self.netlist['vdd'], self.netlist['rst']], self), ])
def __init__ ( self, name, mapping, parent=None ) : portlist = dict( [("Gb%d"%i, gate.IN) for i in range (0,4)] + [("Pb%d"%i, gate.IN) for i in range (0,4)] + [("C%d"%i, gate.OUT) for i in range (0,4)] + [("CNb", gate.IN),("CN4", gate.OUT),("X", gate.OUT),("Y", gate.OUT)] ) gate.module.__init__( self, name, portlist, mapping, parent) for i in range(0, 4): n = "Pbuf%d" % i self.netlist[n] = net.net(n, parent=self) for n in [ "CNbGb0","Pb0Gb1","CNbGb01", "Pb1Gb2", "Pb0Gb12", "Pb1Gb23", "Pb0Gb123", "CNbGb012", "Pb2Gb3", "XCNb"] : self.netlist[n] = net.net(n, parent=self) self.gatelist.extend([ INV("C0gate", [self.port["C0"].netconn, self.port["CNb"].netconn], self), BUF("Pb0gate", [self.netlist['Pbuf0'], self.port["Pb0"].netconn], self), AND("CNbGb0gate", [self.netlist["CNbGb0"], self.port["CNb"].netconn, self.port["Gb0"].netconn], self), BUF("Pb1gate", [self.netlist['Pbuf1'], self.port["Pb1"].netconn], self), AND("Pb0Gb1gate", [self.netlist["Pb0Gb1"], self.port["Pb0"].netconn, self.port["Gb1"].netconn], self), AND("CNbGb01gate", [self.netlist["CNbGb01"], self.port["CNb"].netconn, self.port["Gb0"].netconn, self.port["Gb1"].netconn], self), BUF("Pb2gate", [self.netlist['Pbuf2'], self.port["Pb2"].netconn], self), AND("Pb1Gb2gate", [self.netlist["Pb1Gb2"], self.port["Pb1"].netconn, self.port["Gb2"].netconn], self), AND("Pb0Gb12gate", [self.netlist["Pb0Gb12"], self.port["Pb0"].netconn, self.port["Gb1"].netconn, self.port["Gb2"].netconn], self), AND("CNbGb012gate", [self.netlist["CNbGb012"], self.port["CNb"].netconn, self.port["Gb0"].netconn, self.port["Gb1"].netconn, self.port["Gb2"].netconn], self), BUF("Pb3gate", [self.netlist['Pbuf3'], self.port["Pb3"].netconn], self), AND("Pb2Gb3gate", [self.netlist["Pb2Gb3"], self.port["Pb2"].netconn, self.port["Gb3"].netconn], self), AND("Pb1Gb23gate", [self.netlist["Pb1Gb23"], self.port["Pb1"].netconn, self.port["Gb2"].netconn, self.port["Gb3"].netconn], self), AND("Pb0Gb123gate", [self.netlist["Pb0Gb123"], self.port["Pb0"].netconn, self.port["Gb1"].netconn, self.port["Gb2"].netconn, self.port["Gb3"].netconn], self), NAND("Xgate", [self.port["X"].netconn, self.port["Gb0"].netconn, self.port["Gb1"].netconn, self.port["Gb2"].netconn, self.port["Gb3"].netconn], self), NOR("Ygate", [ self.port["Y"].netconn, self.netlist["Pbuf3"],self.netlist["Pb2Gb3"],self.netlist["Pb1Gb23"],self.netlist["Pb0Gb123"]], self), NAND("XCNbgate", [self.netlist["XCNb"], self.port["Gb0"].netconn, self.port["Gb1"].netconn, self.port["Gb2"].netconn, self.port["Gb3"].netconn, self.port["CNb"].netconn], self), AND("CN4gate", [self.port["CN4"].netconn, self.port["Y"].netconn, self.netlist["XCNb"]], self), NOR("C3gate", [self.port["C3"].netconn, self.netlist["Pbuf2"], self.netlist["Pb1Gb2"], self.netlist["Pb0Gb12"], self.netlist["CNbGb012"]], self), NOR("C2gate", [self.port["C2"].netconn, self.netlist["Pbuf1"], self.netlist["Pb0Gb1"], self.netlist["CNbGb01"]], self), NOR("C1gate", [self.port["C1"].netconn, self.netlist["Pbuf0"], self.netlist["CNbGb0"]], self)])
def test(net, testloader, cost, use_cuda): net.eval() test_loss = 0.0 correct = 0.0 total = 0 # temp = [] for data in testloader: x_test, y_test = data if use_cuda: x_test, y_test = x_test.cuda(), y_test.cuda() x_test, y_test = Variable(x_test), Variable(y_test) output = net(x_test) # if use_cuda: # temp.append(output.data.cpu().numpy()) # else: # temp.append(output.data.numpy()) test_loss += cost(output, y_test).data[0] if use_cuda: _, pred = torch.max( output.data.cpu(), 1) # pred: get the index of the max probability correct += pred.eq(y_test.data.cpu().view_as(pred)).sum() else: _, pred = torch.max(output.data, 1) correct += pred.eq(y_test.data.view_as(pred)).sum() total += y_test.size(0) Loss = test_loss / len(testloader) acc = 100 * correct / total print("Loss {}, Acc {}".format(Loss, acc)) print("-" * 10) return Loss, acc
def parse_file(filename): # open the file inputfile = open(filename) # parse the first line first_line = inputfile.readline() first_line = first_line.split() num_cells = int(first_line[0]) num_connections = int(first_line[1]) num_rows = int(first_line[2]) num_cols = int(first_line[3]) # parse the nets list_of_nets = [] for i in range(num_connections): cur_net_unparsed = inputfile.readline().split() cur_net = net.net(int(cur_net_unparsed[1]), int(cur_net_unparsed[0]) - 1) for j in range(2, int(cur_net_unparsed[0]) + 1): cur_net.add_connection(int(cur_net_unparsed[j])) # error checking, did we parse correctly? # print(len(cur_net.connections), cur_net.num_connections) assert (len(cur_net.connections) == cur_net.num_connections) list_of_nets.append(cur_net) # error checking # print(len(list_of_nets), num_cells) assert (len(list_of_nets) == num_connections) # returned the parsed information return [num_cells, num_connections, num_rows, num_cols, list_of_nets]
def main(): key_word = 'testdata' + '/' file_path1 = '/home/ruslan/prac/planogramm/' + key_word for name in os.listdir(file_path1): if name == 'else': continue print(name) image = cv2.imread(key_word + name) img = imread(key_word + name) saved = img.copy() image, image1, flag = first_try_to_detect(image, saved, name) if flag == 0: image, image1 = second_try_to_detect(img, saved, name) images = array(image) images1 = array(image1) # Подаем матрицу нейросети list_of_list_of_class, list_of_list_of_proba = net.net(images, mode=1) for ind in range(len(list_of_list_of_class)): list_of_proba = list_of_list_of_proba[ind] list_of_class = list_of_list_of_class[ind] print_class(list_of_class) maximum(list_of_proba, list_of_class)
def __init__(self, name, mapping, parent=None): portlist = dict([('OUT', gate.OUT), ('I0', gate.IN), ('I1', gate.IN), ('I2', gate.IN)]) gate.module.__init__(self, name=name, portlist=portlist, mapping=mapping, parent=parent) for i in ('n0', 'n1', 'n2'): self.netlist[i] = net.net(i, parent=self) # Add depln mode pullups self.netlist['n0'].pullup_str = 100 self.port['OUT'].netconn.pullup_str = 100 self.gatelist.extend([ NMOS("NMOS_0_u", [ self.netlist['n0'], self.netlist['n1'], self.port['I0'].netconn ], self), NMOS("NMOS_1_u", [ self.netlist['n1'], self.netlist['n2'], self.port['I1'].netconn ], self), NMOS("NMOS_2_u", [ self.netlist['n2'], self.netlist['vss'], self.port['I2'].netconn ], self), NMOS("NMOS_3_u", [ self.port['OUT'].netconn, self.netlist['vss'], self.netlist['n0'] ], self), ])
def test_random_U(net, data_size, batch_size, channel, dim, use_cuda): net.eval() print("-" * 10) print("test process") print("-" * 10) result = {} if data_size % batch_size == 0: time = data_size // batch_size else: time = data_size // batch_size + 1 for i in range(time): print('time {}/{}'.format(i + 1, time)) if i == time - 1: x_test = random_data.get_U_random_data(channel=channel, size=data_size - (time - 1) * batch_size, dim=dim) else: x_test = random_data.get_U_random_data(channel=channel, size=batch_size, dim=dim) if use_cuda: x_test = x_test.cuda() x_test = Variable(x_test) output = net(x_test) _, pred = torch.max(output.data, 1) pred = pred.view(-1) for j in pred: if j in result.keys(): result[j] += 1 else: result[j] = 0 return result
def test_net(test_loader=None, path=None, batch_size=128): #run test loop here n_batches = len(test_loader) model = torch.load(path) net = model['model'] net.load_state_dict(model['state_dict']) for par in net.parameters(): par.requires_grad = False net.eval() #writing results to spreadsheet fname = "test_pred.csv" f_out = open(fname, "w") wrt = csv.writer(f_out) net = net.cpu() #testing metrics corr_cnt = 0 total_iter = 0 for data in test_loader: [inputs, labels, snr] = data snr = snr.numpy() #inputs, labels,snr = Variable(inputs), Variable(labels), Variable(snr) pred = net(inputs.float()).numpy() pred = np.argmax(pred, axis=1) labels = np.argmax(labels.numpy(), axis=1) for s, p, l in zip(snr, pred, labels): if (p == l): corr_cnt += 1 wrt.writerow([s, p, l]) total_iter += 1 print("Test done, accr = :" + str(corr_cnt / total_iter)) f_out.close()
def train(net, dataloader, cost, optimizer, epoch, n_epochs, use_cuda): # the model of training net.train() running_loss = 0.0 print("-" * 10) print('Epoch {}/{}'.format(epoch, n_epochs)) num = 0 for item in dataloader: num += len(item) for data in item: x_train, y_train = data if use_cuda: x_train, y_train = x_train.cuda(), y_train.cuda() # change data to Variable, a wrapper of Tensor x_train, y_train = Variable(x_train), Variable(y_train) # zero the parameter gradients optimizer.zero_grad() outputs = net(x_train) loss = cost(outputs, y_train) loss.backward() # optimize the weight of this net optimizer.step() running_loss += loss.data[0] print("Loss {}".format(running_loss / len(num))) print("-" * 10)
def __init__ ( self, name, mapping, parent=None ) : portlist = dict( [("E%d"%i, gate.IN) for i in range (0,4)] + [("D%d"%i, gate.IN) for i in range (0,4)] + [("C%d"%i, gate.IN) for i in range (0,4)] + [("F%d"%i, gate.OUT) for i in range (0,4)] + [("AEB", gate.OUT), ("M", gate.IN)] ) gate.module.__init__( self, name, portlist, mapping, parent) for name in [ 'EXD', 'CM' ]: for i in range(0, 4): n = "%s%d" % (name,i) self.netlist[n] = net.net(n, parent=self) self.gatelist.extend([ XOR("EXD0gate", [self.netlist['EXD0'], self.port['E0'].netconn, self.port['D0'].netconn], self), XOR("EXD1gate", [self.netlist['EXD1'], self.port['E1'].netconn, self.port['D1'].netconn], self), XOR("EXD2gate", [self.netlist['EXD2'], self.port['E2'].netconn, self.port['D2'].netconn], self), XOR("EXD3gate", [self.netlist['EXD3'], self.port['E3'].netconn, self.port['D3'].netconn], self), OR("CM0gate", [self.netlist['CM0'], self.port['C0'].netconn, self.port['M'].netconn], self), OR("CM1gate", [self.netlist['CM1'], self.port['C1'].netconn, self.port['M'].netconn], self), OR("CM2gate", [self.netlist['CM2'], self.port['C2'].netconn, self.port['M'].netconn], self), OR("CM3gate", [self.netlist['CM3'], self.port['C3'].netconn, self.port['M'].netconn], self), XOR("F0gate", [self.port['F0'].netconn, self.netlist['EXD0'], self.netlist['CM0']], self), XOR("F1gate", [self.port['F1'].netconn, self.netlist['EXD1'], self.netlist['CM1']], self), XOR("F2gate", [self.port['F2'].netconn, self.netlist['EXD2'], self.netlist['CM2']], self), XOR("F3gate", [self.port['F3'].netconn, self.netlist['EXD3'], self.netlist['CM3']], self), AND("AEBgate", [self.port["AEB"].netconn, self.port["F0"].netconn, self.port["F1"].netconn, self.port["F2"].netconn, self.port["F3"].netconn], self)])
def __init__(self, name, mapping, parent=None): portlist = dict([("Q0", gate.OUT), ("Q1", gate.OUT), ("RSTB", gate.IN), ("PHI", gate.IN)]) gate.module.__init__(self, name=name, portlist=portlist, mapping=mapping, parent=parent) for n in ['d0', 'd1', 'q0b', 'q1b', 'd1a', 'd1b']: self.netlist[n] = net.net(n, parent=self) for i in range(0, 2): n = "n%d" % i self.netlist[n] = net.net(n, parent=self) self.gatelist.extend([ NMOS_DFF( "dff0_u", dict([('Q', self.port['Q0'].netconn), ('D', self.netlist['d0']), ('RSTB', self.port['RSTB'].netconn), ('PHI', self.port['PHI'].netconn)]), self), NMOS_INV( "inv6_u", dict([('OUT', self.netlist['d0']), ('IN', self.port['Q0'].netconn)]), self), DFF("dff1_u", [ self.port['Q1'].netconn, self.netlist['d1'], self.port['RSTB'].netconn, self.port['PHI'].netconn ], self), INV("inv4_u", [self.netlist['q0b'], self.port['Q0'].netconn], self), INV("inv5_u", [self.netlist['q1b'], self.port['Q1'].netconn], self), AND("and7_u", [ self.netlist['d1a'], self.port['Q0'].netconn, self.netlist['q1b'] ], self), AND("and8_u", [ self.netlist['d1b'], self.port['Q1'].netconn, self.netlist['q0b'] ], self), OR("or9_u", [self.netlist['d1'], self.netlist['d1a'], self.netlist['d1b']], self) ])
def wire(net_names, pullup_str=0, parent=None, charge_storage=False) : ''' convenience function for declaring nets in a gate object ''' newnets = dict() for name in net_names: newnets[name] = net.net(name, pullup_str=pullup_str, parent=parent, charge_storage=False) return newnets
def train_net(): # 参数定义 lr = 1e-1 # 学习率 epoches = 55 # 迭代次数 device = torch.device( 'cuda') if torch.cuda.is_available() else torch.device('cpu') model = net().to(device) criterion = nn.CrossEntropyLoss() # 目标函数 optimizer = optim.SGD(model.parameters(), lr=lr) # 定义优化器种类,使用随机梯度下降 data = dataPreparation() train_loader = data.train_loader # 设置训练数据 test_loader = data.test_loader # 设置测试数据 checkpoints = './checkpoints/net/' writer = SummaryWriter() accuracy_best = 0 for epoch in range(epoches): print("第%d轮训练" % (epoch + 1)) for i, (images, labels) in enumerate(tqdm(train_loader, ncols=50)): images = images.to(device) labels = labels.to(device) images = Variable(images.view(-1, 28 * 28)) labels = Variable(labels) outputs = model(images) # 计算模型输出结果 loss = criterion(outputs, labels) # 计算误差loss optimizer.zero_grad() # 在反向传播之前清除网络状态 loss.backward() # loss反向传播 optimizer.step() # 更新参数 print("epoch_" + str(epoch) + "_loss:", loss.item()) writer.add_scalar('Train_loss', loss, epoch) #第一个参数为图形名称,第二个参数为y值,第三个为x值 model.eval() with torch.no_grad(): total = 0 correct = 0 for test_images, test_labels in test_loader: test_images = test_images.to(device) test_labels = test_labels.to(device) test_images = Variable(test_images.view(-1, 28 * 28)) test_outputs = model(test_images) _, predicts = torch.max(test_outputs.data, 1) total += test_labels.size(0) correct += (predicts == test_labels).sum().numpy() accuracy = correct / total if accuracy > accuracy_best: accuracy_best = accuracy torch.save(model.state_dict(), os.path.join(checkpoints, 'best.pth')) writer.add_scalar("accuracy", accuracy, epoch) print("accuracy_best:", accuracy_best, '\n')
def __init__(self, name, mapping, parent=None): portlist = dict([('OUT', gate.OUT), ('I0', gate.IN), ('I1', gate.IN)]) gate.module.__init__(self, name=name, portlist=portlist, mapping=mapping, parent=parent) # Add depln mode pullups self.port['OUT'].netconn.pullup_str = 100 self.netlist['i0b'] = net.net('i0b', parent=self, pullup_str=100) self.netlist['i1b'] = net.net('i1b', parent=self, pullup_str=100) self.netlist['n0'] = net.net('n0', parent=self) self.netlist['n1'] = net.net('n1', parent=self) self.gatelist.extend([ UNMOS("NMOS_0_u", [ self.netlist['i0b'], self.netlist['vss'], self.port['I0'].netconn ], self), UNMOS("NMOS_1_u", [ self.netlist['i1b'], self.netlist['vss'], self.port['I1'].netconn ], self), UNMOS("NMOS_2_u", [ self.port['OUT'].netconn, self.netlist['n0'], self.netlist['i0b'] ], self), UNMOS( "NMOS_3_u", [self.netlist['n0'], self.netlist['vss'], self.netlist['i1b']], self), UNMOS("NMOS_4_u", [ self.port['OUT'].netconn, self.netlist['n1'], self.port['I0'].netconn ], self), UNMOS("NMOS_5_u", [ self.netlist['n1'], self.netlist['vss'], self.port['I1'].netconn ], self), ])
def test(): weight_root = './checkpoints/net/best.pth' device = torch.device( 'cuda') if torch.cuda.is_available() else torch.device('cpu') model = net().to(device) model.load_state_dict(torch.load(weight_root)) data = dataPreparation() test_loader = data.test_loader_final # test_loader=data.test_loader num = 0 error = 0 right = 0 # print(test_loader.dataset.data.shape) for i, (test_images, test_labels) in enumerate(test_loader): # test_images = test_images[i].to(device) # test_labels = test_labels[i].to(device) test_images = test_images.to(device) test_labels = test_labels.to(device) test_images = Variable(test_images.view(-1, 28 * 28)) test_outputs = model(test_images) _, predicts = torch.max(test_outputs.data, 1) # print("truth:", test_labels, '\t', "predict:", predicts, '\n') if test_labels == predicts: num += 1 # 显示错误50张图片 if error < 50 and test_labels != predicts: plt.figure("error") plt.subplot(5, 10, error + 1) img = test_images.numpy().reshape(28, 28) plt.imshow(img, cmap=CM.gray) plt.xticks([]) plt.yticks([]) plt.xlabel("truth:" + str(test_labels.numpy()) + " predict:" + str(predicts.numpy())) error += 1 # 显示正确50张图片 if right < 50 and test_labels == predicts: plt.figure("right") plt.subplot(5, 10, right + 1) img = test_images.numpy().reshape(28, 28) plt.imshow(img, cmap=CM.gray) plt.xticks([]) plt.yticks([]) plt.xlabel("truth:" + str(test_labels.numpy()) + " predict:" + str(predicts.numpy())) right += 1 accuracy = num / 10000 print("accuracy:", accuracy) plt.show()
def main(): #set hyperparameter at here hiddenlayerlist = [[18, 20, 25, 16, 15]] #change the number of hidden layer, and nodes in the layer ss = 1e-4 #step Size numofiter = 20000 #iterations size = 200 #input size dim = 2 #input dimension margin = 0 #change Margin at here, change this value to 0 to make the data not linear separable #generate the input and output inputdata, outputdata = generatedata(size, dim, margin) #plot to viaualize if it is 1D print("Training Data Plot: ") plt.figure(1) if dim == 1: plt.scatter(inputdata[: size // 2, 0],np.ones((size // 2, 1)), color="r") plt.scatter(inputdata[size // 2 :, 0],np.ones((size // 2, 1)), color="b") plt.legend(['Label 1', 'Label 0'], loc='upper right') elif dim == 2: plt.scatter(inputdata[: size // 2, 0],inputdata[: size // 2, 1], color="r") plt.scatter(inputdata[size // 2 :, 0],inputdata[size // 2 :, 1], color="b") plt.legend(['Label 1', 'Label 0'], loc='upper right') network = net(inputdata, outputdata, size, ss, numofiter, dim, hiddenlayerlist) network.backpropagation() output = network.forwardewithcomputedW(inputdata) #plot network computed result output = np.append(inputdata,output, axis=1) print("Network computed output: ") plt.figure(4) if dim ==1: output1 = output[output[:, -1] == 1] output2 = output[output[:, -1] == 0] plt.scatter(output1[:, 0],np.ones((np.shape(output1)[0], 1)), color="r") plt.scatter(output2[:, 0],np.ones((np.shape(output2)[0], 1)), color="b") plt.legend(['Label 1', 'Label 0'], loc='upper right') if dim ==2: output1 = output[output[:, -1] == 1] output2 = output[output[:, -1] == 0] plt.scatter(output1[:, 0], output1[:, 1], color="r") plt.scatter(output2[:, 0], output2[:, 1], color="b") plt.legend(['Label 1', 'Label 0'], loc='upper right') plt.show()
def __init__(self, options): testbench.__init__(self, options) for name in ['in0', 'in1', 'in2', 'en0', 'en1', 'en2', 'n0', 'n1']: self.netlist[name] = net.net(name) dut0 = BUFIF1( "bufif1_0_u", [self.netlist['n0'], self.netlist['in0'], self.netlist['en0']], strength=net.SUPPLY_STR) dut1 = BUFIF1( "bufif1_1_u", [self.netlist['n0'], self.netlist['in1'], self.netlist['en1']], strength=net.SUPPLY_STR) dut2 = BUFIF1( "bufif1_2_u", [self.netlist['n0'], self.netlist['in2'], self.netlist['en2']], strength=net.SUPPLY_STR) dut3 = BUF("buf_0_u", [self.netlist['n1'], self.netlist['n0']]) self.gatelist = [dut0, dut1, dut2, dut3] vector_string = ''' PI in0 PI in1 PI in2 PI en0 PI en1 PI en2 PO n0 PO n1 000 000 XX 000 001 00 000 010 00 000 011 00 000 100 00 000 101 00 000 110 00 000 111 00 100 000 XX 100 001 00 100 010 00 100 011 00 100 100 11 100 101 XX 100 110 XX 100 111 00 ''' self.events = self.read_flex_string(vector_string)
def predict(net, batch_size, test_set): test_predictions = [] for start_index in range(0, test_set.shape[0] - batch_size + 1, batch_size): #get batches X = test_set[start_index:start_index + batch_size, :-5].view( batch_size, 1, 285) y = test_set[start_index:start_index + batch_size, -5:] #forward pass outputs = net(X).view(batch_size, 5).detach() test_predictions.append(outputs) return torch.cat(test_predictions, dim=0).numpy()
def correct_photo(): files = flask.request.files images = [] mimetype = 'application/zip' uniq_name = str(uuid.uuid4()) zf = zipfile.ZipFile(f'{uniq_name}_images.zip', 'w') for name, value in files.items(): ext = str(name).split('.')[-1] if ext.lower() in ['jpg', 'jpeg', 'png']: value.save(name) images.append((name, )) processed_img = net.net(name) imageio.imwrite(name, processed_img) zf.write(name, name) logger.info(f'removing tmp: {name}') os.remove(name) elif ext.lower() in ['arw', 'dng']: value.save(name) images.append((name,)) processed_img = net.net(name) name = name.split('.')[0] + '.png' imageio.imwrite(name, processed_img) zf.write(name, name) logger.info(f'removing tmp: {name}') os.remove(name) os.remove(name.split('.')[0] + '.' + ext) logger.info(f'processing {len(images)} images') zf.close() if not is_empty(images): return Response(json.loads(json.dumps('{"filename": "' + uniq_name + '"}')), status=200, mimetype=mimetype) else: # error, return error code 400 return Response(json.dumps('{msg: "no images", code: 400}'), status=400, mimetype='application/json')
def __init__ ( self, name, mapping, parent=None ) : portlist = dict( [("A%d"%i, gate.IN) for i in range (0,4)] + [("B%d"%i, gate.IN) for i in range (0,4)] + [("S%d"%i, gate.IN) for i in range (0,4)] + [("E%d"%i, gate.OUT) for i in range (0,4)] + [("Bb%d"%i, gate.OUT) for i in range (0,4)]) gate.module.__init__( self, name, portlist, mapping, parent) for i in range(0, 4): n = "ABS3%d" % i self.netlist[n] = net.net(n, parent=self) n = "ABbS2%d" % i self.netlist[n] = net.net(n, parent=self) self.gatelist = [ INV("Bb0gate",[self.port["Bb0"].netconn, self.port["B0"].netconn], self), INV("Bb1gate",[self.port["Bb1"].netconn, self.port["B1"].netconn], self), INV("Bb2gate",[self.port["Bb2"].netconn, self.port["B2"].netconn], self), INV("Bb3gate",[self.port["Bb3"].netconn, self.port["B3"].netconn], self), AND("ABS30gate",[self.netlist["ABS30"], self.port["A0"].netconn, self.port["B0"].netconn, self.port["S3"].netconn], self), AND("ABS31gate",[self.netlist["ABS31"], self.port["A1"].netconn, self.port["B1"].netconn, self.port["S3"].netconn], self), AND("ABS32gate",[self.netlist["ABS32"], self.port["A2"].netconn, self.port["B2"].netconn, self.port["S3"].netconn], self), AND("ABS33gate",[self.netlist["ABS33"], self.port["A3"].netconn, self.port["B3"].netconn, self.port["S3"].netconn], self), AND("ABbS20gate", [self.netlist["ABbS20"], self.port["A0"].netconn, self.port["Bb0"].netconn, self.port["S2"].netconn], self), AND("ABbS21gate", [self.netlist["ABbS21"], self.port["A1"].netconn, self.port["Bb1"].netconn, self.port["S2"].netconn], self), AND("ABbS22gate", [self.netlist["ABbS22"], self.port["A2"].netconn, self.port["Bb2"].netconn, self.port["S2"].netconn], self), AND("ABbS23gate", [self.netlist["ABbS23"], self.port["A3"].netconn, self.port["Bb3"].netconn, self.port["S2"].netconn], self), NOR("E0gate", [self.port["E0"].netconn, self.netlist["ABS30"], self.netlist["ABbS20"]], self), NOR("E1gate", [self.port["E1"].netconn, self.netlist["ABS31"], self.netlist["ABbS21"]], self), NOR("E2gate", [self.port["E2"].netconn, self.netlist["ABS32"], self.netlist["ABbS22"]], self), NOR("E3gate", [self.port["E3"].netconn, self.netlist["ABS33"], self.netlist["ABbS23"]], self)]
def __init__(self, n=1, num=2, lr=1e-5, report=10, batch_size=16, img_side=2): # omino type self.n = n # number of objects self.num = num # learning rate self.lr = lr # report steps self.report = report # batch size self.batch = batch_size # image size self.img_side = img_side self.types = 2 # training steps self.steps = 5000 # iterate steps self.episodes = 50 # start to build the graph tf.reset_default_graph() # initialize a network self.network = net() # training placeholders self.input = tf.placeholder(tf.float32, [None, self.img_side, self.img_side, 1]) self.target = tf.placeholder(tf.float32, [None, self.types, self.img_side**2]) # save map generated self.maps = [] # one test image could be used self.test_img = np.reshape(np.concatenate( [np.zeros((1, 2)), np.ones((1, 2))], axis=0), newshape=[1, 2, 2, 1])
def init(self): # load the config file self.nettester_config = config() # initialize the gui self.nettester_gui = gui( self.nettester_config.config["resolution"], self.nettester_config.config["fg_color"], self.nettester_config.config["bg_color"], self.nettester_config.config["font_size_correction"], self.nettester_config.config["show_mouse_cursor"], ) # initialize the networking self.nettester_net = net() # create the buttons self.create_buttons() self.switch_to_wired() return True
def __init__ ( self, name, portlist, mapping, parent=None, strength=1, pullup_str=None, pulldown_str=None,is_a_primitive=False): self.name = name self.port = dict() self.parent = parent self.outputpins = dict() if not pulldown_str: self.pulldown_str = strength else: self.pulldown_str = pulldown_str if not pullup_str: self.pullup_str = strength else: self.pullup_str = pullup_str self.strength = min( [self.pulldown_str, self.pullup_str] ) self.is_a_primitive = is_a_primitive # Map each port to a simulation net and update the simulation # net's fanin and fanout lists appropriately for portname in mapping: n = mapping[portname] if portname in portlist : direction = portlist[portname] p = pin.pin(name=portname, parent=self, netconn=n, direction=direction ) self.port[portname] = p if direction == IN or direction == INOUT : #n.all_fanout.add( p ) n.all_fanout.add( self ) # point at the gate rather than a pin if is_a_primitive: # n.prim_fanout.add( p ) n.prim_fanout.add( self ) # point at the gate rather than a pin if self.simulate not in n.efanout: n.efanout.append(self.simulate) if direction == OUT or direction == INOUT : self.outputpins[portname] = p n.all_fanin.add(p) n.all_gate_fanin.add(self) # all drivers default to drive 'X' on startup if is_a_primitive: n.drivers.append(p) for portname in portlist: if not portname in self.port: self.port[portname] = pin.pin(name=portname, parent=self, netconn=net.net('unconnected'))
def warpper(*args, **kwargs): self.net = net(1, ip, port) funcName, msg = function.__name__, "" func = (funcName, args, kwargs) self.net.send('RF', func) while 1: recived = self.net.recv() msg = recived[0] data = recived[1] msg = msg.replace( ' ', '') # to remove the white space in the msg if msg == "end": return data if msg == "SF": data = func self.net.msgToFunc[msg](data)
def train(sess): logits = net.net(images_batch, num_fully_connected_layers=1) # Initialize all variables sess.run(tf.global_variables_initializer()) labels = tf.cast(labels_batch, dtype=tf.float32) cost = tf.reduce_mean(tf.squared_difference(logits, labels)) # Initialize all variables sess.run(tf.global_variables_initializer()) train_op = tf.train.AdamOptimizer(FLAGS.LEARNING_RATE).minimize(cost) # Initialize all variables sess.run(tf.global_variables_initializer()) training_epochs = 10 # Training cycle for epoch in range(training_epochs): avg_cost = 0. total_batch = int(n_samples / FLAGS.BATCH_SIZE) # Loop over all batches for i in range(total_batch): # batch_xs, _ = mnist.train.next_batch(batch_size) # batch_xs = images_batch.eval() # Fit training using batch data # cost = vae.partial_fit(batch_xs) _, my_cost = sess.run([train_op, cost]) print("Epoch: (" + str(epoch) + "/" + str(training_epochs) + "); i: (" + str(i) + "/" + str(total_batch) + "). Current cost: " + float_to_str(my_cost) + "") # Compute average loss avg_cost += cost / n_samples * FLAGS.BATCH_SIZE
def train(net, dataloader, cost, optimizer, epoch, n_epochs, use_cuda): # the model of training net.train() running_loss = 0.0 correct = 0.0 total = 0 print('Epoch {}/{}'.format(epoch, n_epochs)) for data in dataloader: x_train, y_train = data if use_cuda: x_train, y_train = x_train.cuda(), y_train.cuda() # change data to Variable, a wrapper of Tensor x_train, y_train = Variable(x_train), Variable(y_train) # zero the parameter gradients optimizer.zero_grad() outputs = net(x_train) loss = cost(outputs, y_train) loss.backward() # optimize the weight of this net optimizer.step() running_loss += loss.data[0] if use_cuda: _, pred = torch.max( outputs.data.cpu(), 1) # pred: get the index of the max probability correct += pred.eq(y_train.data.cpu().view_as(pred)).sum() else: _, pred = torch.max(outputs.data, 1) correct += pred.eq(y_train.data.view_as(pred)).sum() total += y_train.size(0) Loss = running_loss / len(dataloader) train_acc = 100 * correct / total print("Loss {}, acc {}".format(Loss, train_acc)) print("-" * 10) return Loss, train_acc
def mainNet(self): host = socket.gethostbyname(socket.gethostname()) self.net = net(0, host, 1705) stdout = output(self.net) stderr = error(self.net) sys.stdout = stdout sys.stderr = stderr while 1: msg, data = self.net.recv() msg = msg.replace(' ', '') #remove white spaces from the message if len(msg): end = self.net.msgToFunc[msg](data) if end: break self.net.socket.close() self.net.socket.close()
def train_net(train_loader=None, net=None, batch_size=128, n_epochs=5, learning_rate=0.001, saved_model=None, fname=None): #Print all of the hyperparameters of the training iteration: print("===== HYPERPARAMETERS =====") print("batch_size=", batch_size) print("epochs=", n_epochs) print("learning_rate=", learning_rate) print("=" * 30) #Get training and test data n_batches = len(train_loader) #Create our loss and optimizer functions loss, optimizer = get_loss_optimizer(net, learning_rate) #Time for printing training_start_time = time.time() f_out = open(fname, "w") wrt = csv.writer(f_out) total_train_loss = 0 scheduler = StepLR(optimizer, step_size=250, gamma=0.1) net = net.float() net = net.to('cuda') #Loop for n_epochs for epoch in range(n_epochs): running_loss = 0.0 print_every = n_batches // 10 start_time = time.time() wrt.writerow([epoch, total_train_loss]) total_train_loss = 0 if (((epoch + 1) % 250) == 0): checkpoint = { 'model': net, 'state_dict': net.state_dict(), 'optimizer': optimizer.state_dict() } file_name = 'checkpoint.pt' torch.save(checkpoint, file_name) i = 0 for data in train_loader: [inputs, labels, snr] = data #print(inputs.shape) #Wrap them in a Variable object inputs, labels, snr = Variable(inputs).to('cuda'), Variable( labels).to('cuda'), Variable(snr).to('cuda') #inputs,labels,snr = Variable(inputs), Variable(labels), Variable(snr) #Set the parameter gradients to zero optimizer.zero_grad() #Forward pass, backward pass, optimize outputs = net(inputs.float()) labels = labels.squeeze_().cpu() loss_size = loss(outputs.cpu(), np.argmax(labels, axis=1)) #loss_size = loss(outputs, np.argmax(labels,axis=1)) loss_size.backward() optimizer.step() #Print statistics running_loss += loss_size.data total_train_loss += loss_size.data #Print loss from every 10% (then resets to 0) of a batch of an epoch if (i + 1) % (print_every + 1) == 0: print("Epoch {}, {:d}% \t train_loss: {:.4f} took: {:.2f}s". format(epoch + 1, int(100 * (i + 1) / n_batches), total_train_loss / print_every, time.time() - start_time)) #Reset running loss and time running_loss = 0.0 start_time = time.time() i += 1 scheduler.step() print("Training finished, took {:.2f}s".format(time.time() - training_start_time)) final = { 'model': net, 'state_dict': net.state_dict(), 'optimizer': optimizer.state_dict() } torch.save(final, saved_model) f_out.close()
filename, infile, alg, query = argv try: algType = ["enum", "elim"].index(alg) except ValueError: exit("Unknown algorithm; please use enum or elim") try: parts = ( lambda x: x.strip("P").strip("()"))(# remove the leading P for probability, then the parens (lambda x: x[0] if len(x) is 1 else x[1])(# remove the unquoted part (lambda x: x.split('"'))(# allow extra quotes query ) ) ).split("|") event = parts[0] evidence = {} if len(parts) > 1: # allow empty conditionals for term in parts[1].split(","): if term: name, value = tuple(term.split("=")) evidence[name] = value except Exception: exit('Could not parse query string. Make sure it is of this form, INCLUDING quotes: "P(C|A=f,E=t)" or "P(C)"') bayes = net(infile) original = dict(evidence) output.display(bayes.probability(event, evidence, algType), event, original)