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()):
