def dgen(batch_size=2): while 1: p, q, a, an = [], [], [], [] for i in range(batch_size): r = random.randint(0, size) train_ = train(r) p.append(train_[1].tolist()) q.append(train_[2].tolist()) # a_t = [] # for ii in train_[0]: # for iii in ii: # a_t.extend(iii) # a.append(a_t) a_t = [] for ii in train_[0].tolist(): a_t.extend(ii) a.append(a_t) an.append(train_[3].tolist()) p = np.array(p) q = np.array(q) a = np.array(a) an = np.array(an) print(p.shape, q.shape, a.shape, an.shape) yield ([p, q, a], [a, an])
def main(): hook = sy.TorchHook(torch) squad = WebsocketClientWorker(id=1, host='localhost', port=7171, hook=hook, verbose=True) message = data message_ptr = message.send(squad) print(message_ptr) print('sent model data. now squad has %d objects' % (message_ptr.location.objects_count_remote())) # get squad updated model model = nn.Linear(1, 1) train(model)
def add(self): l = login() l.get() axs = raw_input("Access Spec of new user :"******"Access not part of allowed set" return elif axs == 'student': #s = student() l.add(axs) nam = raw_input("Enter Student's name:") self.cur.execute('''insert into student values (?,?); ''',(nam.decode(),l.uname)) data.train(l.uname) self.con.commit() else: #s = teacher() nam = raw_input("Enter teacher's name:") sub = raw_input("Enter teacher's subject:") l.add(axs) self.cur.execute('''insert into teacher values (?,?,?); ''',(nam.decode(),l.uname,sub.decode())) self.con.commit()
def main(): paddle.init(use_gpu=True, trainer_count=1) img = paddle.layer.data(name='img', type=paddle.data_type.dense_vector(784)) label = paddle.layer.data(name='label', type=paddle.data_type.integer_value(10)) predict = letnet_5(img) cost = paddle.layer.classification_cost(input=predict, label=label) if os.path.exists(PARAMETERS_TAR): with open(PARAMETERS_TAR, 'r') as f: parameters = paddle.parameters.Parameters.from_tar(f) else: parameters = paddle.parameters.create(cost) optimizer = paddle.optimizer.Momentum( learning_rate=0.1 / 128, momentum=0.9, regularization=paddle.optimizer.L2Regularization(rate=0.0001)) trainer = paddle.trainer.SGD(cost=cost, parameters=parameters, update_equation=optimizer) def event_handler(evt): if isinstance(evt, paddle.event.EndPass): print 'Pass id: %d, %s' % (evt.pass_id, evt.metrics) trainer.train(reader=paddle.batch(paddle.reader.shuffle(dataset.train(), buf_size=8192), batch_size=64), event_handler=event_handler, num_passes=30) with open(PARAMETERS_TAR, 'w') as f: trainer.save_parameter_to_tar(f) test_reader = dataset.test()() test_list = [] for img in test_reader: test_list.append(img) labels = paddle.infer(output_layer=predict, parameters=parameters, input=test_list) labels = np.argmax(labels, axis=1) dataset.save_result2csv('./result.csv', labels) print 'training end'
def main(FLAGS): paddle.enable_static() if FLAGS.static else None device = paddle.set_device("gpu" if FLAGS.use_gpu else "cpu") # yapf: disable inputs = [ Input([None,1,48,384], "float32", name="pixel"), Input([None, None], "int64", name="label_in"), ] labels = [ Input([None, None], "int64", name="label_out"), Input([None, None], "float32", name="mask"), ] # yapf: enable model = paddle.Model( Seq2SeqAttModel( encoder_size=FLAGS.encoder_size, decoder_size=FLAGS.decoder_size, emb_dim=FLAGS.embedding_dim, num_classes=FLAGS.num_classes), inputs, labels) lr = FLAGS.lr if FLAGS.lr_decay_strategy == "piecewise_decay": learning_rate = fluid.layers.piecewise_decay( [200000, 250000], [lr, lr * 0.1, lr * 0.01]) else: learning_rate = lr grad_clip = fluid.clip.GradientClipByGlobalNorm(FLAGS.gradient_clip) optimizer = fluid.optimizer.Adam( learning_rate=learning_rate, parameter_list=model.parameters(), grad_clip=grad_clip) model.prepare(optimizer, WeightCrossEntropy(), SeqAccuracy()) train_dataset = data.train() train_collate_fn = BatchCompose( [data.Resize(), data.Normalize(), data.PadTarget()]) train_sampler = data.BatchSampler( train_dataset, batch_size=FLAGS.batch_size, shuffle=True) train_loader = paddle.io.DataLoader( train_dataset, batch_sampler=train_sampler, places=device, num_workers=FLAGS.num_workers, return_list=True, collate_fn=train_collate_fn) test_dataset = data.test() test_collate_fn = BatchCompose( [data.Resize(), data.Normalize(), data.PadTarget()]) test_sampler = data.BatchSampler( test_dataset, batch_size=FLAGS.batch_size, drop_last=False, shuffle=False) test_loader = paddle.io.DataLoader( test_dataset, batch_sampler=test_sampler, places=device, num_workers=0, return_list=True, collate_fn=test_collate_fn) model.fit(train_data=train_loader, eval_data=test_loader, epochs=FLAGS.epoch, save_dir=FLAGS.checkpoint_path, callbacks=[LoggerCallBack(10, 2, FLAGS.batch_size)])
reps, nPlanes, residual_blocks=False, downsample=[2, 2])).add(scn.BatchNormReLU(m)).add( scn.OutputLayer(dimension)) self.linear = nn.Linear(m, data.nClassesTotal) def forward(self, x): x = self.sparseModel(x) x = self.linear(x) return x model = Model() print(model) trainIterator = data.train() validIterator = data.valid() criterion = nn.CrossEntropyLoss() p = {} p['n_epochs'] = 100 p['initial_lr'] = 1e-1 p['lr_decay'] = 4e-2 p['weight_decay'] = 1e-4 p['momentum'] = 0.9 p['check_point'] = False p['use_cuda'] = torch.cuda.is_available() dtype = 'torch.cuda.FloatTensor' if p['use_cuda'] else 'torch.FloatTensor' dtypei = 'torch.cuda.LongTensor' if p['use_cuda'] else 'torch.LongTensor' if p['use_cuda']: model.cuda()
import random from skimage.io import imread, imshow from skimage.transform import resize import matplotlib.pyplot as plt from tqdm import tqdm np.random.seed = 42 IMG_WIDTH = 128 IMG_HEIGHT = 128 IMG_CHANNELS = 3 ################################# X_train, Y_train = data.train(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS) X_test = data.test(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS) ################################# model = arch.architecture(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS) print(model.summary()) ################################ #Modelcheckpoint checkpointer = tf.keras.callbacks.ModelCheckpoint('model_for_nuclei.h5', verbose=1, save_best_only=True) callbacks = [