def create_vocab():
DBHelperMethod.connect_to_db()
dataset = DBHelperMethod.load_data_set()
chars = dp.load_nn_input_dataset_string(dataset[:, [0, 6]])
vocab, vocab_inv = dp.build_vocab(chars)
return vocab, vocab_inv, chars, dataset
def convert_input_to_vocab(input):
sequence_list = numpy.array(input)
vocabulary, vocabulary_inv = dp.build_vocab(sequence_list)
sentences = list(chain(*sequence_list))
padded_input = dp.build_input_data2(sentences, vocabulary)
return numpy.array(padded_input), vocabulary, vocabulary_inv
def main(_):
FLAGS = tf.app.flags.FLAGS
pp = pprint.PrettyPrinter()
FLAGS._parse_flags()
pp.pprint(FLAGS.__flags)
# Load Data
X_train, Q_train, Y_train = data_helper.load_data('train')
X_test, Q_test, Y_test = data_helper.load_data('valid')
vocab_size = np.max(X_train) + 1
print('[?] Vocabulary Size:', vocab_size)
# Create directories
if not os.path.exists(FLAGS.ckpt_dir):
os.makedirs(FLAGS.ckpt_dir)
timestamp = datetime.now().strftime('%c')
FLAGS.log_dir = os.path.join(FLAGS.log_dir, timestamp)
if not os.path.exists(FLAGS.log_dir):
os.makedirs(FLAGS.log_dir)
# Train Model
with tf.Session(config=tf.ConfigProto(
log_device_placement=False,
allow_soft_placement=True)) as sess, tf.device('/gpu:0'):
model = AlternatingAttention(FLAGS.batch_size,
vocab_size,
FLAGS.encoding_dim,
FLAGS.embedding_dim,
FLAGS.num_glimpses,
session=sess)
if FLAGS.trace: # Trace model for debugging
train.trace(FLAGS, sess, model, (X_train, Q_train, Y_train))
return
saver = tf.train.Saver()
if FLAGS.restore_file is not None:
print('[?] Loading variables from checkpoint %s' %
FLAGS.restore_file)
saver.restore(sess, FLAGS.restore_file)
# Run evaluation
if FLAGS.evaluate:
if not FLAGS.restore_file:
print('Need to specify a restore_file checkpoint to evaluate')
else:
test_data = data_helper.load_data('test')
word2idx, _, _ = data_helper.build_vocab()
test.run(FLAGS, sess, model, test_data, word2idx)
else:
train.run(FLAGS, sess, model, (X_train, Q_train, Y_train),
(X_test, Q_test, Y_test), saver)
def main(_):
FLAGS = tf.app.flags.FLAGS
pp = pprint.PrettyPrinter()
FLAGS._parse_flags()
pp.pprint(FLAGS.__flags)
# Load Data
X_train, Q_train, Y_train = data_helper.load_data('train')
X_test, Q_test, Y_test = data_helper.load_data('valid')
vocab_size = np.max(X_train) + 1
print('[?] Vocabulary Size:', vocab_size)
# Create directories
if not os.path.exists(FLAGS.ckpt_dir):
os.makedirs(FLAGS.ckpt_dir)
timestamp = datetime.now().strftime('%c')
FLAGS.log_dir = os.path.join(FLAGS.log_dir, timestamp)
if not os.path.exists(FLAGS.log_dir):
os.makedirs(FLAGS.log_dir)
# Train Model
with tf.Session(config=tf.ConfigProto(log_device_placement=False, allow_soft_placement=True)) as sess, tf.device('/gpu:0'):
model = AlternatingAttention(FLAGS.batch_size, vocab_size, FLAGS.encoding_dim, FLAGS.embedding_dim, FLAGS.num_glimpses, session=sess)
if FLAGS.trace: # Trace model for debugging
train.trace(FLAGS, sess, model, (X_train, Q_train, Y_train))
return
saver = tf.train.Saver()
if FLAGS.restore_file is not None:
print('[?] Loading variables from checkpoint %s' % FLAGS.restore_file)
saver.restore(sess, FLAGS.restore_file)
# Run evaluation
if FLAGS.evaluate:
if not FLAGS.restore_file:
print('Need to specify a restore_file checkpoint to evaluate')
else:
test_data = data_helper.load_data('test')
word2idx, _, _ = data_helper.build_vocab()
test.run(FLAGS, sess, model, test_data, word2idx)
else:
train.run(FLAGS, sess, model,
(X_train, Q_train, Y_train),
(X_test, Q_test, Y_test),
saver)
def load_data(data_path):
"""
Loads and preprocessed data for the MR dataset.
Returns input vectors, labels, vocabulary, and inverse vocabulary.
"""
# Load and preprocess data
sentences, labels,label_inv = load_data_and_labels(data_path)
vocabulary, vocabulary_inv =data_helper.build_vocab(sentences)
x, y = build_input_data(sentences, labels, vocabulary)
print('before adding noise train case number in every category')
count_category(y,label_inv)
x,y=noise_input_data(x,y,vocabulary)
print('after adding noise train case number in every category')
count_category(y,label_inv)
return [x, y, vocabulary, vocabulary_inv,label_inv]
def load_testing_data():
dp.establish_db_connection()
training_dataset = DBHelperMethod.load_dataset_by_type("testing")
x = dp.load_nn_input_dataset_string_space_only(training_dataset[:, [0, 6]])
y = dp.load_nn_labels_dataset_string(training_dataset[:, [0, 1]])
vocab, vocab_inv = dp.build_vocab(x)
sent_num, sen_len = dp.load_nn_seq_lengths(training_dataset[:, [3]])
input_sentences = sqp.create_window_of_chars(list(x), window_size)
input_sentences = dp.build_input_data_without_flattening(
input_sentences, vocab)
input_sentences = numpy.array(input_sentences[:-1])
output_labels = sqp.create_window_of_chars(list(y), window_size)
output_labels = numpy.array(output_labels[:-1])
return input_sentences, output_labels, vocab, vocab_inv
def predict(config, model):
model_path = os.path.join(config.save_path, "model.ckpt")
model.load_state_dict(torch.load(model_path))
model.eval()
char2index, _ = build_vocab()
index2label = {index: label for index, label in enumerate(config.labels)}
with torch.no_grad():
while True:
input_line = input("input your sentence >>>")
input_index = [char2index[char] for char in input_line]
input_index = torch.tensor([input_index]).to(config.device)
output = model(input_index)
output_arg = torch.argmax(output, dim=1)
output_arg = output_arg.numpy().tolist()
output = output.numpy().tolist()
print("target label: [{label}] with props: {props}".format(
label=index2label[output_arg[0]], props=output[0]))
def load_test_data(test_file, labels):
df = pd.read_csv(test_file)
select = ['Descript']
df = df.dropna(axis=0, how='any', subset=select)
test_examples = df[select[0]].apply(
lambda x: data_helper.clean_str(x).split(' ')).tolist()
vocabulary, vocabulary_inv = data_helper.build_vocab(test_examples)
x = np.array([[vocabulary[word] for word in sentence]
for sentence in test_examples])
num_labels = len(labels)
one_hot = np.zeros((num_labels, num_labels), int)
np.fill_diagonal(one_hot, 1)
label_dict = dict(zip(labels, one_hot))
y_ = None
if 'Category' in df.columns:
select.append('Category')
y_ = df[select[1]].apply(lambda x: label_dict[x]).tolist()
not_select = list(set(df.columns) - set(select))
df = df.drop(not_select, axis=1)
return x, y_, df
train_summary_writer.flush()
timestr = datetime.datetime.now().isoformat()
logging.info("%s, the %i step, train cost is:%f and the train accuracy is %6.7f"%(timestr, global_steps, cost, accuracy))
if(global_steps % FLAGS.evaluate_every == 0):
valid_accuracy = evaluate(valid_model,session,valid_data,global_steps)
logging.info("%s, the valid accuracy is %f"%(timestr, valid_accuracy))
global_steps += 1
return global_steps
#---------------------------- run epoch end -------------------------------------
#------------------------------------load data -------------------------------
word2idx, idx2word = build_vocab(FLAGS.word_file)
label2idx, idx2label = load_label(FLAGS.label_file)
train_x, train_y, train_mask = load_data(FLAGS.train_file, word2idx, label2idx, FLAGS.sequence_len)
logging.info("load train data finish")
train_data, valid_data = create_valid(zip(train_x, train_y, train_mask))
num_classes = len(label2idx)
embedding = load_embedding(FLAGS.embedding_size, filename=FLAGS.embedding_file)
test_x, test_y, test_mask = load_data(FLAGS.test_file, word2idx, label2idx, FLAGS.sequence_len)
logging.info("load test data finish")
#----------------------------------- load data end ----------------------
#----------------------------------- execute train ---------------------------------------
with tf.Graph().as_default():
with tf.device("/cpu:0"):
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=FLAGS.gpu_options)
session_conf = tf.ConfigProto(allow_soft_placement=FLAGS.allow_soft_placement, log_device_placement=FLAGS.log_device_placement, gpu_options=gpu_options)
" the real selectd set from the The sampled pools")
tf.flags.DEFINE_integer("gan_k", 10, "he number of samples of gan")
# Misc Parameters
tf.flags.DEFINE_boolean("allow_soft_placement", True,
"Allow device soft device placement")
tf.flags.DEFINE_boolean("log_device_placement", False,
"Log placement of ops on devices")
FLAGS = tf.flags.FLAGS
FLAGS.flag_values_dict()
timeStamp = time.strftime("%Y%m%d%H%M%S", time.localtime(int(time.time())))
print(("Loading data..."))
vocab = data_helper.build_vocab()
embeddings = data_helper.load_vectors(vocab)
alist = data_helper.read_alist("WebAP")
raw = data_helper.read_raw("WebAP")
qs = data_helper.qname("WebAP/qeo-train.txt")
number = data_helper.qid("WebAP/qeo-train.txt")
numbertest = data_helper.qid("WebAP/qeo-test.txt")
qstest = data_helper.qname("WebAP/qeo-test.txt")
# 加载了几个测试集
test_List = data_helper.loadTestSet(dataset="WebAP", filename="term-test")
train_List = data_helper.loadTestSet(dataset="WebAP", filename="term-train")
print("Load done...")
log_gan_train_ndcg = 'WebAP/log/log_gan_train_ndcg'
log_gan_test_ndcg = 'WebAP/log/log_gan_test_ndcg'
def test_build_vocab():
file_path_1 = "./data/source.txt"
file_path_2 = "./data/target.txt"
output_path = "./data/vocab.txt"
build_vocab(file_path_list=[file_path_1, file_path_2],
output_path=output_path)
def train_cnn():
global my_min # by odg
# 오리지널 파일로부터 입력과 출력값을 배열로 만들어내기. 또한 CNN의 설정값 또한 파일로서 읽기
"""Step 0: load sentences, labels, and training parameters"""
# 파라미터로 받은 파일을 로딩해서 문장배열(x_raw)과 각 문장들의 분류값배열(y_raw)을 얻어낸다. x는 뉴럴넷의 input이로, y는 output이다.
train_file = sys.argv[1]
# CNN네트워크의 각종 세부 설정값(hyper parameter)들을 로딩한다. 이 안에는 num_epochs, batch_size, num_filters등의 값들이 들어있다.
x_raw, y_raw, df, labels = data_helper.load_data_and_labels(
train_file) # @
# x_raw는 데이터셋, y_raw는 label의 One-hot vector, df는 라벨 포함 데이터셋, labels는 라벨 들어가있음.
parameter_file = sys.argv[2]
params = json.loads(open(parameter_file).read())
model_dir = sys.argv[3] # 모델 폴더 이름
max_document_length = 0
minimum_frequency = 5 # 단어장에 넣을 단어의 최소한의 빈도수(해당 빈도수 이상 있어야 단어장에 등록)
list_max_final_scores = [] # final_scores 들 중 가장 큰 값만 저장한 리스트 by odg
if (model_dir == "new"):
timestamp = str(int(time.time()))
model_name = "./trained_model_" + timestamp
# 학습내용을 기록할 디렉토리 정의
out_dir = os.path.abspath(os.path.join(os.path.curdir,
model_name)) # !새롭게 생기는 폴더.
checkpoint_dir = os.path.abspath(os.path.join(out_dir, "checkpoints"))
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
vectorize_list = list(mytoken.tokenizer(x_raw))
for i in vectorize_list:
if max_document_length < len(i):
max_document_length = len(i)
word2Vec = Word2Vec(vectorize_list,
size=params['embedding_dim'] -
params['num_of_class'],
window=3,
min_count=minimum_frequency,
workers=4)
word2Vec.save(model_name + "/word2Vec.vec") # @
fastText = FastText(vectorize_list,
size=params['embedding_dim'] -
params['num_of_class'],
window=3,
min_count=minimum_frequency,
workers=4)
fastText.save(model_name + "/fastText.vec") # @
vocab_dict, _ = data_helper.build_vocab(max_document_length,
word2Vec.wv.index2word,
params['num_of_class'], True)
# 학습내용중 Tensorflow 내부의 변수상태가 저장됨 (예:AdamOptimizer)
else:
out_dir = os.path.abspath(os.path.join(model_dir))
checkpoint_dir = os.path.abspath(os.path.join(out_dir, "checkpoints"))
vocab_dict, max_document_length = data_helper.build_vocab(
0, None, None, False)
model_name = model_dir
checkpoint_prefix = os.path.join(checkpoint_dir, "model")
# 전체 문장을 동일한 크기로 맞추고, 단어마다 ID를 부여해서, ID로 이루어진 문장을 만들기
"""Step 1: pad each sentence to the same length and map each word to an id"""
# 문장배열의 크기를 pad값을 사용해서 같은 크기로 맞추어 주고, 문장안의 단어들을 ID로 매핑시켜주는 작업을 통해 학습 문장을 숫자 매트릭스형태로 만들어 학습이 가능한 상태로 만든다.
logging.info('가장 긴 길이의 문장: {}'.format(max_document_length)) # 21
vocab_processor = learn.preprocessing.VocabularyProcessor(
max_document_length=max_document_length,
vocabulary=vocab_dict,
tokenizer_fn=mytoken.tokenizer) # 데이터셋의 단어들에 대해 인덱스를 붙여주는... #!
x = np.array(list(vocab_processor.transform(x_raw))) # !
vocab_dictionary = vocab_processor.vocabulary_._mapping # !
y = np.array(y_raw) # y는 라벨에 대한 One-hot vector
# 데이터셋을 학습용과 테스트용으로 나누기
"""Step 2: split the original dataset into train and test sets"""
x_, x_test, y_, y_test = train_test_split(x,
y,
test_size=0.1,
random_state=42)
# 학습 문장과 결과값을 학습과 테스트 두개의 그룹으로 나눈다.(10%만 검증용으로 사용한다)
# 데이터셋을 임의로 배치하고, 학습 데이터를 학습용과 검증용으로 다시 분류하기.
"""Step 3: shuffle the train set and split the train set into train and dev sets"""
# 학습용 문장 배열(x_)의 순서를 그때마다 다르게 하기 위해 random방식으로 배열의 순서를 바꾸는 과정이다.
# 학습데이터를 다시 두개의 그룹으로 나누는 것은 학습과 검증을 나눔으로서 overfitting을 줄이고 학습의 효과를 확인하기 쉽게 하기 위해서이다. 전체 데이터셋 구성은 다음과 같다. https://blog.naver.com/2feelus/221005831312 에서 확인.
shuffle_indices = np.random.permutation(np.arange(len(y_))) # 인덱스를 섞어줌
x_shuffled = x_[
shuffle_indices] # 데이터셋에서 랜덤으로 셔플된 문장 인덱스 가져옴 ex) [5 69 0 ... 0]
y_shuffled = y_[shuffle_indices] # 해당 데이터셋에 대한 라벨 One-hot vector를 가져옴
x_train, x_dev, y_train, y_dev = train_test_split(x_shuffled,
y_shuffled,
test_size=0.1)
# 카테고리 라벨을 파일로 저장하여, 예측시에 활용할수 있도록 하기
# 전체 카테고리 라벨들이 label.json 파일의 내용으로 저장. 실제 예측시에 이파일에 저장된 카테고리 순서에 따라 예측값을 얻어낸다.
with open('./labels.json', 'w', encoding='utf-8-sig') as outfile: # by odg
json.dump(labels, outfile, indent=4, ensure_ascii=False) # by odg
logging.info('x_train: {}, x_dev: {}, x_test: {}'.format(
len(x_train), len(x_dev), len(x_test)))
logging.info('y_train: {}, y_dev: {}, y_test: {}'.format(
len(y_train), len(y_dev), len(y_test)))
# 텐서 플로우 그래프생성이후 CNN 객체를 생성하기
"""Step 5: build a graph and cnn object"""
# 텐서플로우에서 머신러닝의 데이터 흐름을 표현하는 그래프를 새로 생성한다. 그래프는 여러가지 머신러닝용 계산 명령 객체들을 포함하고 있다.
graph = tf.Graph()
# 파이선의 Context Manager 개념을 사용하여 기존의 기본 그래프 객체를 위에서 선언한 graph 객체로 대체하여 내부 블럭에 적용한다.
# 멀티프로세스로 돌아가는 환경에서 이러한 방식을 사용하여 쓰레드에서 각각의 그래프 객체를 사용하도록 한다.
with graph.as_default():
# 세션을 새로 생성한다. 세션의 설정옵션으로 GPU를 특정하지 않기(allow_soft_placement=True),
# 연산이 어느디바이스로 설정되었는지 보여주여주지 않기(log_device_placement=False)
session_conf = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
sess = tf.InteractiveSession(config=session_conf) # !!
# 세션또한 Context manager를 사용하여 세션의 열고 닫는 처리를 자동으로 해준다.
with sess.as_default():
# CNN객체를 생성한다. 파라미터 = 문장의 최대길이(sequence_length):912, 분류 카테고리수(num_classes):11,
# 사전에 등록된 단어수(vocab_size):52943, 워드임베딩 사이즈(embedding_size):50,
# CNN필터(커널)의 크기는 3x3,4x4,5x5 , 필터의 갯수는 총 32 개,
# 오버피팅 방지를 위한 가중치 영향력 감소 수치(l2_reg_lambda):0.0
cnn = TextCNN(
sequence_length=x_train.shape[1], # 들어온 문장의 최대 길이
num_classes=y_train.shape[1], # 라벨의 개수 (= One-hot vector의 길이)
vocab_size=len(vocab_processor.vocabulary_), # 단어의 수
embedding_size=params['embedding_dim'],
filter_sizes=list(map(int, params['filter_sizes'].split(","))),
num_filters=params['num_filters'],
l2_reg_lambda=params['l2_reg_lambda'],
vec_dir=model_name # @
)
global_step = tf.Variable(0, name="global_step",
trainable=False) # !!원본 바꾼것
# Cost function으로 Adam Optimizer사용
optimizer = tf.train.AdamOptimizer(1e-3)
# cnn의 loss(오차) 값을 파리미터로 받아 점진하강.
grads_and_vars = optimizer.compute_gradients(cnn.loss)
# 학습에 사용할 함수 정의(session.run에서 사용됨).
tf.summary.scalar("cnn_loss", cnn.loss) # @@@
tf.summary.scalar("cnn_accuracy", cnn.accuracy) # @@@
train_op = optimizer.apply_gradients(grads_and_vars,
global_step=global_step)
# saver를 사용해 학습 내용을 저장
saver = tf.train.Saver()
# One training step: train the model with one batch
# train_step 은 모델을 학습하는 하나의 묶음(batch)이다. 만약 batch size가 50이라면 50번의 Traning과 그에 따른 50번의 Test가 실행되게 된다.
def train_step(x_batch, y_batch):
# 입력/예측 출력값을 넣어줌으로서 학습/평가를 할수 있도록 한다.
feed_dict = {
cnn.input_x: x_batch,
cnn.input_y: y_batch,
cnn.dropout_keep_prob: params['dropout_keep_prob']
} # Overfitting을 줄이기 위해, Dropout(신경망 노드 탈락시키기) 확률을 지정.
# 위에서 설정한 값들을 사용해 학습을 시작한다.
_, step, loss, acc = sess.run(
[train_op, global_step, cnn.loss, cnn.accuracy], feed_dict)
# One evaluation step: evaluate the model with one batch
# dev_step 은 학습 결과 묶음(batch)를 평가(Evaluation)하는 메소드이다.
def dev_step(x_batch, y_batch):
# 평가시에는 dropout은 사용하지 않는다.(dropout_keep_prob:1.0 => off)
feed_dict = {
cnn.input_x: x_batch,
cnn.input_y: y_batch,
cnn.dropout_keep_prob: 1.0
}
# 평가시에는 학습용 train_op 파라미터는 넣지 않는다.
step, loss, acc, num_correct, summary, scores, final_scores = sess.run(
[
global_step, cnn.loss, cnn.accuracy, cnn.num_correct,
merged, cnn.scores, cnn.final_scores
], feed_dict) # @@@
for j in final_scores: # 각 final_scores에서 최대값 얻어오기
max_final_scores = max(j)
list_max_final_scores.append(
max_final_scores) # 각 최대값을 리스트에 추가
min_final_scores = min(list_max_final_scores) # 리스트에서 가장 작은 값
writer.add_summary(summary, step) # @@@
return num_correct, min_final_scores
# 사용된 단어들을 ID에 매핑시켜 차후 예측시에 사용한다.(학습시에는 사용하지 않음)
vocab_processor.save(os.path.join(out_dir, "vocab.pickle"))
# 텐서플로우에서 사용하는 변수들을 초기화
ckpt = tf.train.get_checkpoint_state(
model_dir +
"/checkpoints") # checkpoint 얻는다.(모델의 Variable값을 얻어옴) #!!
if ckpt and tf.train.checkpoint_exists(
ckpt.model_checkpoint_path): # 모델 checkpoint가 존재하면 #!!
print("다음 파일에서 모델을 읽는 중 입니다..",
ckpt.model_checkpoint_path) # !!
saver.restore(sess, ckpt.model_checkpoint_path
) # checkpoint파일에서 모델의 변수값을 얻어온다. #!!
else: # 모델 checkpoint가 존재하지 않는다면 #!!
print("새로운 모델을 생성하는 중 입니다.") # !!
sess.run(tf.global_variables_initializer()) # !!
# Training starts here
# 학습의 총 배치 갯수를 세팅한다. batch_iter 함수는 generator형식으로 작성되어있어서, 아래처럼 초기화를 해놓으면, for문안에서 배치단위로 값을 돌려주게 되어있다.
# 한번에 학습단위묶음은 37개(batch_size=37). 학습데이터는 전체 학습에 한번 씩만 사용할것이다. (num_epochs=1)
train_batches = data_helper.batch_iter(list(zip(x_train, y_train)),
params['batch_size'],
params['num_epochs'])
# 최고의 정확성을 저장하기 위한 변수
best_accuracy, best_at_step = 0, 0
merged = tf.summary.merge_all() # @@@
writer = tf.summary.FileWriter("./logs", graph=graph) # @@@
"""Step 6: train the cnn model with x_train and y_train (batch by batch)"""
for train_batch in train_batches:
# zip을 사용하여 배치렬로 x(입력)과 y(기대출력)값을 각각 뽑아낸다.
x_train_batch, y_train_batch = zip(
*train_batch
) # *는 unpack 하는거. https://stackoverflow.com/questions/2921847/what-does-the-star-operator-mean 참고.
# 배치단위로 학습 진행
train_step(x_train_batch, y_train_batch)
current_step = tf.train.global_step(sess, global_step)
# 현재 학습 회차가 evaluate 할 순서이면 evaluate를 한x_dev다. 기본은 200번 마다.
"""Step 6.1: evaluate the model with x_dev and y_dev (batch by batch)"""
if current_step % params['evaluate_every'] == 0:
# 개발용 데이터를 배치단위로 가져온다.
dev_batches = data_helper.batch_iter(
list(zip(x_dev, y_dev)), params['batch_size'], 1)
total_dev_correct = 0
for dev_batch in dev_batches:
x_dev_batch, y_dev_batch = zip(*dev_batch)
# 학습된 모델에 개발용 배치 데이터를 넣어서 예측 성공 갯수를 누적한다.
num_dev_correct, _ = dev_step(x_dev_batch, y_dev_batch)
total_dev_correct += num_dev_correct
# 모델의 정확성을 화면에 출력한다.
dev_accuracy = float(total_dev_correct) / len(y_dev)
logging.critical(
'Accuracy on dev set: {}'.format(dev_accuracy))
# 가장 예측 확률이 좋게 나온 모델을 저장한다. 기준은 dev_accuracy가 가장 좋게 나온 step의 모델이다.
"""Step 6.2: save the model if it is the best based on accuracy on dev set"""
if dev_accuracy >= best_accuracy:
best_accuracy, best_at_step = dev_accuracy, current_step
path = saver.save(sess,
checkpoint_prefix,
global_step=current_step) # !!
tf.Print(path, [path], "This is saver : ")
logging.critical('Saved model at {} at step {}'.format(
path, best_at_step))
logging.critical(
'Best accuracy is {} at step {}'.format(
best_accuracy, best_at_step))
# 학습데이터와 Test데이터는 9:1로 나누었다.
# Test데이터는 학습에 사용되지 않은 데이터로서, 학습된 모델이 객관성을 가지는지 확인하기 위한 용도이다
"""Step 7: predict x_test (batch by batch)"""
test_batches = data_helper.batch_iter(list(zip(x_test, y_test)),
params['batch_size'], 1)
total_test_correct = 0
for test_batch in test_batches:
x_test_batch, y_test_batch = zip(*test_batch)
num_test_correct, min_final_scores = dev_step(
x_test_batch, y_test_batch)
my_min = min_final_scores # by odg
total_test_correct += num_test_correct
f = open(checkpoint_dir + "_min.txt", "w")
f.write(str(my_min))
f.close()
test_accuracy = float(total_test_correct) / len(y_test)
logging.critical('테스트셋 Accuracy {}, best 모델 {}'.format(
test_accuracy,
path)) # 자꾸 여기서 오류남. 이건 그냥 log 띄우는거라 없어도 될거같은데..
logging.critical('트레이닝 완료')
import tensorflow as tf
import data_helper
encoder_sentence_length = 10
decoder_sentence_length = 10
print 'Building vocab ...'
all_input_sentences = data_helper.get_input_sentence()
all_target_sentences = data_helper.get_target_sentence()
encoder_vocab, encoder_reverse_vocab, encoder_vocab_size = data_helper.build_vocab(
all_input_sentences)
decoder_vocab, decoder_reverse_vocab, decoder_vocab_size = data_helper.build_vocab(
all_target_sentences, is_target=True)
max_epoch = 2000
layer_num = 2
hidden_size = 30
embedding_size = 30
encoder_inputs = tf.placeholder(tf.int32, [None, encoder_sentence_length],
name='encoder_inputs')
encoder_sequence_length = tf.placeholder(tf.int32, [None],
name='encoder_sequence_length')
decoder_inputs = tf.placeholder(tf.int32, [None, decoder_sentence_length + 1],
name='decoder_inputs')
with tf.variable_scope('embedding'):
encoder_embedding = tf.get_variable(
'encoder_embedding',
initializer=tf.random_uniform([encoder_vocab_size + 1,
embedding_size]))
total_busi_num += busi_num
total_busi_correct_num += busi_correct_num
total_other_num += other_num
total_other_correct_num += other_correct_num
accuracy=float(total_correct_num)/total_num
busi_acc = float(total_busi_correct_num) / total_busi_num
other_acc = float(total_other_correct_num) / total_other_num
logger.info("validation success")
return accuracy, busi_acc, other_acc
#------------------------------ evaluate model end -------------------------------------
#------------------------------------load data -------------------------------
label2id, id2label = load_label(FLAGS.label_file)
id2word, word2id = build_vocab(FLAGS.word_file)
embeddings = load_embedding(FLAGS.embedding_file)
logger.info("load label, word, embedding finished")
train_valid_x, train_valid_y, class_weight = load_data(FLAGS.train_file, word2id, label2id, FLAGS.num_unroll_steps)
# cal label weight
class_weight_mean = np.mean(class_weight.values())
label_weight = {}
for label, weight in class_weight.items():
label_weight[label2id.get(label)] = 1. / (weight / class_weight_mean)
label_weight = np.array([label_weight[ix] for ix in sorted(label_weight.keys())], dtype=np.float32)
# split data
train_data, valid_data = split_train_by_ratio(zip(train_valid_x, train_valid_y), 0.01)
train_x, train_y = zip(*train_data)
valid_x, valid_y = zip(*valid_data)
入口函数，进行train，test和predict
主要负责：
1. 参数的组装
2. 数据的处理
3. train等入口函数的处理
"""
import argparse
from data_helper import create_iter, build_vocab
from train_eval import train
from model import Config, TextRnn
from predict import predict
parser = argparse.ArgumentParser(description='Lstm Text Classification')
parser.add_argument('--operation',
default="train",
type=str,
help='train test or predict')
args = parser.parse_args()
char2index, index2char = build_vocab()
config = Config(len(char2index))
train_iter, eval_iter = create_iter(config)
model = TextRnn(config)
operation = args.operation
if operation == "train":
print("*****[ begin to train ]*****")
train(config, model, train_iter, eval_iter)
elif operation == "predict":
print("*****[ begin to predict ]*****")
predict(config, model)
metrics.classification_report(y_test_cls,
y_pred_cls,
target_names=categories))
# 混淆矩阵
print("Confusion Matrix...")
cm = metrics.confusion_matrix(y_test_cls, y_pred_cls)
print(cm)
time_dif = get_time_dif(start_time)
print("Time usage:", time_dif)
if __name__ == '__main__':
config = RNNConfig() # 获取配置参数
if not os.path.exists(vocab_dir): # 如果不存在词汇表，重建
build_vocab(train_dir, vocab_dir, config.vocab_size)
categories, cat_to_id = read_category()
words, word_to_id = read_vocab(vocab_dir)
config.vocab_size = len(words)
# print(word_to_id)
# print(words)
if not os.path.exists(vector_word_npz):
export_word2vec_vectors(word_to_id, words_embeding, vector_word_npz)
config.pre_trianing = get_training_word2vec_vectors(vector_word_npz)
model = TextRNN(config)
option = ''
if option == 'train':
train()
else:
test()
tf.flags.DEFINE_integer("checkpoint_every", 100,
"Save model after this many steps (default: 100)")
# Misc Parameters
tf.flags.DEFINE_boolean("allow_soft_placement", True,
"Allow device soft device placement")
tf.flags.DEFINE_boolean("log_device_placement", False,
"Log placement of ops on devices")
FLAGS = tf.flags.FLAGS
FLAGS.flag_values_dict()
timeStamp = time.strftime("%Y%m%d%H%M%S", time.localtime(int(time.time())))
print(("Loading data..."))
vocab = data_helper.build_vocab() # 加载vocab,需修改参数 QA Web 默认是QA
embeddings = data_helper.load_vectors(vocab) #需修改参数 QA Web
alist = data_helper.read_alist("WebAP") # 加载所有例子里的回答
qs = data_helper.qname("WebAP/qeo-train.txt")
number = data_helper.qid("WebAP/qeo-train.txt")
numbertest = data_helper.qid("WebAP/qeo-test.txt")
qstest = data_helper.qname("WebAP/qeo-test.txt")
test1List = data_helper.loadTestSet(dataset="WebAP", filename="term-test")
test2List = data_helper.loadTestSet(dataset="WebAP", filename="term-train")
print("Load done...")
precision = 'WebAP/log/test1.dns' + timeStamp
precision1 = 'WebAP/logtrain/train.dns' + timeStamp
loss_precision = 'WebAP/log/qterm.gan_loss' + timeStamp
from functools import wraps
