コード例 #1
0
ファイル: client.py プロジェクト: kiddyboots216/DecentML
 def get_initial_weights(self, model_type):
     tf.reset_default_graph()
     if model_type == "perceptron":
         m = Perceptron()
         inputs = tf.placeholder(tf.float32, shape=(None, 28 * 28))
         _ = m.get_model(features={"x": inputs},
                         labels=None,
                         mode='predict',
                         params=None)
     elif model_type == 'cnn-mnist':
         m = CNN()
         inputs = tf.placeholder(tf.float32, shape=(None, 28, 28, 1))
         _ = m.get_model(features={"x": inputs},
                         labels=None,
                         mode='predict',
                         params=None)
     elif model_type == 'cnn-cifar10':
         m = CNN()
         inputs = tf.placeholder(tf.float32, shape=(None, 32, 32, 3))
         _ = m.get_model(features={"x": inputs},
                         labels=None,
                         mode='predict',
                         params=None)
     else:
         raise ValueError(
             "Model {model_type} not supported.".format(model_type))
     with tf.Session().as_default() as sess:
         sess.run(tf.global_variables_initializer())
         collection = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)
         weights = {tensor.name: sess.run(tensor) for tensor in collection}
     tf.reset_default_graph()
     return weights
コード例 #2
0
ファイル: test.py プロジェクト: sndnyang/vat_chainer
def test(args):
    np.random.seed(1234)
    train, _, test = load_dataset(args.data_dir, valid=args.validation, dataset_seed=args.dataset_seed)
    print("N_train:{}".format(train.N))
    enc = CNN(n_outputs=args.n_categories, dropout_rate=args.dropout_rate)
    chainer.serializers.load_npz(args.trained_model_path, enc)
    if args.gpu > -1:
        chainer.cuda.get_device(args.gpu).use()
        enc.to_gpu()

    print("Finetune")
    for i in range(args.finetune_iter):
        x,_ = train.get(args.batchsize_finetune, gpu=args.gpu)
        enc(x)

    acc_sum = 0
    test_x, test_t = test.get()
    N_test = test.N
    for i in range(0, N_test, args.batchsize_eval):
        x = test_x[i:i + args.batchsize_eval]
        t = test_t[i:i + args.batchsize_eval]
        if args.gpu > -1:
            x, t = cuda.to_gpu(x, device=args.gpu), cuda.to_gpu(t, device=args.gpu)
        logit = enc(x, train=False)
        acc = F.accuracy(logit, t).data
        acc_sum += acc * x.shape[0]

    acc_test = acc_sum / N_test
    print("test acc: ", acc_test)
コード例 #3
0
 def get_predictions(self, frames, scope):
     frames = self._reshape_to_conv(frames)
     cnn = CNN()
     if self.operation == 'training':
         cnn_output = cnn.create_model(frames,
                                       cnn.conv_filters,
                                       keep_prob=self.keep_prob)
     else:
         cnn_output = cnn.create_model(frames,
                                       cnn.conv_filters,
                                       keep_prob=1.0)
     cnn_output = self._reshape_to_rnn(cnn_output)
     rnn = RNN()
     rnn_output = rnn.create_model(cnn_output, scope + '_rnn')
     if self.is_attention:
         attention = Attention(self.batch_size)
         attention_output = attention.create_model(rnn_output,
                                                   scope + '_attention')
         fc = FC(self.num_classes)
         outputs = fc.create_model(attention_output, scope + '_fc')
     else:
         rnn_output = rnn_output[:, -1, :]
         fc = FC(self.num_classes)
         outputs = fc.create_model(rnn_output, scope + '_fc')
     return outputs
コード例 #4
0
def GetDefaultCNN():
    cnn = CNN( in_features=(32,32,3),
                out_features=10,
                conv_filters=[32,32,64,64],
                conv_kernel_size=[3,3,3,3],
                conv_strides=[1,1,1,1],
                conv_pad=[0,0,0,0],
                max_pool_kernels=[None, (2,2), None, (2,2)],
                max_pool_strides=[None,2,None,2],
                use_dropout=False,
                use_batch_norm=False,
                actv_func=[None, "relu", None, "relu"],
                device=device
        )
    # Create MLP
    # Calculate the input shape
    s = cnn.GetCurShape()
    in_features = s[0]*s[1]*s[2]

    mlp = MLP(in_features,
                10,
                [],
                [],
                use_batch_norm=False,
                use_dropout=False,
                use_softmax=False,
                device=device)

    # mlp = DefaultCifar10MLP(device=device, in_features=in_features)

    cnn.AddMLP(mlp)
    return cnn
コード例 #5
0
ファイル: client.py プロジェクト: kiddyboots216/DecentML
 def setup_model(self, model_type):
     self.model_type = model_type
     if model_type == "perceptron":
         self.model = Perceptron()
     elif model_type == "cnn-mnist":
         self.model = CNN()
     elif model_type == "cnn-cifar10":
         self.model = CNN()
     else:
         raise ValueError("Model {0} not supported.".format(model_type))
コード例 #6
0
    def __init__(self, config, pad_idx, train_iter=None, valid_iter=None, test_iter=None):
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.config = config
        self.pad_idx = pad_idx

        # Train mode
        if self.config.mode == 'train':
            self.train_iter = train_iter
            self.valid_iter = valid_iter

        # Test mode
        else:
            self.test_iter = test_iter

        model_type = {
            'vanilla_rnn': RNN(self.config, self.pad_idx),
            'bidirectional_lstm': BidirectionalLSTM(self.config, self.pad_idx),
            'cnn': CNN(self.config),
        }

        self.model = model_type[self.config.model]
        self.model.to(self.device)

        # SGD updates all parameters with the 'same' learning rate
        # Adam adapts learning rate for each parameter
        optim_type = {
            'SGD': optim.SGD(self.model.parameters(), lr=self.config.lr),
            'Adam': optim.Adam(self.model.parameters()),
        }

        self.optimizer = optim_type[self.config.optim]

        # BCEWithLogitsLoss carries out both the sigmoid and the binary cross entropy steps.
        self.criterion = nn.BCEWithLogitsLoss()
        self.criterion.to(self.device)
コード例 #7
0
ファイル: predict_cnn.py プロジェクト: hereismari/ajna
def main(args):
    # Get dataset
    datasource = DataSource(None, [args.input_image],
                            shape=tuple(args.eye_shape),
                            data_format=args.data_format,
                            heatmap_scale=args.heatmap_scale)

    # Get model
    learning_schedule = [{
        'loss_terms_to_optimize': {
            'heatmaps_mse': ['hourglass'],
            'radius_mse': ['radius'],
        },
        'learning_rate': 1e-3,
    }]
    model = CNN(datasource.tensors,
                datasource.x_shape,
                learning_schedule,
                data_format=args.data_format)

    # Get evaluator
    evaluator = Trainer(model, model_checkpoint=args.model_checkpoint)

    # Predict
    output, losses = evaluator.run_predict(datasource)
    input_data = util.load_pickle(args.input_image)
    print('Losses', losses)
    util.plot_predictions(output, input_data, tuple(args.eye_shape))
コード例 #8
0
 def __init__(self, args, device, rel2id, word_emb=None):
     lr = args.lr
     lr_decay = args.lr_decay
     self.cpu = torch.device('cpu')
     self.device = device
     self.args = args
     self.max_grad_norm = args.max_grad_norm
     if args.model == 'pa_lstm':
         self.model = PositionAwareLSTM(args, rel2id, word_emb)
     elif args.model == 'bgru':
         self.model = BGRU(args, rel2id, word_emb)
     elif args.model == 'cnn':
         self.model = CNN(args, rel2id, word_emb)
     elif args.model == 'pcnn':
         self.model = PCNN(args, rel2id, word_emb)
     elif args.model == 'lstm':
         self.model = LSTM(args, rel2id, word_emb)
     else:
         raise ValueError
     self.model.to(device)
     self.criterion = nn.CrossEntropyLoss()
     self.parameters = [
         p for p in self.model.parameters() if p.requires_grad
     ]
     # self.parameters = self.model.parameters()
     self.optimizer = torch.optim.SGD(self.parameters, lr)
コード例 #9
0
 def __init__(self, args, device, rel2id, word_emb=None):
     lr = args.lr
     lr_decay = args.lr_decay
     self.cpu = torch.device('cpu')
     self.device = device
     self.args = args
     self.rel2id = rel2id
     self.max_grad_norm = args.max_grad_norm
     if args.model == 'pa_lstm':
         self.model = PositionAwareRNN(args, rel2id, word_emb)
     elif args.model == 'bgru':
         self.model = BGRU(args, rel2id, word_emb)
     elif args.model == 'cnn':
         self.model = CNN(args, rel2id, word_emb)
     elif args.model == 'pcnn':
         self.model = PCNN(args, rel2id, word_emb)
     elif args.model == 'lstm':
         self.model = LSTM(args, rel2id, word_emb)
     else:
         raise ValueError
     self.model.to(device)
     self.criterion = nn.CrossEntropyLoss()
     if args.fix_bias:
         self.model.flinear.bias.requires_grad = False
     self.parameters = [
         p for p in self.model.parameters() if p.requires_grad
     ]
     # self.parameters = self.model.parameters()
     self.optimizer = torch.optim.SGD(self.parameters, lr)
     self.scheduler = lr_scheduler.ReduceLROnPlateau(self.optimizer,
                                                     'min',
                                                     patience=3,
                                                     factor=lr_decay)
コード例 #10
0
ファイル: eval_cnn.py プロジェクト: hereismari/ajna
def main(args):
    # Get dataset
    test_files = glob.glob(os.path.join(args.test_path, '*.pickle'))
    datasource = DataSource(None,
                            test_files,
                            shape=tuple(args.eye_shape),
                            data_format=args.data_format,
                            heatmap_scale=args.heatmap_scale)

    # Get model
    learning_schedule = [{
        'loss_terms_to_optimize': {
            'heatmaps_mse': ['hourglass'],
            'radius_mse': ['radius'],
        },
        'learning_rate': 1e-3,
    }]
    model = CNN(datasource.tensors, datasource.x_shape, learning_schedule)

    # Get evaluator
    evaluator = Trainer(model, model_checkpoint=args.model_checkpoint)

    # Evaluate
    avg_losses = evaluator.run_eval(datasource)
    print('Avarage Losses', avg_losses)
コード例 #11
0
    def setup(self):
        # Load a Tensorflow model into memory.
        # If needed froze the graph to get better performance.
        data_format = self.args.data_format
        shape = tuple(self.args.eye_shape)
        preprocessor = ImgPreprocessor(data_format)
        datasource = ImgDataSource(shape=shape,
                                   data_format=data_format)
        # Get model
        model = CNN(datasource.tensors, datasource.x_shape, None,
                    data_format=data_format, predict_only=True)

        # Start session
        saver = tf.train.Saver()
        sess = tf.Session()

        # Init variables
        init = tf.global_variables_initializer()
        init_l = tf.local_variables_initializer()
        sess.run(init)
        sess.run(init_l)
        # Restore model checkpoint
        saver.restore(sess, self.args.model_checkpoint)

        return datasource, preprocessor, sess, model
コード例 #12
0
ファイル: train_cnn.py プロジェクト: hereismari/ajna
def main(args):
    # Get dataset
    train_files = glob.glob(os.path.join(args.train_path, '*.pickle'))
    eval_files = glob.glob(os.path.join(args.eval_path, '*.pickle'))
    datasource = DataSource(train_files,
                            eval_files,
                            shape=tuple(args.eye_shape),
                            batch_size=args.batch_size,
                            data_format=args.data_format,
                            heatmap_scale=args.heatmap_scale)

    # Get model
    learning_schedule = [
        {
            'loss_terms_to_optimize': {
                'heatmaps_mse': ['hourglass'],
                'radius_mse': ['radius'],
            },
            'learning_rate': 1e-3,
        },
    ]
    model = CNN(datasource.tensors, datasource.x_shape, learning_schedule)

    # Get trainer
    trainer = Trainer(model, eval_steps=args.eval_steps)

    # Train for 10000 steps
    return trainer.run_training(datasource, args.steps)
コード例 #13
0
 def multi_get_attention(self, frames):
     frames = self._reshape_to_conv(frames)
     cnn = CNN()
     cnn_output = cnn.create_model(frames, cnn.conv_filters)
     cnn_output = self._reshape_to_rnn(cnn_output)
     rnn = RNN()
     rnn_output = rnn.create_model(cnn_output)
     if self.is_attention:
         attention = Attention(self.batch_size)
         attention_output = attention.attention_analysis(rnn_output)
         return attention_output
     else:
         rnn_output = rnn_output[:, -1, :]
         fc = FC(self.num_classes)
         outputs = fc.create_model(rnn_output)
         return outputs
def main(args):
    model = CNN()
    chainer.serializers.load_npz(args.init_weights, model)
    model = chainer.links.Classifier(model)

    paths = glob.glob(os.path.join(args.dataset_dir, '**/*.wav'))
    testset = ESDataset(paths, label_index=args.label_index)

    y_targs = []
    y_preds = []
    for data in testset:
        x, y = data

        y_targs.append(int(y))
        y_preds.append(int(predict(model, x)))

    class_names = ['中立', '穏やか', '幸せ', '悲しみ', '怒り', '恐怖', '嫌悪', '驚き']

    accuracy = accuracy_score(y_targs, y_preds)
    plot_confusion_matrix(y_targs,
                          y_preds,
                          classes=class_names,
                          normalize=True,
                          title='{0} 精度:{1:.1%}'.format(args.title, accuracy))

    plt.savefig(os.path.join(args.out_dir, 'confusion_matrix.png'))
コード例 #15
0
ファイル: cnn_predictor.py プロジェクト: clover3/Chair
class CNNPredictor:
    def __init__(self, name= "WikiContrvCNN", input_name=None):
        if input_name is None:
            input_name = name
        self.hp = hyperparams.HPCNN()
        self.sess = init_session()
        self.sess.run(tf.global_variables_initializer())
        self.dropout_prob = tf.placeholder(tf.float32, name="dropout_keep_prob")
        self.seq_max = self.hp.seq_max
        self.word2idx = cache.load_cache(input_name+".voca")
        init_emb = cache.load_cache("init_emb_word2vec")
        self.model = CNN("controv", self.seq_max, 2, [2, 3, 4], 128,
                         init_emb, self.hp.embedding_size, self.dropout_prob)
        self.input_text = tf.placeholder(tf.int32,
                                       shape=[None, self.seq_max],
                                       name="comment_input")
        self.sout = self.model.network(self.input_text)
        self.tokenize = lambda x: tokenize(x, set(), False)

        loader = tf.train.Saver()
        loader.restore(self.sess, cpath.get_model_full_path(name))

    def encode(self, docs):

        def convert(word):
            if word in self.word2idx:
                return self.word2idx[word]
            else:
                return OOV

        data = []
        for doc in docs:
            entry = []
            for token in self.tokenize(doc):
                entry.append(convert(token))
            entry = entry[:self.seq_max]
            while len(entry) < self.seq_max:
                entry.append(PADDING)
            data.append((entry, 0))
        return data

    def score(self, docs):
        inputs = self.encode(docs)

        def forward_run(inputs):
            batches = get_batches_ex(inputs, self.hp.batch_size, 2)
            logit_list = []
            for batch in batches:
                x, y, = batch
                logits,  = self.sess.run([self.sout, ],
                                           feed_dict={
                                               self.input_text: x,
                                               self.dropout_prob: 1.0,
                                           })
                logit_list.append(logits)
            return np.concatenate(logit_list)

        output = forward_run(inputs)[:,1]
        return output
コード例 #16
0
ファイル: generic.py プロジェクト: xianyubai/fpl
def get_model(args):
    mean = np.array([640., 476.23620605, 88.2875590389])
    std = np.array([227.59802246, 65.00177002, 52.7303319245])
    if "scale" not in args.model:
        mean, std = mean[:2], std[:2]

    logger.info("Mean: {}, std: {}".format(mean, std))
    if args.model == "cnn" or args.model == "cnn_scale":
        model = CNN(mean, std, args.gpu, args.channel_list, args.deconv_list, args.ksize_list,
                    args.dc_ksize_list, args.inter_list, args.last_list, args.pad_list)
    elif args.model == "cnn_pose" or args.model == "cnn_pose_scale":
        model = CNN_Pose(mean, std, args.gpu, args.channel_list, args.deconv_list, args.ksize_list,
                         args.dc_ksize_list, args.inter_list, args.last_list, args.pad_list)
    elif args.model == "cnn_ego" or args.model == "cnn_ego_scale":
        model = CNN_Ego(mean, std, args.gpu, args.channel_list, args.deconv_list, args.ksize_list,
                        args.dc_ksize_list, args.inter_list, args.last_list, args.pad_list, args.ego_type)
    elif args.model == "cnn_ego_pose" or args.model == "cnn_ego_pose_scale":
        model = CNN_Ego_Pose(mean, std, args.gpu, args.channel_list, args.deconv_list, args.ksize_list,
                             args.dc_ksize_list, args.inter_list, args.last_list, args.pad_list, args.ego_type)
    else:
        logger.info("Invalid argument: model={}".format(args.model))
        exit(1)

    if args.resume != "":
        serializers.load_npz(args.resume, model)

    if args.gpu >= 0:
        model.to_gpu(args.gpu)

    return model
コード例 #17
0
def models(m):
    if m == 'rnn':
        return RNN(1, opt.hidden_size, opt.num_layers, 1, opt.cuda)
    elif m == 'lstm':
        return LSTM(1, opt.hidden_size, opt.num_layers, 1, opt.cuda)
    elif m == 'qrnn':
        return QRNN(1, opt.hidden_size, opt.num_layers, 1, opt.cuda)
    elif m == 'cnn':
        return CNN(1, opt.hidden_size, 1, opt.cuda)
コード例 #18
0
    def get_multi_predictions(self, frames):
        frames = self._reshape_to_conv(frames)
        cnn = CNN()
        if self.operation == 'training':
            cnn_output = cnn.create_model(frames,
                                          cnn.conv_filters,
                                          keep_prob=self.keep_prob)
        else:
            cnn_output = cnn.create_model(frames,
                                          cnn.conv_filters,
                                          keep_prob=1.0)
        cnn_output = self._reshape_to_rnn(cnn_output)
        rnn = RNN()
        arousal_rnn_output = rnn.create_model(cnn_output, 'arousal_rnn')
        valence_rnn_output = rnn.create_model(cnn_output, 'valence_rnn')
        dominance_rnn_output = rnn.create_model(cnn_output, 'dominance_rnn')
        if self.is_attention:
            attention = Attention(self.batch_size)
            arousal_attention_output = attention.create_model(
                arousal_rnn_output, 'arousal_attention')
            valence_attention_output = attention.create_model(
                valence_rnn_output, 'valence_attention')
            dominance_attention_output = attention.create_model(
                dominance_rnn_output, 'dominance_attention')
            fc = FC(self.num_classes)
            arousal_fc_outputs = fc.create_model(arousal_attention_output,
                                                 'arousal_fc')
            valence_fc_outputs = fc.create_model(valence_attention_output,
                                                 'valence_fc')
            dominance_fc_outputs = fc.create_model(dominance_attention_output,
                                                   'dominance_fc')
        else:
            arousal_rnn_output = arousal_rnn_output[:, -1, :]
            valence_rnn_output = valence_rnn_output[:, -1, :]
            dominance_rnn_output = dominance_rnn_output[:, -1, :]
            fc = FC(self.num_classes)
            arousal_fc_outputs = fc.create_model(arousal_rnn_output,
                                                 'arousal_fc')
            valence_fc_outputs = fc.create_model(valence_rnn_output,
                                                 'valence_fc')
            dominance_fc_outputs = fc.create_model(dominance_rnn_output,
                                                   'dominance_fc')

        return arousal_fc_outputs, valence_fc_outputs, dominance_fc_outputs
コード例 #19
0
    def __init__(self, filed=80):
        super(TD_LSTM, self).__init__()
        self.filed = filed
        self.cnn_l = CNN(self.filed)
        self.rnn_l = nn.LSTM(input_size=40,
                             hidden_size=64,
                             num_layers=4,
                             batch_first=True)

        self.cnn_r = CNN(self.filed)
        self.rnn_r = nn.LSTM(input_size=40,
                             hidden_size=64,
                             num_layers=4,
                             batch_first=True)

        self.linear = nn.Sequential(
            nn.Linear(128, 64),
            nn.Linear(64, 2),
        )
コード例 #20
0
ファイル: cnn_predictor.py プロジェクト: clover3/Chair
    def __init__(self, name= "WikiContrvCNN", input_name=None):
        if input_name is None:
            input_name = name
        self.hp = hyperparams.HPCNN()
        self.sess = init_session()
        self.sess.run(tf.global_variables_initializer())
        self.dropout_prob = tf.placeholder(tf.float32, name="dropout_keep_prob")
        self.seq_max = self.hp.seq_max
        self.word2idx = cache.load_cache(input_name+".voca")
        init_emb = cache.load_cache("init_emb_word2vec")
        self.model = CNN("controv", self.seq_max, 2, [2, 3, 4], 128,
                         init_emb, self.hp.embedding_size, self.dropout_prob)
        self.input_text = tf.placeholder(tf.int32,
                                       shape=[None, self.seq_max],
                                       name="comment_input")
        self.sout = self.model.network(self.input_text)
        self.tokenize = lambda x: tokenize(x, set(), False)

        loader = tf.train.Saver()
        loader.restore(self.sess, cpath.get_model_full_path(name))
コード例 #21
0
ファイル: MemNet.py プロジェクト: zdfcvsn/RSD
    def __init__(self, filed=80):
        super(MemNet, self).__init__()
        self.filed = filed
        self.cnn_l = CNN(filed=self.filed)

        self.attention = Attention(40, score_function='mlp')

        self.x_linear = nn.Sequential(nn.Linear(40, 40), )
        self.linear = nn.Sequential(
            nn.Linear(40, 64),
            nn.Linear(64, 2),
        )
コード例 #22
0
def get_predictor():
    dropout_keep_prob = tf.placeholder(tf.float32, name="dropout_keep_prob")
    cnn = CNN("agree",
              sequence_length=FLAGS.comment_length,
              num_classes=3,
              filter_sizes=[1, 2, 3],
              num_filters=64,
              init_emb=load_local_pickle("init_embedding"),
              embedding_size=FLAGS.embedding_size,
              dropout_prob=dropout_keep_prob)
    input_comment = tf.placeholder(tf.int32,
                                   shape=[None, FLAGS.comment_length],
                                   name="comment_input")
    #sout = model.cnn.network(input_comment)
    sout = cnn.network(input_comment)
    sess = init_session()
    batch_size = 512
    path = os.path.join(model_path, "runs", "agree", "model-36570")
    variables = tf.contrib.slim.get_variables_to_restore()
    for v in variables:
        print(v.name)
    loader = tf.train.Saver(variables)
    loader.restore(sess, path)

    def predict(comments):
        batches = get_batches_ex(comments, batch_size, 1)
        all_scores = []
        ticker = TimeEstimator(len(batches))
        for batch in batches:
            scores, = sess.run([sout],
                               feed_dict={
                                   input_comment: batch[0],
                                   dropout_keep_prob: 1.0,
                               })
            all_scores.append(scores)
            ticker.tick()

        return np.concatenate(all_scores)

    return predict
コード例 #23
0
    def __init__(self, prior, init_emb):
        self.comment_length = FLAGS.comment_length
        self.comment_count = FLAGS.comment_count
        self.embedding_size = FLAGS.embedding_size
        self.prior = prior
        self.dropout_keep_prob = tf.placeholder(tf.float32,
                                                name="dropout_keep_prob")

        self.input_comment = tf.placeholder(
            tf.int32,
            shape=[None, self.comment_count, self.comment_length],
            name="input_reaction")

        self.input_comment_y = tf.placeholder(
            tf.int32, shape=[None, self.comment_count],
            name="input_y_comment")  # agree label for comments

        self.input_y = tf.placeholder(tf.int32, shape=[
            None,
        ], name="input_y")  # Controversy Label

        self.cnn = CNN("agree",
                       sequence_length=self.comment_length,
                       num_classes=3,
                       filter_sizes=[1, 2, 3],
                       num_filters=64,
                       init_emb=init_emb,
                       embedding_size=self.embedding_size,
                       dropout_prob=self.dropout_keep_prob)
        self.score = self.controversy(self.input_comment)
        self.acc = accuracy(self.score, self.input_y, axis=1)
        self.agree_logit = self.predict_2d(self.input_comment)
        self.agree_acc = accuracy(self.agree_logit,
                                  self.input_comment_y,
                                  axis=2)
        self.agree_loss = tf.reduce_mean(
            tf.nn.sparse_softmax_cross_entropy_with_logits(
                logits=self.agree_logit, labels=self.input_comment_y))
コード例 #24
0
    def __init__(self, args):
        super(CNN_MLP, self).__init__()

        self.args = args

        self.device = args["device"]
        self.batch_size = args["batch_size"]
        self.input_dim = args["input_dim"]
        self.obs_len = args["input_length"]

        self.kernel_size = args["kernel_size"]
        self.nb_conv = args["nb_conv"]
        self.nb_kernel = args["nb_kernel"]
        self.cnn_feat_size = args["cnn_feat_size"]

        self.mlp_layers = args["mlp_layers"]
        self.output_size = args["output_size"]

        self.cnn = CNN(num_inputs=self.input_dim,
                       nb_kernel=self.nb_kernel,
                       cnn_feat_size=self.cnn_feat_size,
                       obs_len=self.obs_len,
                       kernel_size=self.kernel_size,
                       nb_conv=self.nb_conv)
        # self.cnn = nn.Sequential()
        # padding = int((self.kernel_size-1)/2.0)
        # for i in range(self.nb_conv):

        #     conv = nn.Conv1d(self.nb_kernel , self.nb_kernel , self.kernel_size, padding=padding)

        #     if i == 0:
        #         conv = nn.Conv1d(self.coord_embedding_size, self.nb_kernel , self.kernel_size, padding=padding)
        #     self.cnn.add_module("conv0",conv)

        # self.project_cnn = nn.Linear(self.obs_len*self.nb_kernel,self.cnn_feat_size)
        self.mlp = nn.Sequential()

        self.mlp.add_module("layer0",
                            nn.Linear(self.cnn_feat_size, self.mlp_layers[0]))

        self.mlp.add_module("relu0", nn.ReLU())
        for i in range(1, len(self.mlp_layers)):
            self.mlp.add_module(
                "layer{}".format(i),
                nn.Linear(self.mlp_layers[i - 1], self.mlp_layers[i]))
            self.mlp.add_module("relu{}".format(i), nn.ReLU())

        self.mlp.add_module("layer{}".format(len(self.mlp_layers)),
                            nn.Linear(self.mlp_layers[-1], self.output_size))
コード例 #25
0
    def __init__(self, filed=80):
        super(ATAE_LSTM, self).__init__()
        self.filed = filed
        self.cnn_l = CNN(filed=self.filed)
        self.rnn_l = nn.LSTM(input_size=110,
                             hidden_size=64,
                             num_layers=4,
                             batch_first=True)

        self.attention = NoQueryAttention(128, score_function='bi_linear')

        self.linear = nn.Sequential(
            nn.Linear(64, 64),
            nn.Linear(64, 2),
        )
def GetCNN():
    cnn = CNN(
        in_features=(32, 32, 3),
        out_features=10,
        conv_filters=[32, 32, 64, 64],
        conv_kernel_size=[3, 3, 3, 3],
        conv_strides=[1, 1, 1, 1],
        conv_pad=[0, 0, 0, 0],
        max_pool_kernels=[None, (2, 2), None, (2, 2)],
        max_pool_strides=[None, 2, None, 2],
        use_dropout=False,
        use_batch_norm=True,  #False
        actv_func=["relu", "relu", "relu", "relu"],
        device=device)

    return cnn
コード例 #27
0
 def setup_model(self, model_type):
     self.model_type = model_type
     if model_type == "perceptron":
         self.model = Perceptron()
         self.weights_metadata = self.model.get_weights_shape()
     elif model_type == "cnn":
         #TODO: Support CNN
         self.model = CNN()
     elif model_type == "lstm":
         #TODO: Support LSTM
         self.model = LSTM()
     elif model_type == "gan":
         self.model = ConversationalNetwork()
         self.model.build_model(is_retraining=True)
     else:
         raise ValueError("Model {0} not supported.".format(model_type))
コード例 #28
0
ファイル: IAN.py プロジェクト: zdfcvsn/RSD
    def __init__(self, filed = 80):
        super(IAN_LSTM, self).__init__()
        self.filed = filed
        self.cnn_l = CNN(filed=self.filed)
        self.rnn_l = nn.LSTM(
            input_size=55,
            hidden_size=64,
            num_layers=4,
            batch_first=True)

        self.attention_aspect = Attention(64, score_function='bi_linear')
        self.attention_context = Attention(64, score_function='bi_linear')


        self.linear = nn.Sequential(
                nn.Linear(128, 64),
                nn.Linear(64, 2),
        )
コード例 #29
0
ファイル: utils.py プロジェクト: sidsrini12/FURL_Sim
def get_model(args, parallel=True, ckpt_path=False):
    if args.clf == 'fcn':
        print('Initializing FCN...')
        model = FCN(args.input_size, args.output_size)
    elif args.clf == 'mlp':
        print('Initializing MLP...')
        model = MLP(args.input_size, args.output_size)
    elif args.clf == 'svm':
        print('Initializing SVM...')
        model = SVM(args.input_size, args.output_size)
    elif args.clf == 'cnn':
        print('Initializing CNN...')
        model = CNN(nc=args.num_channels, fs=args.cnn_view)
    elif args.clf == 'resnet18':
        print('Initializing ResNet18...')
        model = resnet.resnet18(num_channels=args.num_channels,
                                num_classes=args.output_size)
    elif args.clf == 'vgg19':
        print('Initializing VGG19...')
        model = VGG(vgg_name=args.clf,
                    num_channels=args.num_channels,
                    num_classes=args.output_size)
    elif args.clf == 'unet':
        print('Initializing UNet...')
        model = UNet(in_channels=args.num_channels,
                     out_channels=args.output_size)

    num_params, num_layers = get_model_size(model)
    print("# params: {}\n# layers: {}".format(num_params, num_layers))

    if ckpt_path:
        model.load_state_dict(torch.load(ckpt_path))
        print('Load init: {}'.format(ckpt_path))

    if parallel:
        model = nn.DataParallel(model.to(get_device(args)),
                                device_ids=args.device_id)
    else:
        model = model.to(get_device(args))

    loss_type = 'hinge' if args.clf == 'svm' else args.loss_type
    print("Loss: {}".format(loss_type))

    return model, loss_type
コード例 #30
0
def predict_cnn(config):
    # load tokenizer and torchtext Field
    pickle_tokenizer = open('pickles/tokenizer.pickle', 'rb')
    cohesion_scores = pickle.load(pickle_tokenizer)
    tokenizer = LTokenizer(scores=cohesion_scores)

    pickle_vocab = open('pickles/text.pickle', 'rb')
    text = pickle.load(pickle_vocab)

    model = CNN(config)

    model.load_state_dict(torch.load(config.save_model))
    model.to(device)
    model.eval()

    tokenized = tokenizer.tokenize(config.input)

    min_len = config.filter_sizes[-1]

    # if user's input sentence is shorter than the largest filter size, add pad tokens to input sentence
    if len(tokenized) < min_len:
        tokenized += ['<pad>'] * (min_len - len(tokenized))

    indexed = [text.vocab.stoi[token] for token in tokenized]
    length = [len(indexed)]

    tensor = torch.LongTensor(indexed).to(device)
    tensor = tensor.unsqueeze(1)
    length_tensor = torch.LongTensor(length)

    prediction = torch.sigmoid(model(tensor, length_tensor))
    label = torch.round(prediction)

    if label == 1:
        label = 'Positive'
    else:
        label = 'Negative'

    sentiment_percent = prediction.item()
    print(f'[in]  >> {config.input}')
    print(f'[out] >> {sentiment_percent*100:.2f} % : {label}')
コード例 #31
0
ファイル: run_CNN.py プロジェクト: chagge/kaldiproj
 
    train_dataset, train_dataset_args = read_data_args(train_data_spec)
    valid_dataset, valid_dataset_args = read_data_args(valid_data_spec)
    
    # reading data 
    train_sets, train_xy, train_x, train_y = read_dataset(train_dataset, train_dataset_args)
    valid_sets, valid_xy, valid_x, valid_y = read_dataset(valid_dataset, valid_dataset_args)

    numpy_rng = numpy.random.RandomState(89677)
    theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
    log('> ... building the model')
    # construct the cnn architecture
    cnn = CNN(numpy_rng=numpy_rng, theano_rng = theano_rng,
              batch_size = batch_size, n_outs=n_outs,
              conv_layer_configs = conv_layer_configs,
              hidden_layers_sizes = hidden_layers_sizes,
              conv_activation = conv_activation, 
              full_activation = full_activation,
              use_fast = use_fast, update_layers = update_layers)

    total_layer_number = len(cnn.layers)
    if full_ptr_layer_number > 0:
        _file2nnet(cnn.layers[len(conv_layer_configs):total_layer_number], set_layer_num = full_ptr_layer_number, filename = full_ptr_file,  withfinal=False)
    if conv_ptr_layer_number > 0:
        _file2cnn(cnn.layers[0:len(conv_layer_configs)], filename=conv_ptr_file)
    # get the training, validation and testing function for the model
    log('> ... getting the finetuning functions')
    train_fn, valid_fn = cnn.build_finetune_functions(
                (train_x, train_y), (valid_x, valid_y),
                batch_size=batch_size)
コード例 #32
0
ファイル: run_CNN.py プロジェクト: magic2du/dlnn
    if arguments.has_key('ptr_file') and arguments.has_key('ptr_layer_number'):
        ptr_file = arguments['ptr_file']
        ptr_layer_number = int(arguments['ptr_layer_number'])

    # check working dir to see whether it's resuming training
    resume_training = False
    if os.path.exists(wdir + '/nnet.tmp') and os.path.exists(wdir + '/training_state.tmp'):
        resume_training = True
        cfg.lrate = _file2lrate(wdir + '/training_state.tmp')
        log('> ... found nnet.tmp and training_state.tmp, now resume training from epoch ' + str(cfg.lrate.epoch))

    numpy_rng = numpy.random.RandomState(89677)
    theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
    log('> ... initializing the model')
    # construct the cnn architecture
    cnn = CNN(numpy_rng=numpy_rng, theano_rng = theano_rng, cfg = cfg)
    # load the pre-training networks, if any, for parameter initialization
    if (ptr_layer_number > 0) and (resume_training is False):
        _file2nnet(cnn.layers, set_layer_num = ptr_layer_number, filename = ptr_file)
    if resume_training:
        _file2nnet(cnn.layers, filename = wdir + '/nnet.tmp')

    # get the training, validation and testing function for the model
    log('> ... getting the finetuning functions')
    train_fn, valid_fn = cnn.build_finetune_functions(
                (cfg.train_x, cfg.train_y), (cfg.valid_x, cfg.valid_y),
                batch_size=cfg.batch_size)

    log('> ... finetunning the model')
    while (cfg.lrate.get_rate() != 0):
        # one epoch of sgd training