def finderFunction(boroughChoice): # print(MyData()) TheData = MyData() boroughNameList = [] for datas in TheData: if datas['borough'] == boroughChoice: boroughNameList.append(datas['animalname']) #print(boroughNameList) return most_common(boroughNameList)
#上色的rgb值 back = [0,0,0]#黑色 stalk = [0 ,92,230]#蓝色 twig = [0,255,0]#绿色 grain = [128,128,0]#黄褐色 grain2 = [0,128,0] whit = [255,255,255] zi = [128,0,255] COLOR_DICT = np.array([back,zi,twig,stalk,grain,grain2,whit]) num_class=5 #数据路径 images = r'E:\RandomTasks\Dlinknet\dataset\train\images' mask = r'E:\RandomTasks\Dlinknet\dataset\train\labels' voc_val = MyData(images,mask) batchsize = 16#计算批次大小 train_load = Data.DataLoader( voc_val, batch_size=batchsize, shuffle=True) NAME = 'DinkNet34_class8_xiaomai'#数据模型 modefiles = 'weights/'+NAME+'.th' write = SummaryWriter('weights')#可视化 loss = nn.NLLLoss() #loss = nn.CrossEntropyLoss() solver = MyFrame(DinkNet34, loss, 0.0003)#网络,损失函数,以及学习率 if os.path.exists(modefiles): solver.load(modefiles)
def __addToSet__(self, filepath, occ): for item in self.list: if item.abspath == filepath: item.brPonavljanja = item.brPonavljanja + occ return self.list.append(MyData(filepath, occ))
args = parse.parse_args() args.cuda = not args.no_cuda and torch.cuda.is_available() if args.cuda: torch.cuda.manual_seed(1) base_lr = args.lr model = MobileNetV1(2, 0.75) if args.cuda: model.cuda() cudnn.benchmark = True transform = transforms.Compose([ transforms.Resize((160, 160)), transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) ]) train_dataset = MyData(args.train_data, transforms=transform) print(args.batch, len(train_dataset)) batch = args.batch trainloader = DataLoader(train_dataset, batch_size=batch, shuffle=True, num_workers=2, collate_fn=collate_fn) #test_dataset=MyData(args.test_data) #testloader=DataLoader(test_dataset,batch_size=args.batch,shuffle=False,num_workers=4,collate_fn=collate_fn) optimize = torch.optim.Adam([{ 'params': model.parameters() }], lr=args.lr, betas=(args.beta1, args.beta2)) logs = open('logs.txt', 'a+')
transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), ]) ##判断gpu是否可用并生成随机种子 args.cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) model = Classification(2) if args.cuda: model.cuda() cudnn.benchmark = True batch_size = args.batch ##构建数据迭代器 训练 dataset = MyData(args.datas, transforms=normalize) valid = MyData(args.test, transforms=normalize) dataloader = DataLoader(dataset, shuffle=True, batch_size=batch_size, num_workers=2, collate_fn=collate_fn) valid_dataloader = DataLoader(valid, shuffle=True, batch_size=batch_size, num_workers=2, collate_fn=collate_fn) ##定义优化器 optimizer = torch.optim.Adam([{ 'params': model.parameters() }],
def main(): input_lang, output_lang, pairs, data1, data2 = read_langs("eng", "fra", True) input_tensor = [[input_lang.word2index[s] for s in es.split(' ')] for es in data1] target_tensor = [[output_lang.word2index[s] for s in es.split(' ')] for es in data2] max_length_inp, max_length_tar = max_length(input_tensor), max_length(target_tensor) input_tensor = [pad_sequences(x, max_length_inp) for x in input_tensor] target_tensor = [pad_sequences(x, max_length_tar) for x in target_tensor] print(len(target_tensor)) input_tensor_train, input_tensor_val, target_tensor_train, target_tensor_val = train_test_split(input_tensor, target_tensor, test_size=0.2) # Show length print(len(input_tensor_train), len(target_tensor_train), len(input_tensor_val), len(target_tensor_val)) BUFFER_SIZE = len(input_tensor_train) BATCH_SIZE = 64 N_BATCH = BUFFER_SIZE // BATCH_SIZE embedding_dim = 256 units = 1024 vocab_inp_size = len(input_lang.word2index) vocab_tar_size = len(output_lang.word2index) train_dataset = MyData(input_tensor_train, target_tensor_train) val_dataset = MyData(input_tensor_val, target_tensor_val) dataset = DataLoader(train_dataset, batch_size=BATCH_SIZE, drop_last=True, shuffle=True) device = torch.device("cpu") encoder = Encoder(vocab_inp_size, embedding_dim, units, BATCH_SIZE) decoder = Decoder(vocab_tar_size, embedding_dim, units, units, BATCH_SIZE) encoder.to(device) decoder.to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(list(encoder.parameters()) + list(decoder.parameters()), lr=0.001) EPOCHS = 10 for epoch in range(EPOCHS): start = time() encoder.train() decoder.train() total_loss = 0 for (batch, (inp, targ, inp_len)) in enumerate(dataset): loss = 0 xs, ys, lens = sort_batch(inp, targ, inp_len) enc_output, enc_hidden = encoder(xs.to(device), lens, device) dec_hidden = enc_hidden dec_input = torch.tensor([[output_lang.word2index['<sos>']]] * BATCH_SIZE) for t in range(1, ys.size(1)): predictions, dec_hidden, _ = decoder(dec_input.to(device), dec_hidden.to(device), enc_output.to(device)) loss += loss_function(criterion, ys[:, t].to(device), predictions.to(device)) # loss += loss_ dec_input = ys[:, t].unsqueeze(1) batch_loss = (loss / int(ys.size(1))) total_loss += batch_loss optimizer.zero_grad() loss.backward() ### UPDATE MODEL PARAMETERS optimizer.step() if batch % 100 == 0: print('Epoch {} Batch {} Loss {:.4f}'.format(epoch + 1, batch, batch_loss.detach().item())) ### TODO: Save checkpoint for model print('Epoch {} Loss {:.4f}'.format(epoch + 1, total_loss / N_BATCH)) print('Time taken for 1 epoch {} sec\n'.format(time.time() - start))
# A very simple Flask Hello World app for you to get started with... from flask import Flask, render_template, request from data import MyData app = Flask(__name__) theData = MyData() @app.route('/') def hello_world(): return 'Hello from Meme World!, Dabbin on the haters' @app.route('/nana') def nan(): return 'I\'m a bonana' @app.route('/home') def rend_home(): return render_template('index.html') @app.route('/about') def about(): return render_template('about.html') @app.route('/data')
parse.add_argument('--batch', type=int, default=32, help='') parse.add_argument('--data', type=str, default='./test_set/test_set/', help='') parse.add_argument('--no_cuda', action='store_true', default=False, help='') args = parse.parse_args() args.cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(1) if args.cuda: torch.cuda.manual_seed(1) cudnn.benchmark = True transform = transforms.Compose([ transforms.Resize((64, 64)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) dataset = MyData(args.data, transform) dataloader = DataLoader(dataset, batch_size=args.batch, shuffle=False, num_workers=4, collate_fn=collate_fn) for f in os.listdir(args.models): model = Classification(2, False) model.load_state_dict(torch.load(args.models + f)['models']) model.eval() if args.cuda: model.cuda() cnt = 0.0 for i, (image, label) in enumerate(dataloader): image = Variable(image.cuda(), requires_grad=False) output = model(image, None)