def evaluation(model, supervisor): if cfg.dataset == 'imdb': teX, teY, num_te_batch = load_imdb(cfg.batch_size, cfg.words, cfg.length, is_training=False) elif cfg.dataset == 'ag': teX, teY, num_te_batch = load_ag(cfg.batch_size, cfg.length, is_training=False) cfg.is_training = False f_test_acc = save_to() with supervisor.managed_session(config=tf.ConfigProto( allow_soft_placement=True)) as sess: supervisor.saver.restore(sess, tf.train.latest_checkpoint(cfg.logdir)) tf.logging.info('Model restored...') test_acc = 0 for i in tqdm(range(num_te_batch), total=num_te_batch, ncols=70, leave=False, unit='b'): start = i * cfg.batch_size end = start + cfg.batch_size acc = sess.run(model.accuracy, { model.X: teX[start:end], model.Y: teY[start:end] }) test_acc += acc test_acc = test_acc / num_te_batch f_test_acc.write(str(test_acc)) f_test_acc.close() print('Test accuracy saved to ' + cfg.results + '/test_acc.csv') print('Test accuracy:', test_acc) return test_acc
from keras.preprocessing import sequence from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Embedding, LSTM, SimpleRNN, GRU from keras.layers import Convolution1D, GlobalMaxPooling1D from utils import load_imdb ########################## ## Preparing data ########################## # some parameters vocab_size = 5000 # number of words considered in the vocabulary train_split = 0.7 # ratio of train sentences # Preparing data is usually the most time-consuming part of machine learning. # Luckily for you, the imdb dataset has already been preprocessed and included in Keras. (X_train, y_train), (X_test, y_test) = load_imdb(nb_words=vocab_size, train_split=train_split) print(len(X_train), 'train sequences') print(len(X_test), 'test sequences') ## Padding input data # Models in Keras (and elsewhere) usually take as input batches of sentences of the same length. # Since sentences usually have different sizes, we "pad" sentences (we add a dummy "padding" token at the end of the # sentences. The input thus has this size : (batchsize, maxseqlen) where maxseqlen is the maximum length of a sentence # in the batch. maxlen = 80 # cut texts after this number of words (among top vocab_size most common words) X_train = sequence.pad_sequences(X_train, maxlen=maxlen) X_test = sequence.pad_sequences(X_test, maxlen=maxlen) print('X_train shape:', X_train.shape) print('X_test shape:', X_test.shape)
import numpy as np from sklearn.feature_extraction.text import CountVectorizer from scipy.sparse import csr_matrix from time import time from classifiers import TransparentMultinomialNB from utils import load_imdb, ce_squared, ClassifierArchive from pickle import dump # In[3]: t0 = time() vect = CountVectorizer(min_df=5, max_df=1.0, binary=False, ngram_range=(1, 1)) X_train, y_train, X_val, y_val, X_test, y_test, *_ = load_imdb("./aclImdb", shuffle=True, vectorizer=vect) feature_names = vect.get_feature_names() clf = TransparentMultinomialNB() clf.fit(X_train, y_train) ctrl_clf = clf y_test_na = y_test[:, np.newaxis] y_test_na = np.append(y_test_na, 1-y_test_na, axis=1) y_val_na = y_val[:, np.newaxis] y_val_na = np.append(y_val_na, 1-y_val_na, axis=1) y_modified = np.copy(y_train)
from classifiers import TransparentMultinomialNB from utils import ce_squared, load_imdb, ClassifierArchive from sklearn.feature_extraction.text import TfidfVectorizer from time import time from pickle import load, dump import numpy as np # In[2]: t0 = time() vect = TfidfVectorizer(min_df=5, max_df=1.0, binary=False, ngram_range=(1, 1)) X_train, y_train, X_test, y_test, train_corpus, test_corpus = load_imdb("./aclImdb", shuffle=True, vectorizer=vect) feature_names = vect.get_feature_names() y_test_na = y_test[:, np.newaxis] y_test_na = np.append(y_test_na, 1-y_test_na, axis=1) duration = time() - t0 print("Loading took {:0.2f}s.\n".format(duration)) # # Experiment # In[3]: with open('clf3.arch', 'rb') as f:
import numpy as np from sklearn.feature_extraction.text import CountVectorizer from time import time from scipy.sparse.construct import diags from utils import load_imdb if __name__ == '__main__': # Load the data print "Loading the data" t0 = time() vect = CountVectorizer(min_df=5, max_df=1.0, binary=True, ngram_range=(1, 1)) X_train, y_train, X_test, y_test, train_corpus, test_corpus = load_imdb("C:\\Users\\Mustafa\\Desktop\\aclImdb", shuffle=True, vectorizer=vect) feature_names = vect.get_feature_names() duration = time() - t0 print print "Loading took %0.2fs." % duration print print "Fitting the classifier" t0 = time() clf = TransparentLogisticRegression(penalty='l1', C=0.1) clf.fit(X_train, y_train) duration = time() - t0
if args.context == 'cudnn': from nnabla.ext_utils import get_extension_context ctx = get_extension_context('cudnn', device_id=args.device) nn.set_default_context(ctx) batch_size = 128 max_len = 400 embedding_size = 32 vocab_size = 20000 head_num = 8 hopping_num = 1 max_epoch = 20 l2_penalty_coef = 1e-4 x_train, x_test, y_train, y_test = load_imdb(vocab_size) for i, sentence in enumerate(tqdm(x_train)): x_train[i] = [vocab_size] + sentence for i, sentence in enumerate(tqdm(x_test)): x_test[i] = [vocab_size] + sentence x_train = with_padding(x_train, padding_type='post', max_sequence_length=max_len) x_test = with_padding(x_test, padding_type='post', max_sequence_length=max_len) y_train = y_train[:, None] y_test = y_test[:, None] num_train_batch = len(x_train) // batch_size num_dev_batch = len(x_test) // batch_size
def testMNB(): print "Loading the data" t0 = time() vect = CountVectorizer(min_df=5, max_df=1.0, binary=True, ngram_range=(1, 1)) X_train, y_train, X_test, y_test, train_corpus, test_corpus = load_imdb("C:\\Users\\mbilgic\\Desktop\\aclImdb", shuffle=True, vectorizer=vect) feature_names = vect.get_feature_names() duration = time() - t0 print print "Loading took %0.2fs." % duration print print "Fitting the classifier" t0 = time() clf = TransparentMultinomialNB() clf.fit(X_train, y_train) duration = time() - t0 print print "Fitting took %0.2fs." % duration print print "Predicting the evidences" t0 = time() neg_evi, pos_evi = clf.predict_evidences(X_test) duration = time() - t0 print print "Predicting evidences took %0.2fs." % duration print print "Predicting the probs" t0 = time() probs = clf.predict_proba(X_test) duration = time() - t0 print print "Predicting probs took %0.2fs." % duration print ti = TopInstances(neg_evi, pos_evi, clf.get_bias()) total_evi = neg_evi + pos_evi print print "Most negative" print i = ti.most_negatives()[0] print total_evi[i], neg_evi[i], pos_evi[i], probs[i] print test_corpus[i] print print "Most positive" print i = ti.most_positives()[0] print total_evi[i], neg_evi[i], pos_evi[i], probs[i] print test_corpus[i]
def train(model, supervisor): losses = [] accs = [] steps = [] val_accs = [] val_steps = [] if cfg.dataset == 'imdb': trX, trY, num_tr_batch, valX, valY, num_val_batch = load_imdb( cfg.batch_size, cfg.words, cfg.length, is_training=True) elif cfg.dataset == 'ag': trX, trY, num_tr_batch, valX, valY, num_val_batch = load_ag( cfg.batch_size, cfg.length, is_training=True) f_loss, f_train_acc, f_val_acc = save_to() config = tf.ConfigProto() config.gpu_options.allow_growth = True with supervisor.managed_session(config=config) as sess: print('\nSupervisor Prepared') for epoch in range(cfg.epoch): print('Training for epoch ' + str(epoch + 1) + '/' + str(cfg.epoch) + ':') if supervisor.should_stop(): print('Supervisor stopped') break for step in tqdm(range(num_tr_batch), total=num_tr_batch, ncols=70, leave=False, unit='b'): start = step * cfg.batch_size end = start + cfg.batch_size global_step = epoch * num_tr_batch + step if global_step % cfg.train_sum_freq == 0: _, loss, train_acc, summaries = sess.run([ model.train_op, model.total_loss, model.accuracy, model.train_summary ]) losses.append(loss) accs.append(train_acc) steps.append(global_step) assert not np.isnan(loss), 'loss is nan...' supervisor.summary_writer.add_summary( summaries, global_step) f_loss.write(str(global_step) + ',' + str(loss) + '\n') f_loss.flush() f_train_acc.write( str(global_step) + ',' + str(train_acc) + '\n') f_train_acc.flush() else: sess.run(model.train_op) if cfg.val_sum_freq != 0 and ( global_step) % cfg.val_sum_freq == 0: val_acc = 0 for i in range(num_val_batch): start = i * cfg.batch_size end = start + cfg.batch_size acc = sess.run(model.accuracy, { model.X: valX[start:end], model.Y: valY[start:end] }) val_acc += acc val_acc = val_acc / num_val_batch f_val_acc.write( str(global_step) + ',' + str(val_acc) + '\n') f_val_acc.flush() val_accs.append(val_acc) val_steps.append(global_step) if (epoch + 1) % cfg.save_freq == 0 and cfg.save: supervisor.saver.save( sess, cfg.logdir + '/model_epoch_{0:.4g}_step_{1:.2g}'.format( epoch, global_step)) if cfg.save: supervisor.saver.save( sess, cfg.logdir + '/model_epoch_{0:.4g}_step_{1:.2g}'.format(epoch, global_step)) f, (ax1, ax2) = plt.subplots(1, 2, sharey=False) ax1.set_title('Loss') ax1.plot(steps, losses) ax1.set_xlabel('Global step') ax1.set_ylabel('Loss') ax2.set_title('Accuracy') ax2.plot(val_steps, val_accs, color='b', label='val_accs') ax2.plot(steps, accs, color='r', label='train_accs') ax2.set_xlabel('Global step') ax2.set_ylabel('Accuracy') ax2.legend(loc='lower right') plt.show() f_loss.close() f_train_acc.close() f_val_acc.close() return losses[-1], accs[-1]
import torch from torch.autograd import Variable from utils import load_imdb from utils import bag_of_words import numpy as np batch_size = 100 train_iter, val_iter, test_iter, text_field = load_imdb(imdb_path='imdb.zip', imdb_dir='imdb', batch_size=batch_size, gpu=True, reuse=True, repeat=False, shuffle=True) V = len(text_field.vocab) # vocab size num_labels = 2 vocab_list = text_field.vocab.itos def build_model(input_dim, output_dim): model = torch.nn.Sequential() # computes w_c^T x + b_c model.add_module("linear", torch.nn.Linear(input_dim, output_dim).cuda()) # Compute our log softmax term. model.add_module("softmax", torch.nn.LogSoftmax().cuda()) return model def l1_logistic_loss(model, lambda_, fx, y): log_loss = torch.nn.NLLLoss(size_average = True) log_loss = log_loss.forward(fx, y) lasso_part = torch.nn.L1Loss(size_average = False) params = next(model.parameters()) target = Variable(torch.zeros(params.size()[0], params.size()[1]).cuda(), requires_grad=False) lasso_part = lasso_part.forward(params, target)