parser.add_argument('--analysis', type=int, default=0) args, _ = parser.parse_known_args(argv) logging.basicConfig( filename = ('log/%s.log' % args.name) * (1-args.screen), level=logging.DEBUG, format='%(asctime)s %(filename)s[line:%(lineno)d] %(message)s', datefmt='%H:%M:%S') logging.info('command: python ' + ' '.join(sys.argv)) dm = DataManager(args.dataset, {'negation': 'negation.txt', \ 'intensifier': 'intensifier.txt', \ 'sentiment': 'sentiment.txt'}) dm.gen_word_list() dm.gen_data() info_sent, info_words = dm.analysis() logging.info('sentence level for negation/intensifier/sentiment: %s' % info_sent) logging.info('words level for negation/intensifier/sentiment: %s' % info_words) model = Model(dm.words, dm.grained, argv) optimizer = OptimizerList[args.optimizer](model.params, args.lr, args.lr_vector) Evaluator = EvaluatorList[dm.grained] def do_test(label, data): evaluator = Evaluator() loss = .0 evaluator_neg = Evaluator() evaluator_int = Evaluator() for item_label, item_data in zip(label, data):
parser.add_argument('--dim_gram', type=int, default=1) parser.add_argument('--dataset', type=str, default='data') parser.add_argument('--fast', type=int, choices=[0, 1], default=0) parser.add_argument('--screen', type=int, choices=[0, 1], default=0) parser.add_argument('--optimizer', type=str, default='ADAGRAD') parser.add_argument('--grained', type=int, default=3) parser.add_argument('--lr', type=float, default=0.01) parser.add_argument('--lr_word_vector', type=float, default=0.1) parser.add_argument('--epoch', type=int, default=25) parser.add_argument('--batch', type=int, default=25) args, _ = parser.parse_known_args(argv) torch.random.manual_seed(args.seed) datamanager = DataManager(args.dataset, train=True) wordlist = datamanager.gen_word() train_data, val_data, test_data = datamanager.gen_data() model = Model(wordlist, argv, len(datamanager.dict_target)) batch_n = (len(train_data) - 1) // args.batch + 1 details = {'acc_train': [], 'acc_dev': [], 'acc_test': []} for epoch in range(args.epoch): np.random.shuffle(train_data) now = {} now['loss'], now['acc_train'] = train(model, train_data, batch_size=args.batch, batch_n=batch_n) now['sum_loss'] = torch.sum(now['loss']) _, now['acc_dev'] = test(model, val_data) _, now['acc_test'] = test(model, test_data)
## END SETTING UP DEFAULT HYPERPARAMETERS ## ############################################# args, _ = parser.parse_known_args( argv ) # Overwrite default hyperparameters if specified in command-line call random.seed(args.seed) # Will be used to shuffle training data print("### MAIN.PY: Initializing data set ...") data = DataManager( args.dataset ) # New instance of DataManage obect, defined in DataManager.py print("### MAIN.PY: Preparing list of words from dictionary...") wordlist = data.gen_word() # Get comprehensive list of words from data print("### MAIN.PY: Formatting data...") train_data, dev_data, test_data = data.gen_data( args.grained) # Store formatted data retrieved from *.cor files print("### MAIN.PY: Initializing model...") model = Model( wordlist, argv, len(data.dict_target) ) # Initialize new model (specified in lstm_att_con.py in this case) batch_n = int( (len(train_data) - 1) / args.batch + 1) # Determine the number of batches to split training data into print("### MAIN.PY: Initializing optimizer...") optimizer = OptimizerList[args.optimizer]( model.params, args.lr, args.lr_word_vector ) # Intialize instance of OptimizerList (defined as ADAGRAD object in Optimizer.py) details = {'loss': [], 'loss_train':[], 'loss_dev':[], 'loss_test':[], \ 'acc_train':[], 'acc_dev':[], 'acc_test':[], 'loss_l2':[]} # Initiaize sections of result data that will be printed to final results file ##########################################
def run(args): config = tf.ConfigProto() config.allow_soft_placement = True config.gpu_options.allow_growth = True tf.add_to_collection('graph_config', config) logging.basicConfig( filename=('log/%s.log' % args.name) * (1 - args.screen), level=logging.DEBUG, format='%(asctime)s %(filename)s[line:%(lineno)d] %(message)s', datefmt='%H:%M:%S') logging.info('----------run------------') logging.info("args: " + str(args.__dict__)) dm = DataManager(args.dataset) if args.cache == 0: dm.gen_word_list() dm.gen_data() pickle.dump(dm, open("./cache/data_dump", "wb"), -1) else: dm = pickle.load(open("./cache/data_dump", "rb")) trainY, trainX, trainLength = dm.gen_batch('train', length=args.sentence_length) devY, devX, devLength = dm.gen_batch('dev', length=args.sentence_length) testY, testX, testLength = dm.gen_batch('test', length=args.sentence_length) logging.info('----------input data ok------------') input = tflearn.input_data([None, args.sentence_length], name="input") seq_length = tflearn.input_data([None], name="input_len", dtype=tf.int32) wordLoader = WordLoader() wordvec = wordLoader.genWordVec(args.word_vector, dm.words, args.dim_w) embedding = tflearn.embedding( input, input_dim=len(dm.words) + 1, output_dim=args.dim_w, weights_init=tf.constant_initializer(wordvec)) #phrase = PhraseLayer(embedding, input_dim = args.dim_w, output_dim = (args.dim_r, args.dim_rp), output_length = args.choose_num, activation = 'prelu', dropout_keepprob = args.keep_drop, batchNorm = True) #policy = separate_policy(args.policy_dim, activation='prelu',keepdrop = args.keep_drop) #hidden, action = SlstmLayer(phrase, seq_length, input_dim = (args.dim_r, args.dim_rp), output_dim = (args.dim_h, args.dim_hp), policy = policy, dropout_keepprob = args.keep_drop, pooling = False, update = "straight") #hidden = tflearn.lstm(phrase[0][:,:,0,:], args.dim_h) hidden = tflearn.lstm(embedding, args.dim_h, dynamic=True) predict_y = ClassifyLayer(hidden, dim=args.dim_c, keepdrop=args.keep_drop, activation='sigmoid') #predict_y = tf.Print(predict_y, [predict_y], summarize = 10) net = tflearn.regression(predict_y, optimizer='adam', learning_rate=args.learning_rate, loss='categorical_crossentropy') for i in tf.trainable_variables(): print i # Training model = tflearn.DNN(net, tensorboard_verbose=3) model.fit({ "input": trainX, "input_len": trainLength }, trainY, n_epoch=30, validation_set=({ "input": devX, "input_len": devLength }, devY), show_metric=True, batch_size=32) # regularize # normalization # blstm
parser.add_argument('--fast', type=int, choices=[0, 1], default=0) parser.add_argument('--screen', type=int, choices=[0, 1], default=0) parser.add_argument('--optimizer', type=str, default='ADAGRAD') parser.add_argument('--grained', type=int, default=3) parser.add_argument('--lr', type=float, default=0.001) parser.add_argument('--lr_word_vector', type=float, default=0.1) parser.add_argument('--epoch', type=int, default=15) parser.add_argument('--batch', type=int, default=25) parser.add_argument('--is_train', type=bool, default=False) args, _ = parser.parse_known_args(argv) is_train = args.is_train random.seed(args.seed) if is_train: data = DataManager(args.dataset) wordlist = data.gen_word() train_data, test_data, classify_data = data.gen_data(args.grained) model = Model(wordlist, argv, len(data.dict_target)) batch_n = (len(train_data)-1) / args.batch + 1 optimizer = OptimizerList[args.optimizer](model.params, args.lr, args.lr_word_vector) details = {'loss': [], 'loss_train':[], 'loss_dev':[], 'loss_test':[], \ 'acc_train':[], 'acc_dev':[], 'acc_test':[], 'loss_l2':[]} index_to_word=[] index_to_word=data.index_to_word f=open('word.txt','wb') for word in index_to_word: f.write(word) f.write('\n') for e in range(args.epoch): print('train %d epoch:' %e) random.shuffle(train_data)
parser.add_argument('--name', type=str, default='lstm') parser.add_argument('--seed', type=int, default=int(1000 * time.time())) parser.add_argument('--dim_hidden', type=int, default=100) # 默认300 parser.add_argument('--dim_gram', type=int, default=1) parser.add_argument('--dataset', type=str, default='data') parser.add_argument('--fast', type=int, choices=[0, 1], default=0) parser.add_argument('--screen', type=int, choices=[0, 1], default=0) parser.add_argument('--grained', type=int, default=3) parser.add_argument('--epoch', type=int, default=10) parser.add_argument('--batch_size', type=int, default=50) args, _ = parser.parse_known_args(argv) ##1 random.seed(args.seed) data = DataManager(args.dataset) ##数据载入 wordlist = data.gen_word() train_data, dev_data, test_data = data.gen_data(args.grained) model = Model(wordlist, argv, len(data.dict_target)) batch_n = (len(train_data) - 1) / args.batch_size + 1 # optimizer = OptimizerList[args.optimizer](model.params, args.lr, args.lr_word_vector) details = {'loss': [], 'loss_train': [], 'loss_dev': [], 'loss_test': [], \ 'acc_train': [], 'acc_dev': [], 'acc_test': [], 'loss_l2': []} print("\r\n" + time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) + "###########begin training######") print(datetime.now()) x = [] loss_train = [] loss_test = [] acc_train = [] acc_test = []
parser.add_argument('--dim_gram', type=int, default=1) parser.add_argument('--dataset', type=str, default='data') parser.add_argument('--fast', type=int, choices=[0, 1], default=0) parser.add_argument('--screen', type=int, choices=[0, 1], default=0) parser.add_argument('--optimizer', type=str, default='ADAGRAD') parser.add_argument('--grained', type=int, default=3) parser.add_argument('--lr', type=float, default=0.01) parser.add_argument('--lr_word_vector', type=float, default=0.1) parser.add_argument('--epoch', type=int, default=25) parser.add_argument('--batch', type=int, default=25) args, _ = parser.parse_known_args(argv) random.seed(args.seed) data = DataManager(args.dataset) wordlist = data.gen_word() train_data, dev_data, test_data = data.gen_data(args.grained) model = Model(wordlist, argv, len(data.dict_target)) #batch_n = (len(train_data)-1) / args.batch + 1 batch_n = int((len(train_data) - 1) / args.batch + 1) optimizer = OptimizerList[args.optimizer](model.params, args.lr, args.lr_word_vector) details = {'loss': [], 'loss_train':[], 'loss_dev':[], 'loss_test':[], \ 'acc_train':[], 'acc_dev':[], 'acc_test':[], 'loss_l2':[]} for e in range(args.epoch): random.shuffle(train_data) now = {} now['loss'], now['loss_l2'] = train(model, train_data, optimizer, e, args.batch, batch_n) now['loss_train'], now['acc_train'] = test(model, train_data, args.grained) now['loss_dev'], now['acc_dev'] = test(model, dev_data, args.grained) now['loss_test'], now['acc_test'] = test(model, test_data, args.grained) for key, value in list(now.items()):