def set_model(feature_dimension_size, param, output_units): """ NNのモデルの設定 @param feature_dimension_size: 入力特徴量の次元数 @param param: パラメータオブジェクト @param output_units: 出力層のユニット数 @return: ネットワークモデル """ if param.HIDDEN_LAYER_NUM == 1: # 3層パーセプトロン(入力層、中間層1、出力層) model = FunctionSet(l1=F.Linear(feature_dimension_size, param.NODE_NUM_1LAYER), l2=F.Linear(param.NODE_NUM_1LAYER, output_units)) if param.HIDDEN_LAYER_NUM == 2: # 4層パーセプトロン(入力層、中間層1、中間層2、出力層) model = FunctionSet(l1=F.Linear(feature_dimension_size, param.NODE_NUM_1LAYER), l2=F.Linear(param.NODE_NUM_1LAYER, param.NODE_NUM_2LAYER), l3=F.Linear(param.NODE_NUM_2LAYER, output_units)) if param.HIDDEN_LAYER_NUM == 3: # 5層パーセプトロン model = FunctionSet(l1=F.Linear(feature_dimension_size, param.NODE_NUM_1LAYER), l2=F.Linear(param.NODE_NUM_1LAYER, param.NODE_NUM_2LAYER), l3=F.Linear(param.NODE_NUM_2LAYER, param.NODE_NUM_3LAYER), l4=F.Linear(param.NODE_NUM_3LAYER, output_units)) return model
def __init__(self, nnpacker, logging=False): self.nnpacker = nnpacker model = FunctionSet(**nnpacker.getFunctions()) optimizer = optimizers.SGD() lossFunction = F.softmax_cross_entropy params = {'epoch': 20, 'batchsize': 100, 'logging': logging} NNmanager.__init__(self, model, optimizer, lossFunction, **params)
def __init__(self, optimizer): self.model = FunctionSet(l=Linear(self.UNIT_NUM, 2)) self.optimizer = optimizer # true parameters self.w = np.random.uniform(-1, 1, (self.UNIT_NUM, 1)).astype(np.float32) self.b = np.random.uniform(-1, 1, (1, )).astype(np.float32)
def __init__(self, input_vector_length,enable_controller=[0, 1, 2]): self.num_of_actions = len(enable_controller) self.enable_controller = enable_controller # Default setting : "Pong" self.input_vector_length = input_vector_length print "Initializing DQN..." # Initialization for Chainer 1.1.0 or older. # print "CUDA init" # cuda.init() #inputs --> 5 * 14 (with 10 temporality) + 5 (of last one hour) + 5 (of last 24 hour) print "Model Building" self.model = FunctionSet( l1=F.Linear(input_vector_length, 500), l2=F.Linear(500, 250), l3=F.Linear(250, 80), q_value=F.Linear(80, self.num_of_actions, initialW=np.zeros((self.num_of_actions, 80), 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, self.input_vector_length), 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, self.input_vector_length), dtype=np.uint8), np.zeros((self.data_size, 1), dtype=np.bool)]
def __init__(self): self.model0 = FunctionSet( l=F.Convolution2D(1, 1, 5, stride=1, pad=2, nobias=True)) self.model1 = FunctionSet( l=F.Convolution2D(1, 1, 5, stride=1, pad=2, nobias=True)) #print self.model.l.W.shape self.model0.l.W[0, 0, :, :] = np.array( [[0, 0, 2, 0, 0], [0, 0, -12, 0, 0], [0, 0, 6, 0, 0], [0, 0, 4, 0, 0], [0, 0, 0, 0, 0]]).astype(np.float32) / 12.0 self.model1.l.W[0, 0, :, :] = np.array( [[0, 0, 0, 0, 0], [0, 0, -4, 0, 0], [0, 0, -6, 0, 0], [0, 0, 12, 0, 0], [0, 0, -2, 0, 0]]).astype(np.float32) / 12.0 #print self.model.l.W.shape self.model0.to_gpu() self.model1.to_gpu()
def __init__(self, use_gpu, enable_controller, dim): self.use_gpu = use_gpu self.num_of_actions = len(enable_controller) self.enable_controller = enable_controller self.dim = dim print("Initializing Q-Network...") print("Input Dim of Q-Network : ",self.dim*self.hist_size) hidden_dim = 256 self.model = FunctionSet( l4=F.Linear(self.dim*self.hist_size, hidden_dim, wscale=np.sqrt(2)), l5=F.Linear(hidden_dim,hidden_dim,wscale=np.sqrt(2)), q_value=F.Linear(hidden_dim, self.num_of_actions, initialW=np.zeros((self.num_of_actions, hidden_dim), dtype=np.float32)) ) if self.use_gpu >= 0: self.model.to_gpu() self.model_target = copy.deepcopy(self.model) 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, self.hist_size, self.dim), 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, self.hist_size, self.dim), dtype=np.uint8), np.zeros((self.data_size, 1), dtype=np.bool)]
def __init__(self): n_in = 28 * 28 n_hidden = 100 self.model = FunctionSet(encode=F.Linear(n_in, n_hidden), decode=F.Linear(n_hidden, n_in)) self.optimizer = optimizers.Adam() self.optimizer.setup(self.model.collect_parameters())
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..." # Initialization of Chainer 1.1.0 or older. # print "CUDA init" # cuda.init() print "Model Building" self.model = FunctionSet( l1=convlstm_link.CONVLSTM(7056, 7056), l4=F.Linear(7056, 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 __init__(self, data=None, target=None, n_inputs=784, n_hidden=784, n_outputs=10, gpu=-1): self.excludes.append('xp') self.model = FunctionSet(l1=F.Linear(n_inputs, n_hidden), l2=F.Linear(n_hidden, n_hidden), l3=F.Linear(n_hidden, n_outputs)) if gpu >= 0: self.model.to_gpu() self.xp = cuda.cupy else: self.xp = np if not data is None: self.x_train, self.x_test = data else: self.x_train, self.y_test = None, None if not target is None: self.y_train, self.y_test = target self.n_train = len(self.y_train) self.n_test = len(self.y_test) else: self.y_train, self.y_test = None, None self.n_train = 0 self.n_test = 0 self.gpu = gpu self.optimizer = optimizers.Adam() self.optimizer.setup(self.model)
def init_model(model_params): wscale1 = model_params.wscale1 # math.sqrt(5 * 5 * 3) * 0.0001 wscale2 = model_params.wscale2 # math.sqrt(5 * 5 * 32) * 0.01 wscale3 = model_params.wscale3 # math.sqrt(5 * 5 * 32) * 0.01 wscale4 = model_params.wscale4 # math.sqrt(576) * 0.1 wscale5 = model_params.wscale5 # math.sqrt(64) * 0.1 # wscale1, wscale2, wscale3, wscale4, wscale5 = [math.sqrt(2)] * 5 model = FunctionSet(conv1=F.Convolution2D(3, 32, 5, wscale=wscale1, stride=1, pad=2), conv2=F.Convolution2D(32, 32, 5, wscale=wscale2, stride=1, pad=2), conv3=F.Convolution2D(32, 64, 5, wscale=wscale3, stride=1, pad=2), fl4=F.Linear(576, 64, wscale=wscale4), fl5=F.Linear(64, 10, wscale=wscale5)) if params.gpu_flag: model.to_gpu() return model
def __init__(self,n_act): N_output = n_act self.model = FunctionSet( conv1=F.Convolution2D(1, 16, 3, pad=1), conv2=F.Convolution2D(16, 16, 3, pad=1), l1=F.Linear(256, 256), l2=F.Linear(256, N_output))
def init_model(vocab_size, char_type_size): model = FunctionSet( embed=F.EmbedID(vocab_size, embed_units), char_type_embed=F.EmbedID(char_type_size, char_type_embed_units), #dict_embed = F.Linear(12, dict_embed_units), hidden1=F.Linear( window * (embed_units + char_type_embed_units) * 3 + hidden_units, hidden_units), i_gate=F.Linear( window * (embed_units + char_type_embed_units) * 3 + hidden_units, hidden_units), f_gate=F.Linear( window * (embed_units + char_type_embed_units) * 3 + hidden_units, hidden_units), o_gate=F.Linear( window * (embed_units + char_type_embed_units) * 3 + hidden_units, hidden_units), output=F.Linear(hidden_units + 12, label_num), ) if opt_selection == 'Adagrad': opt = optimizers.AdaGrad(lr=learning_rate) elif opt_selection == 'SGD': opt = optimizers.SGD() elif opt_selection == 'Adam': opt = optimizers.Adam() else: opt = optimizers.AdaGrad(lr=learning_rate) print('Adagrad is chosen as defaut') opt.setup(model) return model, opt
def __init__(self, rng, data, n_inputs=784, n_hidden=784, corruption_level=0.3, gpu=-1, sparse=False): """Denoising AutoEncoder data: data for train n_inputs: a number of units of input layer and output layer n_hidden: a number of units of hidden layer corruption_level: a ratio of masking noise """ self.model = FunctionSet(encoder=F.Linear(n_inputs, n_hidden), decoder=F.Linear(n_hidden, n_inputs)) if gpu >= 0: self.model.to_gpu() self.gpu = gpu self.x_train, self.x_test = data self.n_train = len(self.x_train) self.n_test = len(self.x_test) self.optimizer = optimizers.Adam() self.optimizer.setup(self.model.collect_parameters()) self.corruption_level = corruption_level self.rng = rng self.sparse = sparse
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, 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 __init__(self): 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))) self.model.l1.W = np.load('elite/l1_W.npy') self.model.l1.b = np.load('elite/l1_b.npy') self.model.l2.W = np.load('elite/l2_W.npy') self.model.l2.b = np.load('elite/l2_b.npy') self.model.l3.W = np.load('elite/l3_W.npy') self.model.l3.b = np.load('elite/l3_b.npy')
def CreateNNs(self): assert(len(self.Options['n_units'])>=2) assert(self.Options['n_units_err'] is None or len(self.Options['n_units_err'])>=2) #Mean model n_units= self.Options['n_units'] self.f_names= ['l%d'%i for i in range(len(n_units)-1)] funcs= {} for i in range(len(n_units)-1): funcs[self.f_names[i]]= F.Linear(n_units[i],n_units[i+1]) self.model= FunctionSet(**funcs) #Error model if self.Options['n_units_err']!=None: n_units= self.Options['n_units_err'] self.f_names_err= ['l%d'%i for i in range(len(n_units)-1)] funcs= {} for i in range(len(n_units)-1): funcs[self.f_names_err[i]]= F.Linear(n_units[i],n_units[i+1]) self.model_err= FunctionSet(**funcs)
def __init__(self, n_in, n_hidden, n_epoch=20, batchsize=100, use_cuda=False): super().__init__(n_epoch, batchsize, use_cuda) self.model = FunctionSet( encode=F.Linear(n_in, n_hidden), decode=F.Linear(n_hidden, n_in) ) self.registModel()
def __init__(self, num_inputs, num_units, dropout_ratio, corruption_level, optimizer, gpu): model = FunctionSet(layer1=F.Linear(num_inputs, num_units), layer2=F.Linear(num_units, num_units), layer3=F.Linear(num_units, 1)) # 回帰用出力 self.layers = [model.layer1, model.layer2, model.layer3] super(MLP, self).__init__(model, optimizer, dropout_ratio, corruption_level, gpu)
def __init__(self, in_channels, out1, proj3, out3, proj33, out33, pooltype, proj_pool=None, stride=1): if out1 > 0: assert stride == 1 assert proj_pool is not None self.f = FunctionSet( proj3=F.Convolution2D(in_channels, proj3, 1, nobias=True), conv3=F.Convolution2D(proj3, out3, 3, pad=1, stride=stride, nobias=True), proj33=F.Convolution2D(in_channels, proj33, 1, nobias=True), conv33a=F.Convolution2D(proj33, out33, 3, pad=1, nobias=True), conv33b=F.Convolution2D(out33, out33, 3, pad=1, stride=stride, nobias=True), proj3n=F.BatchNormalization(proj3), conv3n=F.BatchNormalization(out3), proj33n=F.BatchNormalization(proj33), conv33an=F.BatchNormalization(out33), conv33bn=F.BatchNormalization(out33), ) if out1 > 0: self.f.conv1 = F.Convolution2D(in_channels, out1, 1, stride=stride, nobias=True) self.f.conv1n = F.BatchNormalization(out1) if proj_pool is not None: self.f.poolp = F.Convolution2D(in_channels, proj_pool, 1, nobias=True) self.f.poolpn = F.BatchNormalization(proj_pool) if pooltype == 'max': self.f.pool = MaxPooling2D(3, stride=stride, pad=1) elif pooltype == 'avg': self.f.pool = AveragePooling2D(3, stride=stride, pad=1) else: raise NotImplementedError()
def CreateNNs(self): assert (len(self.Options['n_units']) >= 2) #Mean model n_units = self.Options['n_units'] self.f_names = ['l%d' % i for i in range(len(n_units) - 1)] funcs = {} for i in range(len(n_units) - 1): funcs[self.f_names[i]] = F.Linear(n_units[i], n_units[i + 1]) self.model = FunctionSet(**funcs)
def __init__(self, use_gpu, enable_controller, dim): self.use_gpu = use_gpu self.num_of_actions = len(enable_controller) self.enable_controller = enable_controller self.dim = dim print("Initializing Q-Network...") hidden_dim1 = 64 #hidden_dim1 = 32 hidden_dim2 = 128 hidden_dim3 = 10 hidden_cont = 100 self.model = FunctionSet( l4=linearL4_link.LinearL4_link(self.dim * self.hist_size * self.time_M, hidden_cont, wscale=np.sqrt(2)), l5=MU_l6.memory_unit_link(self.dim * self.hist_size * self.time_M, hidden_dim3 * hidden_cont, wscale=np.sqrt(2)), l6=MU_l6.memory_unit_link(self.dim * self.hist_size * self.time_M, hidden_dim3 * hidden_cont, wscale=np.sqrt(2)), l7=attention.Attention(hidden_cont, hidden_dim3 * hidden_cont, hidden_dim3), l8=retrieval.Retrieval(hidden_dim3, hidden_dim3 * hidden_cont, hidden_cont), l9=F.Bilinear(hidden_cont, hidden_cont, hidden_dim2), q_value=F.Linear(hidden_dim2, self.num_of_actions, initialW=np.zeros( (self.num_of_actions, hidden_dim2), dtype=np.float32))) if self.use_gpu >= 0: self.model.to_gpu() self.model_target = copy.deepcopy(self.model) 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(now & 10history), a, r, s_dash, end_episode_flag] # modified to MQN self.d = [ np.zeros((self.data_size, self.hist_size * self.time_M, self.dim), 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, self.hist_size, self.dim), dtype=np.uint8), np.zeros((self.data_size, 1), dtype=np.bool) ]
def __init__(self, input_size=32): super(CNN3_Model, self).__init__() # F.Convolution2D(in_channel, out_channel, filter_size) self.model = FunctionSet( # 1*32*32 -(conv)-> 20*28*28 -(pool)-> 20*14*14 conv1=F.Convolution2D(1, 20, 5), # 20*14*14 -(conv)-> 50*10*10 -(pool)-> 50*5*5=1250 conv2=F.Convolution2D(20, 50, 5), l1=F.Linear(1250, 300), l2=F.Linear(300, 2))
def __init__(self, logging=False): model = FunctionSet(l1=F.Linear(784, 100), l2=F.Linear(100, 100), l3=F.Linear(100, 10)) optimizer = optimizers.SGD() lossFunction = F.softmax_cross_entropy params = {'epoch': 20, 'batchsize': 100, 'logging': logging} NNmanager.__init__(self, model, optimizer, lossFunction, **params)
def __init__(self, in_channels, out1, proj3, out3, proj5, out5, proj_pool): self.f = FunctionSet( conv1=Convolution2D(in_channels, out1, 1), proj3=Convolution2D(in_channels, proj3, 1), conv3=Convolution2D(proj3, out3, 3, pad=1), proj5=Convolution2D(in_channels, proj5, 1), conv5=Convolution2D(proj5, out5, 5, pad=2), projp=Convolution2D(in_channels, proj_pool, 1), )
def __init__(self, n_in, n_out, use_cuda=False): self.model = FunctionSet(transform=F.Linear(n_in, n_out)) self.use_cuda = use_cuda if self.use_cuda: self.model.to_gpu() self.optimizer = optimizers.Adam() self.optimizer.setup(self.model.collect_parameters())
def __init__(self): model = FunctionSet(l1_x = F.Linear(go.SIZE, 4 * go.SIZE), l1_h = F.Linear(4 * go.SIZE, 4 * go.SIZE), last = F.Linear(4 * go.SIZE, go.SIZE)) loss = F.softmax_cross_entropy() return
def __init__(self, num_inputs, num_units, dropout_ratio, corruption_level, optimizer, gpu): model = FunctionSet( encode=F.Linear(num_inputs, num_units), decode=F.Linear(num_units, num_inputs), ) self.layers = [model.encode, model.decode] super(DenoisingAutoEncoder, self).__init__(model, optimizer, dropout_ratio, corruption_level, gpu)
def __init__(self, n_in, n_hidden, use_cuda=False): self.model = FunctionSet(encode=F.Linear(n_in, n_hidden), decode=F.Linear(n_hidden, n_in)) self.use_cuda = use_cuda if self.use_cuda: self.model.to_gpu() self.optimizer = optimizers.Adam() self.optimizer.setup(self.model.collect_parameters())
def __init__(self,n_act): self.N_input = 64 N_output = n_act #N_unit = (self.N_input-1)*2 N_unit = 64 self.model = FunctionSet( l1=F.Linear(self.N_input,N_unit), #l2=F.Linear(N_unit, N_unit), #l3=F.Linear(N_unit, N_unit), l4=F.Linear(N_unit, N_output,initialW=np.zeros((N_output, N_unit), dtype=np.float32)))