def __init__(self, enable_controller=[0, 3, 4]): self.num_of_actions = len(enable_controller) self.enable_controller = enable_controller # Default setting : "Pong" print "Initializing DQN..." print "CUDA init" cuda.init() print "Model Building" self.model = FunctionSet( l1=F.Convolution2D(4, 16, ksize=8, stride=4, wscale=np.sqrt(2)), l2=F.Convolution2D(16, 32, ksize=4, stride=2, wscale=np.sqrt(2)), l3=F.Linear(2592, 256), q_value=F.Linear(256, self.num_of_actions, initialW=np.zeros((self.num_of_actions, 256), dtype=np.float32)) ).to_gpu() print "Initizlizing Optimizer" self.optimizer = optimizers.RMSpropGraves(lr=0.0002, alpha=0.3, momentum=0.2) self.optimizer.setup(self.model.collect_parameters()) # History Data : D=[s, a, r, s_dash, end_episode_flag] self.D = [np.zeros((self.data_size, 4, 84, 84), dtype=np.uint8), np.zeros(self.data_size, dtype=np.uint8), np.zeros((self.data_size, 1), dtype=np.int8), np.zeros((self.data_size, 4, 84, 84), dtype=np.uint8), np.zeros((self.data_size, 1), dtype=np.bool)]
def main(): if params.gpu_flag is not False: cuda.init(params.gpu_flag) print 'fetching data ...' fetcher = cifar(norm=False) bo = BO(train_model, {'wscale1' : (-5, 0), 'wscale2' : (-5, 0), 'wscale3' : (-5, 0), 'wscale4' : (-5, 0), 'wscale5' : (-5, 0), 'lr' : (-4, -2), 'batchsize' : (30, 300), 'momentum' : (0.5, 1.0), 'decay' : (-4, -2) }) """ bo.explore({'wscale1' : [-4], 'wscale2' : [-2], 'wscale3' : [-2], 'wscale4' : [-1], 'wscale5' : [-1], 'lr' : [-3], 'batchsize' : [100], 'momentum' : [0.9], 'decay' : [-3] }) """ bo.add_f_args('fetcher', fetcher) bo.maximize(init_points=params.opt_init_points, n_iter=params.opt_iter) print bo.res['max']
def __init__(self, enable_controller=[0, 3, 4]): self.num_of_actions = len(enable_controller) self.enable_controller = enable_controller # Default setting : "Pong" print "Initializing DQN..." print "CUDA init" cuda.init() print "Model Building" self.model = FunctionSet( l1=F.Convolution2D(4, 32, ksize=8, stride=4, nobias=False, wscale=np.sqrt(2)), l2=F.Convolution2D(32, 64, ksize=4, stride=2, nobias=False, wscale=np.sqrt(2)), l3=F.Convolution2D(64, 64, ksize=3, stride=1, nobias=False, wscale=np.sqrt(2)), l4=F.Linear(3136, 512, wscale=np.sqrt(2)), q_value=F.Linear(512, self.num_of_actions, initialW=np.zeros((self.num_of_actions, 512), dtype=np.float32)) ).to_gpu() self.model_target = copy.deepcopy(self.model) print "Initizlizing Optimizer" self.optimizer = optimizers.RMSpropGraves(lr=0.00025, alpha=0.95, momentum=0.95, eps=0.0001) self.optimizer.setup(self.model.collect_parameters()) # History Data : D=[s, a, r, s_dash, end_episode_flag] self.D = [np.zeros((self.data_size, 4, 84, 84), dtype=np.uint8), np.zeros(self.data_size, dtype=np.uint8), np.zeros((self.data_size, 1), dtype=np.int8), np.zeros((self.data_size, 4, 84, 84), dtype=np.uint8), np.zeros((self.data_size, 1), dtype=np.bool)]
def main(): if P.use_mean_var: conv6_output = 126 else: conv6_output = 128 if P.model_name is None: model = FunctionSet( conv1 = F.Convolution2D( 1, 128, 3, stride=1), conv2 = F.Convolution2D(128, 128, 3, stride=1), conv3 = F.Convolution2D(128, 128, 3, stride=1), conv4 = F.Convolution2D(128, 128, 3, stride=1), conv5 = F.Convolution2D(128, 128, 3, stride=1), conv6 = F.Convolution2D(128, conv6_output, 3, stride=1), conv7 = F.Convolution2D(128, 128, 1, stride=1), conv8 = F.Convolution2D(128, 1, 1, stride=1) ) if P.gpu >= 0: cuda.init(P.gpu) model.to_gpu() else: if P.gpu >= 0: cuda.init(P.gpu) model = pickle.load(open(os.path.join(P.model_dir, P.model_name), 'rb')) optimizer = optimizers.MomentumSGD(lr=P.lr, momentum=P.momentum) optimizer.setup(model.collect_parameters()) train(model, optimizer) return
def __init__(self, hidden, action_count): cuda.init() self.hidden = hidden self.action_count = action_count super(Q, self).__init__( l1=L.Linear(self.D, hidden, wscale=np.sqrt(hidden)).to_gpu(), l2=L.Linear(hidden, hidden, wscale=np.sqrt(hidden)).to_gpu(), l3=L.Linear(hidden, action_count, wscale=np.sqrt(action_count)).to_gpu() )
def create_model(self, input_size, output_size): self.model = chainer.FunctionSet( l1=Function.Linear(input_size, self.layer1), l2=Function.Linear(self.layer1, self.layer2), l3=Function.Linear(self.layer2, output_size), ) if self.cuda: print "change cuda mode" cuda.init() self.model.to_gpu()
def main(): if params.gpu_flag is not False: cuda.init(params.gpu_flag) if params.model_name is False: model = init_model() else: model = load_model(params.model_name) optimizer = init_optimizer(model) print 'fetching data ...' fetcher = cifar(norm=False) print 'done' train_and_val(model, optimizer, fetcher)
def main(): args = parse_args() trace('making vocabulary ...') vocab, num_lines, num_words = make_vocab(args.corpus, args.vocab) trace('initializing CUDA ...') cuda.init() trace('start training ...') model = make_rnnlm_model(args.vocab, args.embed, args.hidden) for epoch in range(args.epoch): trace('epoch %d/%d: ' % (epoch + 1, args.epoch)) log_ppl = 0.0 trained = 0 opt = optimizers.SGD() opt.setup(model) for batch in generate_batch(args.corpus, args.minibatch): batch = [[vocab[x] for x in words] for words in batch] K = len(batch) L = len(batch[0]) - 1 opt.zero_grads() s_h = zeros((K, args.hidden)) for l in range(L): s_x = make_var([batch[k][l] for k in range(K)], dtype=np.int32) s_t = make_var([batch[k][l + 1] for k in range(K)], dtype=np.int32) s_e = functions.tanh(model.w_xe(s_x)) s_h = functions.tanh(model.w_eh(s_e) + model.w_hh(s_h)) s_y = model.w_hy(s_h) loss = functions.softmax_cross_entropy(s_y, s_t) loss.backward() log_ppl += get_data(loss).reshape(()) * K opt.update() trained += K trace(' %d/%d' % (trained, num_lines)) log_ppl /= float(num_words) trace(' log(PPL) = %.10f' % log_ppl) trace(' PPL = %.10f' % math.exp(log_ppl)) trace(' writing model ...') save_rnnlm_model(args.model + '.%d' % (epoch + 1), args.vocab, args.embed, args.hidden, vocab, model) trace('training finished.')
def __init__(self, model, optimizer, dropout_ratio, corruption_level, gpu): self.model = model #self.layers = [] self.dropout_ratio = dropout_ratio self.corruption_level = corruption_level self.optimizer = optimizer self.optimizer.setup(self.model.collect_parameters()) self.rng = np.random.RandomState(1) self.gpu = gpu if gpu>=0: cuda.init(gpu) model.to_gpu()
def _layer_setup(self): # Setup chainer layers for NN. layers = {} # Encoding Steps encode_layer_pairs = [(self.img_len, self.encode_sizes[0])] encode_layer_pairs += zip(self.encode_sizes[:-1], self.encode_sizes[1:]) encode_layer_pairs += [(self.encode_sizes[-1], self.latent_dim * 2)] for i, (n_in, n_out) in enumerate(encode_layer_pairs): layers["encode_%i" % i] = F.Linear(n_in, n_out) # Decoding Steps decode_layer_pairs = [(self.latent_dim, self.decode_sizes[0])] decode_layer_pairs += zip(self.decode_sizes[:-1], self.decode_sizes[1:]) decode_layer_pairs += [(self.decode_sizes[-1], self.img_len)] for i, (n_in, n_out) in enumerate(decode_layer_pairs): layers["decode_%i" % i] = F.Linear(n_in, n_out) model = chainer.FunctionSet(**layers) if self.flag_gpu: cuda.init() model.to_gpu() return model
def Init(self): TFunctionApprox.Init(self) L= self.Locate if self.Params['nn_data_x'] != None: self.DataX= np.array(pickle.load(open(L(self.Params['nn_data_x']), 'rb')), np.float32) else: self.DataX= np.array([],np.float32) if self.Params['nn_data_y'] != None: self.DataY= np.array(pickle.load(open(L(self.Params['nn_data_y']), 'rb')), np.float32) else: self.DataY= np.array([],np.float32) self.CreateNNs() if self.Params['nn_params'] != None: #self.model.copy_parameters_from(map(lambda e:np.array(e,np.float32),self.Params['nn_params'])) self.model.copy_parameters_from(map(lambda e:np.array(e,np.float32),pickle.load(open(L(self.Params['nn_params']), 'rb')) )) self.is_predictable= True else: if self.Options['init_bias_randomly']: self.InitBias(m='mean') if self.Params['nn_params_err'] != None: #self.model_err.copy_parameters_from(map(lambda e:np.array(e,np.float32),self.Params['nn_params_err'])) self.model_err.copy_parameters_from(map(lambda e:np.array(e,np.float32),pickle.load(open(L(self.Params['nn_params_err']), 'rb')) )) else: if self.Options['init_bias_randomly']: self.InitBias(m='error') if self.Options['gpu'] >= 0: cuda.init(self.Options['gpu']) self.model.to_gpu() self.model_err.to_gpu() self.optimizer= optimizers.AdaDelta(rho=self.Options['AdaDelta_rho']) self.optimizer.setup(self.model.collect_parameters()) self.optimizer_err= optimizers.AdaDelta(rho=IfNone(self.Options['AdaDelta_rho_err'], self.Options['AdaDelta_rho'])) self.optimizer_err.setup(self.model_err.collect_parameters())
def __init__(self, epsilon=1.0, frames_per_action=4): super(ChainerAgent, self).__init__() cuda.init() self.epsilon = epsilon self.gamma = 0.99 self.iterations = 0 self.model = FunctionSet( l1 = F.Linear(9 * frames_per_action, 256), l2 = F.Linear(256, 256), l3 = F.Linear(256, 256), l4 = F.Linear(256, 2), ).to_gpu() self.optimizer = optimizers.RMSprop(lr=1e-5) self.optimizer.setup(self.model) self.update_target() self.num_frames = 0 self.frames_per_action = frames_per_action self.prev_reward = 0.0 self.history = ChainHistory(state_len=(9 * frames_per_action))
def fit(self, x_data, y_data): self.n_samples = x_data.shape[0] self.n_features = x_data.shape[1] self.converge = False if self.gpu >= 0: cuda.init() self.setup_network(self.n_features) if self.gpu >= 0: self.network.to_gpu() self.setup_optimizer() score = 0.0 prev_time = time.time() batch_num = self.n_samples / self.batch_size for epoch in xrange(self.epochs): if not self.converge: for i in xrange(batch_num): x_batch, y_batch = self.make_batch(x_data, y_data, i) if self.gpu >= 0: x = Variable(cuda.to_gpu(x_batch)) t = Variable(cuda.to_gpu(y_batch)) else: x = Variable(x_batch) t = Variable(y_batch) loss = self.forward_train(x, t) self.fit_update(loss, i) if (i % batch_num) == 0: self.fit_report(epoch, loss, score) elapsed = time.time() - prev_time print "{1} sec ({2} batch/sec) \n{0}\n".format(self, elapsed, batch_num / elapsed) return self
def get_model_optimizer(result_dir, args): model_fn = os.path.basename(args.model) model_name = model_fn.split('.')[0] module = imp.load_source(model_fn.split('.')[0], args.model) Net = getattr(module, model_name) dst = '%s/%s' % (result_dir, model_fn) if not os.path.exists(dst): shutil.copy(args.model, dst) dst = '%s/%s' % (result_dir, os.path.basename(__file__)) if not os.path.exists(dst): shutil.copy(__file__, dst) # prepare model model = Net() if args.restart_from is not None: if args.gpu >= 0: cuda.init(args.gpu) model = pickle.load(open(args.restart_from, 'rb')) if args.gpu >= 0: cuda.init(args.gpu) model.to_gpu() # prepare optimizer if args.opt == 'AdaGrad': optimizer = optimizers.AdaGrad(lr=0.0005) elif args.opt == 'MomentumSGD': optimizer = optimizers.MomentumSGD(lr=0.0005, momentum=0.9) elif args.opt == 'Adam': optimizer = optimizers.Adam() else: raise Exception('No optimizer is selected') optimizer.setup(model.collect_parameters()) return model, optimizer
def __init__(self, frames_per_action=4): super(ConvQAgent, self).__init__() cuda.init() self.epsilon = 1.0 self.gamma = 0.99 self.iterations = 0 self.model = FunctionSet( l1 = F.Convolution2D(frames_per_action, 32, ksize=8, stride=4, nobias=False, wscale=np.sqrt(2)), l2 = F.Convolution2D(32, 64, ksize=4, stride=2, nobias=False, wscale=np.sqrt(2)), l3 = F.Convolution2D(64, 64, ksize=3, stride=1, nobias=False, wscale=np.sqrt(2)), l4 = F.Linear(64 * 7 * 7, 512), l5 = F.Linear(512, 2) ).to_gpu() self.optimizer = optimizers.RMSprop(lr=1e-5) self.optimizer.setup(self.model) self.update_target() self.num_frames = 0 self.frames_per_action = frames_per_action self.prev_reward = 0.0 self.history = ConvHistory((frames_per_action, 84, 84))
def get_img_label(img, model_type, model, mean, gpu): print('Loading Caffe model file %s...' % args.model, file=sys.stderr) func = caffe.CaffeFunction(args.model) print('Loaded', file=sys.stderr) if args.gpu >= 0: cuda.init(args.gpu) func.to_gpu() if args.model_type == 'alexnet' or args.model_type == 'caffenet': in_size = 227 mean_image = np.load(args.mean) def forward(x, t): y, = func(inputs={'data': x}, outputs=['fc8'], train=False) return F.softmax_cross_entropy(y, t), F.accuracy(y, t) def predict(x): y, = func(inputs={'data': x}, outputs=['fc8'], train=False) return F.softmax(y) elif args.model_type == 'googlenet': in_size = 224 # Constant mean over spatial pixels mean_image = np.ndarray((3, 256, 256), dtype=np.float32) mean_image[0] = 104 mean_image[1] = 117 mean_image[2] = 123 def forward(x, t): y, = func(inputs={'data': x}, outputs=['loss3/classifier'], disable=['loss1/ave_pool', 'loss2/ave_pool'], train=False) return F.softmax_cross_entropy(y, t), F.accuracy(y, t) def predict(x): y, = func(inputs={'data': x}, outputs=['loss3/classifier'], disable=['loss1/ave_pool', 'loss2/ave_pool'], train=False) return F.softmax(y) cropwidth = 256 - in_size start = cropwidth // 2 stop = start + in_size mean_image = mean_image[:, start:stop, start:stop].copy() target_shape = (256, 256) output_side_length=256 image = cv2.imread(args.image) height, width, depth = image.shape new_height = output_side_length new_width = output_side_length if height > width: new_height = output_side_length * height / width else: new_width = output_side_length * width / height resized_img = cv2.resize(image, (new_width, new_height)) height_offset = (new_height - output_side_length) / 2 width_offset = (new_width - output_side_length) / 2 image= resized_img[height_offset:height_offset + output_side_length, width_offset:width_offset + output_side_length] image = image.transpose(2, 0, 1) image = image[:, start:stop, start:stop].astype(np.float32) image -= mean_image x_batch = np.ndarray( (1, 3, in_size,in_size), dtype=np.float32) x_batch[0]=image if args.gpu >= 0: x_batch=cuda.to_gpu(x_batch) x = chainer.Variable(x_batch, volatile=True) score = predict(x) if args.gpu >= 0: score=cuda.to_cpu(score.data) #print(score.data) categories = np.loadtxt("labels.txt", str, delimiter="\t") top_k = 20 prediction = zip(score.data[0].tolist(), categories) prediction.sort(cmp=lambda x, y: cmp(x[0], y[0]), reverse=True) flag = False for rank, (score, name) in enumerate(prediction[:top_k], start=1): #get top score label(ad hoc) if flag is False: predicted_label = name flag = True print('#%d | %s | %4.1f%%' % (rank, name, score * 100)) return(predicted_label)
import re import os import argparse from chainer import cuda import cPickle as pickle import numpy as np import cv2 as cv if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--model_file_dir', type=str, default='.') args = parser.parse_args() if args.gpu >= 0: cuda.init() for model_file in glob.glob('%s/*.chainermodel' % args.model_file_dir): epoch = int(re.search(ur'epoch_([0-9]+)', model_file).groups()[0]) model = pickle.load(open(model_file, 'rb')) model.to_cpu() conv1 = model.parameters[0] conv1 = conv1.transpose((0, 2, 3, 1)) n, h, w, c = conv1.shape side = int(np.ceil(np.sqrt(n))) pad = 2 canvas1 = np.zeros( (h * side + pad * (side + 1), w * side + pad * (side + 1), c))
def test_init_unavailable(self): if not cuda.available: with self.assertRaises(RuntimeError): cuda.init()
def train(self, epoch): ################# ####Prepare Data#### ################# print '==================================================' print '========This file will use the model file convnet_trial.py=========' print '==================================================' cropsize = self.crop epoch_size = epoch resolution = self.resol prefix = '/home/koyama-m/Research/membrane_CNN/' train_path = prefix + 'data/training_dataset/256_training_dataset_crop' + str(cropsize) + '/' test_path = prefix + 'data/test_dataset/256_test_dataset_crop' + str(cropsize) + '/' models_path = prefix + 'models/' data_path = prefix + 'data/' pkldata_path = data_path + 'data_pklformat_for_training/' sys.path.append(prefix) sys.path.append(train_path) sys.path.append(test_path) sys.path.append(models_path) sys.path.append(data_path) ####################### ###### Setup############ ####################### print 'importing the required modules ... ' import sys,pickle import numpy as np from chainer import cuda, Function, FunctionSet, gradient_check, Variable, optimizers import chainer.functions as F from matplotlib import pyplot as plt import logistic_reg import convnet_trial as convnet from pickle_preprocessed_dataset import make_dataset import os reload(logistic_reg) reload(convnet) print 'COMPLETE \n' ###### load dataset ###### print 'Loading the preprocessed test data and training data ... ' file_path = pkldata_path+'256_membrane%s.pkl' %str(cropsize) #If the filepath does not exist, create it. if os.path.exists(file_path) != True: print('pkl formatted test data and train data does not exist for these parameters ... creating the pkl file...') save_destination = pkldata_path train_path = data_path + 'training_dataset/%s_training_dataset_crop%s/'%(str(resolution),str(cropsize) ) test_path = data_path + 'test_dataset/%s_test_dataset_crop%s/'%(str(resolution),str(cropsize)) make_dataset(train_path, test_path, save_destination, patchsize = cropsize) else: print('pkl data found. Loading the pkl data...') dataset = pickle.load(open(file_path)) x_train0 = dataset['x_train']/255. y_train0 = dataset['y_train'] x_test = dataset['x_test']/255. y_test = dataset['y_test'] print 'COMPLETE \n ' ##### Validation Set and the rest #### print 'Preparing the Validation data... ' neg_index = np.where(y_train0 == 0)[0] pos_index = np.where(y_train0 == 1)[0] neg_pos_prop = [neg_index.shape[0], pos_index.shape[0] ] print 'Pos Neg proportion in training data ' + str(neg_pos_prop) validate_index = np.arange(150000, y_train0.shape[0],1) train_index = np.arange(0,150000,1) x_valid = x_train0[validate_index] y_valid = y_train0[validate_index] x_train = x_train0[train_index] y_train = y_train0[train_index] print 'COMPLETE \n ' ##### Tue if hte model is cnn ##### print 'Reshaping the dataset ' model_is_cnn = True ##### reshape x for cnn ##### if(model_is_cnn==True): x_train = x_train.reshape((x_train.shape[0],1,x_train.shape[1],x_train.shape[1])) x_test = x_test.reshape((x_test.shape[0],1,x_test.shape[1],x_test.shape[1])) x_valid = x_valid.reshape((x_valid.shape[0],1,x_valid.shape[1],x_valid.shape[1])) ######### init GPU status ####### cuda.init() #FXN MUST BE DEFINED BEFORE INITIALIZATION ######## init models ######## if(model_is_cnn==True): model_cpu_ver = convnet.convnet_trial(patchsize=x_train.shape[2]) model = convnet.convnet_trial(patchsize=x_train.shape[2]).to_gpu() else: model = logistic_reg.logistic_r(patchsize=x_train.shape[1]).to_gpu() print 'COMPLETE \n ' ######## init optimizer ####### print 'Initializing the optimizer...\n ' optimizer = optimizers.Adam() optimizer.setup(model.collect_parameters()) optimizer.zero_grads() print 'Initiating the Training Sequence...' ####################### ######Training########### ####################### import time trainsize = x_train.shape[0] validsize = x_valid.shape[0] #Data Augmentation x_traintr = np.transpose(x_train, (0,1,3,2)) x_trainlr = x_train[:,:,:,::-1] x_trainud = x_train[:,:,::-1,:] x_train_udtr = np.transpose(x_trainud, (0,1,3,2)) start_time = time.time() minibatchsize = 50 for epoch in xrange(epoch_size): elapsed_time = time.time() - start_time print 'Elapsed time is ' + str(elapsed_time) start_time = time.time() indexes = np.random.permutation(trainsize) n_batch = indexes.shape[0]/minibatchsize sum_loss = 0 sum_accuracy = 0 for i in xrange(0, trainsize, minibatchsize): x_batch_orig = x_train[indexes[i : i + minibatchsize]] y_batch_orig = y_train[indexes[i : i + minibatchsize]] x_batch_tr = x_traintr[indexes[i : i + minibatchsize]] y_batch_tr = y_train[indexes[i : i + minibatchsize]] x_batch_lr = x_trainlr[indexes[i : i + minibatchsize]] y_batch_lr = y_train[indexes[i : i + minibatchsize]] x_batch_ud = x_trainud[indexes[i : i + minibatchsize]] y_batch_ud = y_train[indexes[i : i + minibatchsize]] x_batch_udtr = x_train_udtr[indexes[i : i + minibatchsize]] y_batch_udtr = y_train[indexes[i : i + minibatchsize]] pre_x_batch = np.concatenate((x_batch_orig,x_batch_tr, x_batch_lr, x_batch_ud, x_batch_udtr), axis=0) pre_y_batch = np.concatenate((y_batch_orig,y_batch_tr, y_batch_lr, y_batch_ud,y_batch_udtr), axis=0) x_batch = cuda.to_gpu(pre_x_batch) y_batch = cuda.to_gpu(pre_y_batch) optimizer.zero_grads() loss, accuracy,pred = model.forward(x_batch, y_batch) sum_loss += loss.data*minibatchsize sum_accuracy += accuracy.data*minibatchsize loss.backward() optimizer.update() #print 'train loss:' + str(loss.data) #print 'train accuracy(%)' + str(accuracy.data) sum_val_loss = 0 sum_val_accuracy = 0 for i in xrange(0,validsize,minibatchsize): x_batch = cuda.to_gpu(x_valid[i : i + minibatchsize]) y_batch = cuda.to_gpu(y_valid[i : i + minibatchsize]) loss, accuracy,pred = model.forward(x_batch, y_batch,False) sum_val_loss += loss.data*minibatchsize sum_val_accuracy += accuracy.data*minibatchsize print 'epoch ', epoch print 'train loss:' + str(sum_loss/trainsize) print 'train accuracy(%)' + str(sum_accuracy/trainsize*100) print 'validation loss' + str(sum_val_loss/validsize) print 'validation accuracy(%)' + str(sum_val_accuracy/validsize*100) print type(model) modelname = 'trained_model%s_crop%sepoch%s.pkl' %(str(resolution), str(cropsize), str(epoch_size)) print modelname pickle.dump(model, open(models_path+ modelname,'wb'),-1) elapsed_time = time.time() - start_time print elapsed_time print 'Training sequence COMPLETE' print 'Initiating the Testing Sequence...' ####################### ###### Testing ########### ####################### testsize = x_test.shape[0] minibatchsize = 1000 sum_loss = 0 sum_accuracy = 0 confusion_matrix = np.zeros((2,2)) for i in xrange(0, testsize, minibatchsize): x_batch = cuda.to_gpu(x_test[i : i + minibatchsize]) y_batch = cuda.to_gpu(y_test[i : i + minibatchsize]) loss, accuracy, prob = model.forward(x_batch, y_batch,train=False) sum_loss += loss.data*minibatchsize sum_accuracy += accuracy.data*x_batch.shape[0] #pred = cuda.to_cpu(prob.data)[:,0]>threshold pred = np.argmax(cuda.to_cpu(prob.data),axis=1) #calc confusion matrix for j in xrange(x_batch.shape[0]): confusion_matrix[cuda.to_cpu(y_batch)[j],pred[j]] += 1 print 'Testing sequence COMPLETE... saving the log... ' txtname = 'trained_model%s_crop%sepoch%s_log.txt' %(str(resolution), str(cropsize), str(epoch_size)) sys.stdout = open(models_path+ txtname,"w") print 'test loss:' + str(sum_loss/testsize) print 'chance lebel(accuracy)' + str((np.sum(confusion_matrix[0,:])/np.sum(confusion_matrix))) print 'test accuracy(%)' + str((confusion_matrix[0,0]+confusion_matrix[1,1])/np.sum(confusion_matrix)) print 'confusion_matrix:' print confusion_matrix sys.stdout.close()
def __init__(self, modelpath, meanpath, gpu=-1): model = loader.load_model(modelpath) super(ModelVisualizer, self).__init__(meanpath, model, gpu) self.gpu = gpu if self.gpu >= 0: cuda.init(self.gpu)
def test(args): # augmentation setting trans = Transform(padding=[args.crop_pad_inf, args.crop_pad_sup], flip=args.flip, size=args.size, shift=args.shift, lcn=args.lcn) # test data test_fn = '%s/test_joints.csv' % args.datadir test_dl = np.array([l.strip() for l in open(test_fn).readlines()]) # load model if args.gpu >= 0: cuda.init(args.gpu) model = load_model(args) if args.gpu >= 0: model.to_gpu() else: model.to_cpu() # create output dir epoch = int(re.search(ur'epoch_([0-9]+)', args.param).groups()[0]) result_dir = os.path.dirname(args.param) out_dir = '%s/test_%d' % (result_dir, epoch) if not os.path.exists(out_dir): os.makedirs(out_dir) out_log = '%s.log' % out_dir fp = open(out_log, 'w') mean_error = 0.0 N = len(test_dl) for i in range(0, N, args.batchsize): lines = test_dl[i:i + args.batchsize] input_data, labels = load_data(trans, args, lines) if args.gpu >= 0: input_data = cuda.to_gpu(input_data.astype(np.float32)) labels = cuda.to_gpu(labels.astype(np.float32)) _, preds = model.forward(input_data, labels, train=False) if args.gpu >= 0: preds = cuda.to_cpu(preds.data) input_data = cuda.to_cpu(input_data) labels = cuda.to_cpu(labels) for n, line in enumerate(lines): img_fn = line.split(',')[args.fname_index] img = input_data[n].transpose((1, 2, 0)) pred = preds[n] img_pred, pred = trans.revert(img, pred) # turn label data into image coordinates label = labels[n] img_label, label = trans.revert(img, label) # calc mean_error error = np.linalg.norm(pred - label) / len(pred) mean_error += error # create pred, label tuples img_pred = np.array(img_pred.copy()) img_label = np.array(img_label.copy()) pred = [tuple(p) for p in pred] label = [tuple(p) for p in label] # all limbs img_label = draw_joints( img_label, label, args.draw_limb, args.text_scale) img_pred = draw_joints( img_pred, pred, args.draw_limb, args.text_scale) msg = '{:5}/{:5} {}\terror:{}\tmean_error:{}'.format( i + n, N, img_fn, error, mean_error / (i + n + 1)) print(msg, file=fp) print(msg) fn, ext = os.path.splitext(img_fn) tr_fn = '%s/%d-%d_%s_pred%s' % (out_dir, i, n, fn, ext) la_fn = '%s/%d-%d_%s_label%s' % (out_dir, i, n, fn, ext) cv.imwrite(tr_fn, img_pred) cv.imwrite(la_fn, img_label)
def run_nn_vae(q,optimizer_nm,train_x,train_real, train_y,test_x,test_y,cross_val,nn_n_hidden, vae_n_hidden, n_z, n_batch, nn_n_epochs,vae_n_epochs,n_epochs_tuning,activation,grad_clip,noise_nm,gpu=-1): # np.random.seed(123) # random値を固定 n_x = train_x.shape[1] n_real = train_real.shape[1] n_y = train_y.shape[1] nn_n_layers = len(nn_n_hidden) vae_n_hidden_recog =vae_n_hidden vae_n_hidden_gen = vae_n_hidden[::-1] vae_n_layers_recog = len(vae_n_hidden_recog) vae_n_layers_gen = len(vae_n_hidden_gen) """NN pre_train""" layers = {} # Recognition model. nn_layer_sizes = [(n_x,nn_n_hidden[0])] if nn_n_layers >1: nn_layer_sizes += zip(nn_n_hidden[:-1], nn_n_hidden[1:]) nn_layer_sizes += [(nn_n_hidden[-1], n_real)] for i, (n_incoming, n_outgoing) in enumerate(nn_layer_sizes): layers['nn_layer_%i' % i] = F.Linear(n_incoming, n_outgoing) """VAE pre_train""" # Recognition model. vae_rec_layer_sizes = [(n_real, vae_n_hidden_recog[0])] if vae_n_layers_recog >1: vae_rec_layer_sizes += zip(vae_n_hidden_recog[:-1], vae_n_hidden_recog[1:]) vae_rec_layer_sizes += [(vae_n_hidden_recog[-1], n_z)] for i, (n_incoming, n_outgoing) in enumerate(vae_rec_layer_sizes): layers['vae_recog_%i' % i] = F.Linear(n_incoming, n_outgoing) layers['log_sigma'] = F.Linear(vae_n_hidden_recog[-1], n_z) # Generating model. vae_gen_layer_sizes = [(n_z, vae_n_hidden_gen[0])] if vae_n_layers_recog >1: vae_gen_layer_sizes += zip(vae_n_hidden_gen[:-1], vae_n_hidden_gen[1:]) vae_gen_layer_sizes += [(vae_n_hidden_gen[-1], n_real)] for i, (n_incoming, n_outgoing) in enumerate(vae_gen_layer_sizes): layers['vae_gen_%i' % i] = F.Linear(n_incoming, n_outgoing) layers['output'] = F.Linear(n_z, n_y) model = NN_VAE(**layers) if gpu >= 0: cuda.init(gpu) model.to_gpu() # use Adam optimizers_dict = { "Adam":optimizers.Adam(),"AdaDelta":optimizers.AdaDelta(), "AdaGrad":optimizers.AdaGrad(),"MomentumSGD":optimizers.MomentumSGD(), "NesterovAG":optimizers.NesterovAG(),"RMSprop":optimizers.RMSprop(), "SGD":optimizers.SGD() } optimizer = optimizers_dict[optimizer_nm] optimizer.setup(model.collect_parameters()) total_nn_losses = [] if cross_val >=0: print('{}s pre-train start ...'.format(cross_val)) # pre_train_NN start for epoch in xrange(1, nn_n_epochs + 1): t1 = time.time() # np.random.seed(123) indexes = np.random.permutation(train_x.shape[0]) nn_total_loss = 0.0 nn_out_list = np.zeros(train_real.shape) noisy_train_x = np.array(noisy(noise_nm,train_x),dtype = np.float32) for i in xrange(0, train_x.shape[0], n_batch): noisy_x_batch = noisy_train_x[indexes[i : i + n_batch]] real_batch = train_real[indexes[i : i + n_batch]] if gpu >= 0: noisy_x_batch = cuda.to_gpu(noisy_x_batch) optimizer.zero_grads() loss, nn_out = model.nn_forward( noisy_x_batch, real_batch, nn_n_layers,nonlinear=activation, gpu=-1,train=True ) nn_total_loss += float(loss.data) * len(noisy_x_batch) loss.backward() optimizer.clip_grads(grad_clip) optimizer.update() nn_out_list[indexes[i : i + n_batch]] = nn_out.data total_nn_losses.append(nn_total_loss / train_x.shape[0]) # pre_train_VAE start total_vae_losses = [] if cross_val >=0: print('{}s tuning start ...'.format(cross_val)) nn_out_list = np.array(nn_out_list, dtype =np.float32) noisy_nn_out_list = np.array(noisy(noise_nm,nn_out_list),dtype = np.float32) for epoch in xrange(1, vae_n_epochs + 1): # np.random.seed(123) indexes = np.random.permutation(train_x.shape[0]) total_loss = 0.0 noisy_nn_out_list = np.array(noisy(noise_nm,nn_out_list),dtype = np.float32) for i in xrange(0, train_x.shape[0], n_batch): noisy_nn_out_list_batch = noisy_nn_out_list[indexes[i : i + n_batch]] nn_out_list_batch =nn_out_list[indexes[i : i + n_batch]] real_batch = train_real[indexes[i : i + n_batch]] if gpu >= 0: noisy_nn_out_list_batch = cuda.to_gpu(noisy_nn_out_list_batch) optimizer.zero_grads() rec_loss, kl_loss, output = model.vae_forward( noisy_nn_out_list_batch, real_batch, vae_n_layers_recog, vae_n_layers_gen, nonlinear_q=activation, nonlinear_p=activation,train=True) loss = rec_loss + kl_loss total_loss += float(loss.data) * len(noisy_nn_out_list_batch) loss.backward() optimizer.clip_grads(grad_clip) optimizer.update() total_vae_losses.append(total_loss / train_x.shape[0]) # train_test_NN_VAE start total_nn_vae_losses = [] total_test_losses = [] total_train_losses = [] if cross_val >=0: print('{}s tuning start ...'.format(cross_val)) for epoch in xrange(1, n_epochs_tuning + 1): noisy_train_x = np.array(noisy(noise_nm,train_x),dtype = np.float32) #np.random.seed(123) indexes = np.random.permutation(train_x.shape[0]) total_loss = 0.0 for i in xrange(0, train_x.shape[0], n_batch): noisy_x_batch = noisy_train_x[indexes[i : i + n_batch]] y_batch = train_y[indexes[i : i + n_batch]] if gpu >= 0: x_batch = cuda.to_gpu(x_batch) y_batch = cuda.to_gpu(y_batch) optimizer.zero_grads() loss, predict_score = model.nn_vae_tuning( noisy_x_batch, y_batch, nn_n_layers,vae_n_layers_recog, nonlinear_q=activation,train=True ) loss = loss ** 0.5 total_loss += float(loss.data) * len(noisy_x_batch) loss.backward() optimizer.clip_grads(grad_clip) optimizer.update() total_nn_vae_losses.append(total_loss / train_x.shape[0]) # test sum_loss_train = 0 for i in xrange(0, train_x.shape[0], n_batch): x_batch = train_x[indexes[i : i + n_batch]] y_batch = train_y[indexes[i : i + n_batch]] if gpu >= 0: x_batch = cuda.to_gpu(x_batch) y_batch = cuda.to_gpu(y_batch) loss, predict_score = model.nn_vae_tuning( x_batch, y_batch, nn_n_layers,vae_n_layers_recog, nonlinear_q=activation,train=False ) loss = loss ** 0.5 sum_loss_train += float(loss.data) * len(noisy_x_batch) total_train_losses.append(sum_loss_train/train_x.shape[0]) x_batch = test_x y_batch = test_y loss, predict_score = model.nn_vae_tuning( x_batch, y_batch, nn_n_layers,vae_n_layers_recog, nonlinear_q=activation, train=False ) loss = loss ** 0.5 total_test_losses.append(loss.data) q.put([total_nn_losses,total_vae_losses,total_nn_vae_losses,total_train_losses,total_test_losses])
def Main(): import argparse import numpy as np from chainer import cuda, Variable, FunctionSet, optimizers import chainer.functions as F parser = argparse.ArgumentParser(description='Chainer example: regression') parser.add_argument('--gpu', '-g', default=-1, type=int, help='GPU ID (negative value indicates CPU)') args = parser.parse_args() batchsize = 10 n_epoch = NEpoch n_units = 300 #TEST # Prepare dataset data_x, data_y = LoadData() batchsize= max(1,min(batchsize, len(data_y)/20)) #TEST: adjust batchsize #dx2,dy2=GenData(300, noise=0.0); data_x.extend(dx2); data_y.extend(dy2) data = np.array(data_x).astype(np.float32) target = np.array(data_y).astype(np.int32) #DIFF_REG N= len(data) #batchsize * 30 x_train= data y_train= target #For test: mi,ma,me= GetStat(data_x) f_reduce=lambda xa:[xa[0],xa[1]] f_repair=lambda xa:[xa[0],xa[1]] nt= 20+1 N_test= nt*nt x_test= np.array(sum([[f_repair([x1,x2]) for x2 in FRange1(f_reduce(mi)[1],f_reduce(ma)[1],nt)] for x1 in FRange1(f_reduce(mi)[0],f_reduce(ma)[0],nt)],[])).astype(np.float32) y_test= np.array([0.0 for x in x_test]).astype(np.int32) #DIFF_REG #No true test data (just for plotting) print 'Num of samples for train:',len(y_train),'batchsize:',batchsize # Dump data for plot: DumpData('/tmp/nn/smpl_train.dat', x_train, [[y] for y in y_train], f_reduce) #DIFF_REG # Prepare multi-layer perceptron model model = FunctionSet(l1=F.Linear(2, n_units), l2=F.Linear(n_units, n_units), l3=F.Linear(n_units, 3)) #TEST: Random bias initialization #, bias=Rand() #model.l1.b[:]= [Rand() for k in range(n_units)] #model.l2.b[:]= [Rand() for k in range(n_units)] #model.l3.b[:]= [Rand() for k in range(1)] #print model.l2.__dict__ if args.gpu >= 0: cuda.init(args.gpu) model.to_gpu() # Neural net architecture def forward(x_data, y_data, train=True): #train= False #TEST: Turn off dropout dratio= 0.2 #0.5 #TEST: Dropout ratio x, t = Variable(x_data), Variable(y_data) h1 = F.dropout(F.relu(model.l1(x)), ratio=dratio, train=train) h2 = F.dropout(F.relu(model.l2(h1)), ratio=dratio, train=train) #h1 = F.dropout(F.leaky_relu(model.l1(x),slope=0.2), ratio=dratio, train=train) #h2 = F.dropout(F.leaky_relu(model.l2(h1),slope=0.2), ratio=dratio, train=train) #h1 = F.dropout(F.sigmoid(model.l1(x)), ratio=dratio, train=train) #h2 = F.dropout(F.sigmoid(model.l2(h1)), ratio=dratio, train=train) #h1 = F.dropout(F.tanh(model.l1(x)), ratio=dratio, train=train) #h2 = F.dropout(F.tanh(model.l2(h1)), ratio=dratio, train=train) #h1 = F.dropout(model.l1(x), ratio=dratio, train=train) #h2 = F.dropout(model.l2(h1), ratio=dratio, train=train) #h1 = F.relu(model.l1(x)) #h2 = F.relu(model.l2(h1)) #h1 = model.l1(x) #h2 = model.l2(h1) y = model.l3(h2) #return F.mean_squared_error(y, t), y return F.softmax_cross_entropy(y, t), F.softmax(y) #DIFF_REG # Setup optimizer optimizer = optimizers.AdaDelta(rho=0.9) #optimizer = optimizers.AdaGrad(lr=0.5) #optimizer = optimizers.RMSprop() #optimizer = optimizers.MomentumSGD() #optimizer = optimizers.SGD(lr=0.8) optimizer.setup(model.collect_parameters()) # Learning loop for epoch in xrange(1, n_epoch+1): print 'epoch', epoch # training perm = np.random.permutation(N) sum_loss = 0 for i in xrange(0, N, batchsize): x_batch = x_train[perm[i:i+batchsize]] y_batch = y_train[perm[i:i+batchsize]] if args.gpu >= 0: x_batch = cuda.to_gpu(x_batch) y_batch = cuda.to_gpu(y_batch) optimizer.zero_grads() loss, pred = forward(x_batch, y_batch) loss.backward() #Computing gradients optimizer.update() sum_loss += float(cuda.to_cpu(loss.data)) * batchsize print 'train mean loss={}'.format( sum_loss / N) if epoch%10==0: #''' # testing all data preds = [] x_batch = x_test[:] y_batch = y_test[:] if args.gpu >= 0: x_batch = cuda.to_gpu(x_batch) y_batch = cuda.to_gpu(y_batch) loss, pred = forward(x_batch, y_batch, train=False) preds = cuda.to_cpu(pred.data) sum_loss = float(cuda.to_cpu(loss.data)) * len(y_test) #''' print 'test mean loss={}'.format( sum_loss / N_test) # Dump data for plot: y_pred= [[y.index(max(y))]+y for y in preds.tolist()] #DIFF_REG DumpData('/tmp/nn/nn_test%04i.dat'%epoch, x_test, y_pred, f_reduce, lb=nt+1)
def main(): args = parse_args() trace('making vocabulary ...') vocab, num_lines, num_words = make_vocab(args.corpus, args.vocab) trace('initializing CUDA ...') cuda.init() trace('start training ...') if args.model is 0: model = BasicRnnLM(args.embed, args.hidden, args.vocab) model.reset() elif args.model is 1: model = LSTMRnn(args.embed, args.hidden, args.vocab) model.reset() elif args.model is 2: model = AttentionLM(args.embed, args.hidden, args.vocab) model.reset() model.to_gpu() for epoch in range(args.epoch): trace('epoch %d/%d: ' % (epoch + 1, args.epoch)) log_ppl = 0.0 trained = 0 opt = optimizers.AdaGrad(lr = 0.01) opt.setup(model) opt.add_hook(optimizer.GradientClipping(5)) for batch in generate_batch(args.corpus, args.minibatch): K = len(batch) loss, perplexity= forward(batch, model) loss.backward() log_ppl += perplexity opt.update() trained += K model.reset() trace(' %d/%d' % (trained, num_lines)) log_ppl /= float(num_words) trace('Train log(PPL) = %.10f' % log_ppl) trace('Train PPL = %.10f' % math.exp(log_ppl)) log_ppl = 0.0 for batch in generate_batch(args.valid, args.minibatch): K = len(batch) loss, perplexity= forward(batch, model) log_ppl += perplexity model.reset() trace('Valid log(PPL) = %.10f' % log_ppl) trace('Valid PPL = %.10f' % math.exp(log_ppl)) trace(' writing model ...') trace('saving model ...') prefix = 'RNNLM-'+str(args.model) + '.%03.d' % (epoch + 1) save_vocab(prefix + '.srcvocab',vocab) #Fix this # Fixed model.save_spec(prefix + '.spec') serializers.save_hdf5(prefix + '.weights', model) trace('training finished.')
def main(): if P.gpu >= 0: cuda.init(P.gpu) test_and_save() return
import cPickle import numpy as np import six import cv2 import os import six.moves.cPickle as pickle import chainer from chainer import computational_graph as c from chainer import cuda import chainer.functions as F from chainer import optimizers #cudaのイニシャライズ cuda.init(0) #モデルの読み込み model = pickle.load(open('model15','rb')) #キャラクターの名前 chara_name = ['unknown', 'kyoko', 'akari', 'yui', 'chinatsu'] #伝播の設定 def forward(x_data): x = chainer.Variable(x_data, volatile=False) h = F.max_pooling_2d(F.relu(model.conv1(x)), ksize = 5, stride = 2, pad =2) h = F.max_pooling_2d(F.relu(model.conv2(h)), ksize = 5, stride = 2, pad =2) h = F.dropout(F.relu(model.l3(h)), train=False) y = model.l4(h)
training_size = int(9.0 / 10 * data_size) perm = np.random.permutation(data_size) data = data[perm] data12 = data12[perm] target = target[perm] x_train, x_test = np.split(data, [training_size]) x_train12, x_test12 = np.split(data12, [training_size]) y_train, y_test = np.split(target, [training_size]) test_size = data_size - training_size ## Load Network Architecture model = facenet.FaceNet24() if args.gpu >= 0: cuda.init(args.gpu) model.to_gpu() ## Set optimizer optimizer = optimizers.MomentumSGD(lr=0.001, momentum=0.9) optimizer.setup(model.collect_parameters()) ## function for test phase def forward_valid(x_test, y_test, batchsize): sum_accuracy = 0 sum_loss = 0 for i in range(0, test_size, batchsize): x_batch = x_test[i:i + batchsize] x_batch12 = x_test12[i:i + batchsize]
def Main(): import argparse import os, re import numpy as np import six.moves.cPickle as pickle #from fk_test import TFKTester parser = argparse.ArgumentParser(description='Chainer example: regression') parser.add_argument('--gpu', '-g', default=-1, type=int, help='GPU ID (negative value indicates CPU)') parser.add_argument('--dof', '-D', default='3', type=str, help='DoF code') parser.add_argument( '--sdof', '-SD', default='', type=str, help='DoF code of samples. Blank uses the same one as --dof.') parser.add_argument( '--mdof', '-MD', default='', type=str, help='DoF code of model file. Blank uses the same one as --dof.') args = parser.parse_args() batchsize = 10 #TEST; 20 n_epoch = NEpoch n_units = 200 #TEST n_units2 = 20 n_units3 = 50 #n_units = 500 #batchsize = 20 #dof = 3 dofc = args.dof sdofc = args.sdof if args.sdof != '' else dofc mdofc = args.mdof if args.mdof != '' else dofc dof = int(re.search('^[0-9]+', dofc).group()) data_x = LoadData('datak/chain%s_q.dat' % sdofc) if dofc not in ModelCodesWithXAll: data_y1 = LoadData('datak/chain%s_x.dat' % sdofc, c1=0, c2=3) data_y2 = LoadData('datak/chain%s_x.dat' % sdofc, c1=3, c2=None) else: data_y = LoadData('datak/chain%s_xall.dat' % sdofc, c1=7) #Skip the first pose. # Prepare dataset batchsize = max(1, min(batchsize, len(data_x) / 20)) #TEST: adjust batchsize data = np.array(data_x).astype(np.float32) target1 = np.array(data_y1).astype(np.float32) target2 = np.array(data_y2).astype(np.float32) N = len(data) #batchsize * 30 x_train = data y1_train = target1 y2_train = target2 print 'Num of samples for train:', len(x_train) Dx = len(data_x[0]) Dy1 = len(data_y1[0]) Dy2 = len(data_y2[0]) model1, model2 = CreateModel(dofc, Dx, Dy1, Dy2, n_units, n_units2, n_units3) if args.gpu >= 0: cuda.init(args.gpu) model1.to_gpu() model2.to_gpu() # Neural net architecture def forward(x_data, y1_data, y2_data, train=True): return ForwardModel(dofc, model1, model2, x_data, y1_data, y2_data, train) # Predict for a single query x def predict(x): x_batch = np.array([x]).astype(np.float32) y1_batch = np.array([[0.0] * Dy1]).astype(np.float32) #Dummy y2_batch = np.array([[0.0] * Dy2]).astype(np.float32) #Dummy if args.gpu >= 0: x_batch = cuda.to_gpu(x_batch) y1_batch = cuda.to_gpu(y1_batch) y2_batch = cuda.to_gpu(y2_batch) loss1, loss2, pred1, pred2 = forward(x_batch, y1_batch, y2_batch, train=False) y1 = cuda.to_cpu(pred1.data)[0] y2 = cuda.to_cpu(pred2.data)[0] y = np.concatenate((y1, y2)) return y # Setup optimizer optimizer1 = optimizers.AdaDelta(rho=0.9) optimizer2 = optimizers.AdaDelta(rho=0.9) #optimizer = optimizers.AdaGrad(lr=0.5) #optimizer = optimizers.RMSprop() #optimizer = optimizers.MomentumSGD() #optimizer = optimizers.SGD(lr=0.8) optimizer1.setup(model1.collect_parameters()) optimizer2.setup(model2.collect_parameters()) #tester= TFKTester(3) file_names = { 'l': 'result/fk2log%s.dat' % mdofc, 'm': 'result/fk2nn%s.dat' % mdofc } if os.path.exists(file_names['l']) or os.path.exists(file_names['m']): print 'File(s) already exists.' print 'Check:', file_names return fp_log = open(file_names['l'], 'w') # Learning loop for epoch in xrange(1, n_epoch + 1): print 'epoch', epoch # training perm = np.random.permutation(N) sum_loss = 0 for i in xrange(0, N, batchsize): x_batch = x_train[perm[i:i + batchsize]] y1_batch = y1_train[perm[i:i + batchsize]] y2_batch = y2_train[perm[i:i + batchsize]] if args.gpu >= 0: x_batch = cuda.to_gpu(x_batch) y1_batch = cuda.to_gpu(y1_batch) y2_batch = cuda.to_gpu(y2_batch) optimizer1.zero_grads() optimizer2.zero_grads() loss1, loss2, pred1, pred2 = forward(x_batch, y1_batch, y2_batch) loss1.backward() #Computing gradients loss2.backward() #Computing gradients optimizer1.update() optimizer2.update() loss = loss1 + loss2 bloss = float(cuda.to_cpu(loss.data)) sum_loss += bloss * batchsize fp_log.write('%f %f\n' % (epoch - 1.0 + float(i) / float(N), bloss)) print 'train mean loss={}'.format(sum_loss / N) fp_log.write('%f %f %f\n' % (float(epoch), bloss, sum_loss / N)) print predict(np.array([0.0] * dof).astype(np.float32)) #if epoch in TestNEpochs: #tester.Test(f_fwdkin=predict, n_samples=100) model = {'model1': model1, 'model2': model2} pickle.dump(model, open(file_names['m'], 'wb'), -1) print 'Model file is dumped to:', file_names['m'] ''' if epoch in TestNEpochs: # testing all data preds = [] x_batch = x_test[:] y_batch = y_test[:] if args.gpu >= 0: x_batch = cuda.to_gpu(x_batch) y_batch = cuda.to_gpu(y_batch) loss, pred = forward(x_batch, y_batch, train=False) preds = cuda.to_cpu(pred.data) sum_loss = float(cuda.to_cpu(loss.data)) * len(y_test) print 'test mean loss={}'.format( sum_loss / N_test) # Dump data for plot: DumpData('/tmp/nn_test%04i.dat'%epoch, x_test, preds, f_reduce, lb=nt+1) #''' #tester.Cleanup() fp_log.close()
def train(self, epochsize = 10, cooling_rate = 0.95, initial_temperature= 1.5, boringsize = 0): ################# #Turn this on if it is necssary to make the data SOMETHING IS WRONG WITH DATA LOADING makedata = True ################# # export paths parentpath= '/home/koyama-m/Research/membrane_CNN/' models_path= parentpath + 'models/' logs_path = 'logs/' datapath_train = parentpath + 'data/training_dataset/256_training_dataset_crop%s/' %str(self.cropsize) datapath_test = parentpath + 'data/test_dataset/256_test_dataset_crop%s/' %str(self.cropsize) label_datapath_train = parentpath + 'data/training_dataset/label_256_training_dataset_crop%s/'%str(self.cropsize) label_datapath_test = parentpath + 'data/test_dataset/label_256_test_dataset_crop%s/'%str(self.cropsize) trainingfilepath_prefix = '256_training_image_' #256_test_image_%3d%3d%3d.tif %(slice_index, row, column) label_filepath_prefix = 'label_256_training_image_' sys.path.append(parentpath) sys.path.append(models_path) sys.path.append(datapath_train) sys.path.append(datapath_test) sys.path.append(label_datapath_train) sys.path.append(label_datapath_test) sys.path.append(trainingfilepath_prefix) sys.path.append(label_filepath_prefix) ################# ####Prepare Data#### ################# print '==================================================' print '========This file will use the model file convnet_conditional.py=========' print '==================================================' print 'Cropsize :%d, Resolution :%d, Epoch : %d, Boringsize : %d' %(self.cropsize, self.resolution, epochsize, boringsize) print 'cooling_rate:%s, initial temperature:%s, final temperature:%s' %\ (str(cooling_rate), str(initial_temperature), str(initial_temperature*(cooling_rate**epochsize)) ) ####################### ###### Setup############ ####################### print 'importing the required modules ... ' import logistic_reg import convnet_conditional as convnet import load_preprocessed_data_set as loadt reload(logistic_reg) reload(convnet) print 'COMPLETE \n' ###### load dataset ###### print 'Loading the preprocessed test data and training data ... ' if(makedata): dataslice_test = loadt.make_data_set(datapath_test, patchsize =self.cropsize \ ,label_data_path = label_datapath_test, is_training = False, boring_size = boringsize) dataslice_train = loadt.make_data_set(datapath_train, patchsize =self.cropsize\ ,label_data_path = label_datapath_train, is_training = True, boring_size = boringsize) pickle.dump({'test': dataslice_test , 'train':dataslice_train},\ open('/home/koyama-m/Research/membrane_CNN/data/temp_data/temp_dataset_with_hole.pkl','wb'),pickle.HIGHEST_PROTOCOL) dataset = pickle.load(open('/home/koyama-m/Research/membrane_CNN/data/temp_data/temp_dataset_with_hole.pkl','rb')) dataslice_test = dataset['test'] dataslice_train= dataset['train'] x_train, x_test, x_valid, y_train, y_test, y_valid = self.reshape_for_chainer_cnn(dataslice_train, dataslice_test) ######### init GPU status ####### cuda.init() #FXN MUST BE DEFINED BEFORE INITIALIZATION ######## init models ######## model_cpu_ver = convnet.convnet_cdd(patchsize=x_train.shape[2]) model = convnet.convnet_cdd(patchsize=x_train.shape[2]).to_gpu() ######## init optimizer ####### print 'Initializing the optimizer...\n ' optimizer = optimizers.Adam() optimizer.setup(model.collect_parameters()) optimizer.zero_grads() print 'Initiating the Training Sequence...' ####################### ######Training########### ####################### import time trainsize = x_train.shape[0] validsize = x_valid.shape[0] print 'validsize: ', validsize start_time = time.time() temperature = initial_temperature minibatchsize = 50 for epoch in xrange(epochsize): print 'current_temperature: ', temperature elapsed_time = time.time() - start_time print 'Elapsed time is ' + str(elapsed_time) start_time = time.time() indexes = np.random.permutation(trainsize) n_batch = indexes.shape[0]/minibatchsize sum_loss = 0 sum_accuracy = 0 for i in xrange(0, trainsize, minibatchsize): batchrange = indexes[i : i + minibatchsize] x_train_batch = x_train[batchrange] self.filter_batch(x_train_batch[:,1,:,:] , temperature) y_train_batch = y_train[batchrange] pre_x_batch, pre_y_batch = self.augment_data_batch(x_train_batch, y_train_batch) x_batch = cuda.to_gpu(pre_x_batch) y_batch = cuda.to_gpu(pre_y_batch) optimizer.zero_grads() loss, accuracy,pred = model.forward(x_batch, y_batch) sum_loss += loss.data*minibatchsize sum_accuracy += accuracy.data*minibatchsize loss.backward() optimizer.update() sum_val_loss = 0 sum_val_accuracy = 0 for i in xrange(0,validsize,minibatchsize): x_valid_batch =x_valid[i : i + minibatchsize] y_valid_batch =y_valid[i : i + minibatchsize] pre_x_batch, pre_y_batch = self.augment_data_batch(x_valid_batch, y_valid_batch) x_batch = cuda.to_gpu(pre_x_batch) y_batch = cuda.to_gpu(pre_y_batch) loss, accuracy,pred = model.forward(x_batch, y_batch,False) sum_val_loss += loss.data*minibatchsize sum_val_accuracy += accuracy.data*minibatchsize print 'epoch ', epoch print 'train loss:' + str(sum_loss/trainsize) print 'train accuracy(%): ' + str(sum_accuracy/trainsize*100) print 'validation loss: ' + str(sum_val_loss/validsize) print 'validation accuracy(%)' + str(sum_val_accuracy/validsize*100) print type(model) modelname = 'hole%s_cool_rate%sconditional_distr_trained_model%s_crop%sepoch%s.pkl' %(str(boringsize),str(cooling_rate), str(self.resolution), str(self.cropsize), str(epochsize)) print modelname pickle.dump(model, open(models_path+ modelname,'wb'),-1) temperature = temperature *cooling_rate elapsed_time = time.time() - start_time print elapsed_time print 'Training sequence COMPLETE' print 'Initiating the Testing Sequence...' ####################### ###### Testing ########### ####################### testsize = x_test.shape[0] sum_loss = 0 sum_accuracy = 0 confusion_matrix = np.zeros((2,2)) for i in xrange(0, testsize, minibatchsize): if (i %10000 == 0): print "currently computing the set :", i*minibatchsize , " ~ ," x_test_batch = x_test[i : i + minibatchsize] y_test_batch = y_test[i : i + minibatchsize] pre_x_batch, pre_y_batch = self.augment_data_batch(x_test_batch, y_test_batch) x_batch = cuda.to_gpu(pre_x_batch) y_batch = cuda.to_gpu(pre_y_batch) loss, accuracy, prob = model.forward(x_batch, y_batch,train=False) sum_loss += loss.data*minibatchsize sum_accuracy += accuracy.data*x_batch.shape[0] #pred = cuda.to_cpu(prob.data)[:,0]>threshold pred = np.argmax(cuda.to_cpu(prob.data),axis=1) #calc confusion matrix for j in xrange(x_batch.shape[0]): confusion_matrix[cuda.to_cpu(y_batch)[j],pred[j]] += 1 print 'Testing sequence COMPLETE... saving the log... ' txtname = 'hole%scool_rate%sconditional_distr_trained_model%s_crop%sepoch%s_log.txt' %(str(boringsize), str(cooling_rate),str(self.resolution), str(self.cropsize), str(epochsize)) sys.stdout = open(models_path+ logs_path + txtname,"w") print 'test loss:' + str(sum_loss/testsize) print 'chance lebel(accuracy)' + str((np.sum(confusion_matrix[0,:])/np.sum(confusion_matrix))) print 'test accuracy(%)' + str((confusion_matrix[0,0]+confusion_matrix[1,1])/np.sum(confusion_matrix)*100) print 'confusion_matrix:' print confusion_matrix print 'Done with the model \n' print modelname print str(datetime.datetime.now()) sys.stdout.close()
mnist = data.load_mnist_data() mnist['data'] = mnist['data'].astype(np.float32) mnist['data'] /= 255 mnist['target'] = mnist['target'].astype(np.int32) N = 60000 x_train, x_test = np.split(mnist['data'], [N]) y_train, y_test = np.split(mnist['target'], [N]) N_test = y_test.size # Prepare multi-layer perceptron model model = chainer.FunctionSet(l1=F.Linear(784, n_units), l2=F.Linear(n_units, n_units), l3=F.Linear(n_units, 10)) if args.gpu >= 0: cuda.init(args.gpu) model.to_gpu() # Neural net architecture def forward(x_data, y_data, train=True): x, t = chainer.Variable(x_data), chainer.Variable(y_data) h1 = F.dropout(F.relu(model.l1(x)), train=train) h2 = F.dropout(F.relu(model.l2(h1)), train=train) y = model.l3(h2) return F.softmax_cross_entropy(y, t), F.accuracy(y, t) # Setup optimizer optimizer = optimizers.Adam() optimizer.setup(model)
def Main(): import argparse import numpy as np from sklearn.datasets import load_diabetes from chainer import cuda, Variable, FunctionSet, optimizers import chainer.functions as F parser = argparse.ArgumentParser(description='Chainer example: regression') parser.add_argument('--gpu', '-g', default=-1, type=int, help='GPU ID (negative value indicates CPU)') args = parser.parse_args() batchsize = 13 n_epoch = 100 n_units = 30 # Prepare dataset print 'fetch diabetes dataset' diabetes = load_diabetes() data = diabetes['data'].astype(np.float32) target = diabetes['target'].astype(np.float32).reshape( len(diabetes['target']), 1) N = batchsize * 30 #Number of training data x_train, x_test = np.split(data, [N]) y_train, y_test = np.split(target, [N]) N_test = y_test.size print 'Num of samples for train:', len(y_train) print 'Num of samples for test:', len(y_test) # Dump data for plot: fp1 = file('/tmp/smpl_train.dat', 'w') for x, y in zip(x_train, y_train): fp1.write('%s #%i# %s\n' % (' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y)))) fp1.close() # Dump data for plot: fp1 = file('/tmp/smpl_test.dat', 'w') for x, y in zip(x_test, y_test): fp1.write('%s #%i# %s\n' % (' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y)))) fp1.close() # Prepare multi-layer perceptron model model = FunctionSet(l1=F.Linear(10, n_units), l2=F.Linear(n_units, n_units), l3=F.Linear(n_units, 1)) if args.gpu >= 0: cuda.init(args.gpu) model.to_gpu() # Neural net architecture def forward(x_data, y_data, train=True): x, t = Variable(x_data), Variable(y_data) h1 = F.dropout(F.relu(model.l1(x)), train=train) h2 = F.dropout(F.relu(model.l2(h1)), train=train) y = model.l3(h2) return F.mean_squared_error(y, t), y # Setup optimizer optimizer = optimizers.AdaDelta(rho=0.9) optimizer.setup(model.collect_parameters()) # Learning loop for epoch in xrange(1, n_epoch + 1): print 'epoch', epoch # training perm = np.random.permutation(N) sum_loss = 0 for i in xrange(0, N, batchsize): x_batch = x_train[perm[i:i + batchsize]] y_batch = y_train[perm[i:i + batchsize]] if args.gpu >= 0: x_batch = cuda.to_gpu(x_batch) y_batch = cuda.to_gpu(y_batch) optimizer.zero_grads() loss, pred = forward(x_batch, y_batch) loss.backward() optimizer.update() sum_loss += float(cuda.to_cpu(loss.data)) * batchsize print 'train mean loss={}'.format(sum_loss / N) ''' # testing per batch sum_loss = 0 preds = [] for i in xrange(0, N_test, batchsize): x_batch = x_test[i:i+batchsize] y_batch = y_test[i:i+batchsize] if args.gpu >= 0: x_batch = cuda.to_gpu(x_batch) y_batch = cuda.to_gpu(y_batch) loss, pred = forward(x_batch, y_batch, train=False) preds.extend(cuda.to_cpu(pred.data)) sum_loss += float(cuda.to_cpu(loss.data)) * batchsize pearson = np.corrcoef(np.asarray(preds).reshape(len(preds),), np.asarray(y_test).reshape(len(preds),)) #''' #''' # testing all data preds = [] x_batch = x_test[:] y_batch = y_test[:] if args.gpu >= 0: x_batch = cuda.to_gpu(x_batch) y_batch = cuda.to_gpu(y_batch) loss, pred = forward(x_batch, y_batch, train=False) preds = cuda.to_cpu(pred.data) sum_loss = float(cuda.to_cpu(loss.data)) * len(y_test) pearson = np.corrcoef( np.asarray(preds).reshape(len(preds), ), np.asarray(y_test).reshape(len(preds), )) #''' print 'test mean loss={}, corrcoef={}'.format(sum_loss / N_test, pearson[0][1]) # Dump data for plot: fp1 = file('/tmp/nn_test%04i.dat' % epoch, 'w') for x, y in zip(x_test, preds): fp1.write( '%s #%i# %s\n' % (' '.join(map(str, x)), len(x) + 1, ' '.join(map(str, y)))) fp1.close()
def getNeuralCode(directory, layer="conv5_1", gpu=-1): model = "illust2vec_ver200.caffemodel" #use illust2vec_ver200 print('illust2vec_ver200 is being loaded!') #calculate load time timeMemory = time() func = caffe.CaffeFunction(model) print('illust2vec_ver200 was loaded!') print('It took ' + str(int(time() - timeMemory)) + " secondes") #gpu mode if gpu >= 0: cuda.init(gpu) func.to_gpu() in_size = 224 # Constant mean over spatial pixels mean_image = np.load("illust2vec_image_mean.npy") print("neural code is extraced from layer " + layer) def neuralCode(x): #推測関数 y, = func(inputs={'data': x}, outputs=[layer], train=False) return y.data[0] cropwidth = 256 - in_size start = cropwidth // 2 stop = start + in_size mean_image = mean_image[:, start:stop, start:stop].copy() target_shape = (256, 256) output_side_length=256 numPic = 0 #count pictures for folderPath in directory: #search pictures picturePath = [picture for picture in os.listdir(folderPath) if re.findall(r"\.png$|\.jpg$|\.JPG$|\.PNG$|\.JPEG$",picture)] print("you have " + str(len(picturePath)) + " pictures in " + folderPath) numPic = numPic + len(picturePath) print("you have totally " + str(numPic) + " pictures") count = 0 answer = {} for folderPath in directory: #search pictures picturePath = [picture for picture in os.listdir(folderPath) if re.findall(r"\.png$|\.jpg$|\.JPG$|\.PNG$|\.JPEG$",picture)] for picture in picturePath: timeMemory = time() count = count + 1 #load image file image = cv2.imread(folderPath + "/" + picture) #resize and crop height, width, depth = image.shape new_height = output_side_length new_width = output_side_length if height > width: new_height = output_side_length * height / width else: new_width = output_side_length * width / height resized_img = cv2.resize(image, (new_width, new_height)) height_offset = (new_height - output_side_length) / 2 width_offset = (new_width - output_side_length) / 2 image= resized_img[height_offset:height_offset + output_side_length, width_offset:width_offset + output_side_length] #subtract mean image image = image.transpose(2, 0, 1) image = image[:, start:stop, start:stop].astype(np.float32) image -= mean_image x_batch = np.ndarray( (1, 3, in_size,in_size), dtype=np.float32) x_batch[0]=image if gpu >= 0: x_batch=cuda.to_gpu(x_batch) #get neural code x = chainer.Variable(x_batch, volatile=True) answer[folderPath + "/" + picture] = neuralCode(x) sen = overwrite.bar(count,numPic) overwrite.overwrite(sen) return answer
""" CNNsのモデルを実行するスクリプト 今回使用するデータセットはMNIST """ from __future__ import absolute_import from __future__ import division from __future__ import print_function from mnist_classification import CNN from chainer import cuda import numpy as np from sklearn.datasets import fetch_mldata #GPUつかうよ cuda.init(0) print('load MNIST digit dataset') mnist = fetch_mldata('MNIST original', data_home=".") mnist.data = mnist.data.astype(np.float32) mnist.data /= 255 mnist.target = mnist.target.astype(np.int32) output_dim = 10 print('create CNNs model') cnn = CNN(data=mnist.data, target=mnist.target, gpu=0, output_dim=output_dim)
import unittest import numpy from chainer import cuda from chainer import gradient_check from chainer import testing from chainer.testing import attr from chainer import utils if cuda.available: cuda.init() class TestWalkerAlias(unittest.TestCase): def setUp(self): self.ps = [5, 3, 4, 1, 2] self.sampler = utils.WalkerAlias(self.ps) def check_sample(self): counts = numpy.zeros(len(self.ps), numpy.float32) for _ in range(1000): vs = self.sampler.sample((4, 3)) numpy.add.at(counts, cuda.to_cpu(vs), 1) counts /= (1000 * 12) counts *= sum(self.ps) gradient_check.assert_allclose(self.ps, counts, atol=0.1, rtol=0.1) def test_sample_cpu(self): self.check_sample()
#to check the current N and M, run the following #[x.data.shape for x in [conv1_1F,conv2_1F, conv3_1F, conv4_1F,conv5_1F]] L_style = (Fu.mean_squared_error(conv1_1G,conv1_1A)/(4*64*64*50176*50176) + Fu.mean_squared_error(conv2_1G,conv2_1A)/(4*128**128*12544*12544) + Fu.mean_squared_error(conv3_1G,conv3_1A)/(4*256*256*3136*3136) + Fu.mean_squared_error(conv4_1G,conv4_1A)/(4*512*512*784*784)\ )/4 # this is equal weighting of E_l # ratio = 0.001 #alpha/beta loss = ratio * L_content + L_style return loss #main cuda.init(3) # is GPU ID!! p = readimage('satoshi_fb.png') #read a content image a = readimage('style.png') #read a style image #download a pretraind caffe model from here: https://gist.github.com/ksimonyan/3785162f95cd2d5fee77#file-readme-md func = caffe.CaffeFunction( 'VGG_ILSVRC_19_layers.caffemodel') #it takes some time. func.to_gpu() x_data = np.random.randn(1, 3, 224, 224).astype(np.float32) x = Variable(cuda.to_gpu(x_data)) x = readimage('imge230.png') # if you want to start from a exsiting image savedir = "satoshi_fb_adam"