def main(self): datadir = self._basedir + '/../data' Log.i("*** [START] ***") parse(model_file=self._basedir + "/../output/cws.model", embed_file=datadir + "/zhwiki-embeddings-100.txt") Log.i("*** [DONE] ***")
def main(self): corpus = "pku" datadir = self._basedir + '/../data' Log.i("*** [START] ***") train( train_file=datadir + "/icwb2-data/training/%s_training.utf8" % corpus, test_file=datadir + "/icwb2-data/gold/%s_test_gold.utf8" % corpus, embed_file=datadir + "/zhwiki-embeddings-100.txt", n_epoch=self._args.epoch, batch_size=self._args.batchsize, gpu=self._args.gpu, save=self._basedir + "/../output/cws.model" if self._args.save else None ) Log.i("*** [DONE] ***")
def main(self): corpus = "pku" datadir = self._basedir + '/../data' Log.i("*** [START] ***") train(train_file=datadir + "/icwb2-data/training/%s_training.utf8" % corpus, test_file=datadir + "/icwb2-data/gold/%s_test_gold.utf8" % corpus, embed_file=datadir + "/zhwiki-embeddings-100.txt", n_epoch=self._args.epoch, batch_size=self._args.batchsize, gpu=self._args.gpu, save=self._basedir + "/../output/cws.model" if self._args.save else None) Log.i("*** [DONE] ***")
def parse(model_file, embed_file): # Load files Log.i('initialize preprocessor with %s' % embed_file) processor = Preprocessor(embed_file) Log.v('') Log.v("initialize ...") Log.v('') with np.load(model_file) as f: embeddings = np.zeros(f['embed/W'].shape, dtype=np.float32) # Set up a neural network cls = BLSTMCRF if _use_crf else BLSTM model = cls( embeddings=embeddings, n_labels=4, dropout=0.2, train=False, ) Log.i("loading a model from %s ..." % model_file) serializers.load_npz(model_file, model) LABELS = ['B', 'M', 'E', 'S'] def _process(raw_text): if not raw_text: return xs = [processor.transform_one([c for c in raw_text])] ys = model.parse(xs) labels = [LABELS[y] for y in ys[0]] print(' '.join(labels)) seq = [] for c, label in zip(raw_text, labels): seq.append(c) if label == 'E' or label == 'S': seq.append(' ') print(''.join(seq)) print('-') print("Input a Chinese sentence! (use 'q' to exit)") while True: x = input() if x == 'q': break _process(x)
def _process(dataset, model): size = len(dataset) batch_count = 0 loss = 0.0 accuracy = 0.0 p = ProgressBar(min_value=0, max_value=size, fd=sys.stderr).start() for i, (xs, ys) in enumerate(dataset.batch(batch_size, colwise=True, shuffle=model.train)): p.update((batch_size * i) + 1) batch_count += 1 batch_loss, batch_accuracy = model(xs, ys) loss += batch_loss.data accuracy += batch_accuracy if model.train: _update(optimizer, batch_loss) p.finish() Log.i("[%s] epoch %d - #samples: %d, loss: %f, accuracy: %f" % ('training' if model.train else 'evaluation', epoch + 1, size, loss / batch_count, accuracy / batch_count))
def _process(dataset, model): size = len(dataset) batch_count = 0 loss = 0.0 accuracy = 0.0 p = ProgressBar(min_value=0, max_value=size, fd=sys.stderr).start() for i, (xs, ys) in enumerate( dataset.batch(batch_size, colwise=True, shuffle=model.train)): p.update((batch_size * i) + 1) batch_count += 1 batch_loss, batch_accuracy = model(xs, ys) loss += batch_loss.data accuracy += batch_accuracy if model.train: _update(optimizer, batch_loss) p.finish() Log.i("[%s] epoch %d - #samples: %d, loss: %f, accuracy: %f" % ('training' if model.train else 'evaluation', epoch + 1, size, loss / batch_count, accuracy / batch_count))
def test(model_file, moderu): # Load files Log.v('') Log.v("initialize ...") Log.v('') # Set up a neural network Log.i("loading a model from %s ..." % model_file) serializers.load_npz(model_file, moderu) # Set closetest data preds = 0.0 cishu = 0 loss_1 = 0.0 pathDir = os.listdir(cfg.closetest) yucezhi_1 = [] zhenzhi_1 = [] # losslist = [] # fause_ratelist= [] # correct_ratelist = [] # correct_flist = [] # fause_flist = [] for allDir in pathDir: #测试数据是一个一个地往模型里扔 print(allDir) filename = allDir allDir = os.path.join(cfg.closetest, allDir) f = open(allDir, 'r') a = np.loadtxt( f, delimiter=',', skiprows=0, ).astype(np.float32) # print(a.shape) closetestX = a[:, 1:None] closetestlabel = a[:, 0:1] # print('Xclosetest shape: {}'.format(closetestX.shape)) if cfg.mse == True: closetestlabel = label.label_1(closetestlabel) if cfg.cross == True: closetestlabel = label.label_2(closetestlabel) # print('Yclosetest shape: {}'.format(closetestlabel.shape)) # skl.preprocessing.normalize(closetestX, norm='l2') zhuanghuan = [] zhuanghuan1 = [] #输入到blsm中的数据必须是二维的array,形如[[1 2]],第一个维度表示数据的个数,第二个维度是具体的特征值 zhuanghuan.append(np.array(closetestX, np.float32)) zhuanghuan1.append(np.array(closetestlabel, np.int32)) closetestX = np.array(zhuanghuan) closetestlabel = np.array(zhuanghuan1) testloss, preds_1, yucezhi = moderu(closetestX, closetestlabel) # print("现在输出预测值") # print("现在输出preds_1") # print(preds_1) # print("现在输出closetestlabel") # print(closetestlabel) # os.system("pause") yucezhi_1.extend(yucezhi) zhenzhi_1.extend(closetestlabel) loss_1 = loss_1 + testloss preds += preds_1 cishu = cishu + 1 # print(preds) # print(cishu) testloss.unchain_backward() yucezhi_2 = [] zhenzhi_2 = [] for a in zhenzhi_1: # print(type(a)) # os.system("pause") zhenzhi_2.extend(a.tolist()) for b in yucezhi_1: # print(type(b.data)) # os.system("pause") yucezhi_2.extend((b.data).tolist()) # 加了tolist居然好使了 confuse = confusion_matrix(zhenzhi_2, yucezhi_2) Log.i("#closetest:----datasize: %d, accuracy: %f, testloss: %f" % (cishu, preds / cishu, loss_1.data / cishu)) # losslist.append(testloss/cishu) Log.i("the confuse matrix is") Log.i(confuse) ''' 混淆矩阵的形状是 预测值 0 1 真实值 0 a b 1 c d 真实值是0,预测值也是0的情况是有a次 真实值是0,但是预测值是1的情况有b次。。。。。。 ''' print('the name of model is%s' % model_file) Log.i('the name of model is%s' % model_file) print('这次测试的混淆矩阵是') print(confuse) #输入混淆矩阵的是两个list fause = confuse[1][1] / (confuse[1][0] + confuse[1][1]) fause_1 = confuse[1][1] / (confuse[0][1] + confuse[1][1]) correct = confuse[0][0] / (confuse[0][0] + confuse[0][1]) correct_1 = confuse[0][0] / (confuse[0][0] + confuse[1][0]) c = confuse[0][0] + confuse[0][1] f = confuse[1][0] + confuse[1][1] all = confuse[0][0] + confuse[0][1] + confuse[1][0] + confuse[1][1] fause_rate = f / all correct_rate = c / all correct_f = (2 * correct * correct_1) / (correct + correct_1) fause_f = (2 * fause * fause_1) / (fause + fause_1) # print("测试loss是") # print(testloss) # os.system("pause") print("总共的帧数是:%d" % all) Log.i("all of the frames:%d" % all) print("错误识别的再现率是:%f" % fause) Log.i("the precision of label1:%f" % float(fause)) # fause_ratelist.append(fause) print("原本就是错误的帧数为:%f,占总帧数的%f" % (f, fause_rate)) Log.i("the number of label1:%f,label1's rate%f" % (f, fause_rate)) print("正确认识的再现率是:%f" % correct) Log.i("the precision of label0:%f" % float(correct)) # correct_ratelist.append(correct) print("原本就是正确的帧数为:%f,占总帧数的%f" % (c, correct_rate)) Log.i("the number of label0:%f,label0's rate%f" % (c, correct_rate)) print("错误识别的适合率是:%f" % fause_1) Log.i("the recall of label1:%f" % fause_1) print("正确认识的适合率是:%f" % correct_1) Log.i("the recall of label0:%f" % correct_1) print("正确认识的F值为:%f" % correct_f) # correct_flist.append(correct_f) Log.i("the F score of label0:%f" % correct_f) print("错误识别的F值为:%f" % fause_f) # fause_flist.append(fause_f) Log.i("the F score of label1:%f" % fause_f) return loss_1.data / cishu, fause, fause_f, correct_rate, correct_f, preds / cishu print('##################### ClosePredict Done ########################')
def train( n_epoch=10, # 20 batch_size=10, # 20 #n_epoch和batch_size在这里设置是没用的 #但是记住,每次把它们调整成一样的 gpu=-1, save=True): hparams = { 'batchsize': cfg.batchsize, 'dropout_ratio': cfg.dropout, 'adagrad_lr': cfg.adagrad_lr, # 0.0005 < lr < 0.01 'weight_decay': 0.0001, # 0.0001 'inputN': cfg.inputN, 'output': cfg.outputN, 'lr': cfg.lr, 'lstmcenshu': cfg.lstmcenshu, 'cudnn': cfg.cudnn, 'embed_size': cfg.embed_size, 'xunliandata': (str(cfg.gakusyu)).encode(encoding='utf-8'), #如果要保存字符串的话得重新编码 'mse': cfg.mse, 'cross': cfg.cross, } Log.v('') Log.v("initialize ...") Log.v('--------------------------------') Log.i('# Minibatch-size: %d' % cfg.batchsize) Log.i('# epoch: %d' % cfg.epoch) Log.i('# gpu: %d' % cfg.gpu) Log.i('# hyper-parameters: %s' % str(hparams)) Log.v('--------------------------------') Log.v('') train_data = [] train_label = [] # Set Training data pathDir = os.listdir(cfg.gakusyu) # print(pathDir) cot = 0 for allDir in pathDir: # print(allDir) allDir = os.path.join(cfg.gakusyu, allDir) f = open(allDir, 'r') print("我读到了文件%s" % allDir) a = np.loadtxt(f, delimiter=',', skiprows=0).astype(np.float32) Xtrain = a[:, 1:None] Labeltrain = a[:, 0:1] # skl.preprocessing.normalize(Xtrain, norm='l2') #这是用来干什么的暂时不知道 # ds = X.shape[0] # print('Xtrain shape: {}'.format(Xtrain.shape)) if cfg.cross == True: Labeltrain = label.label_2(Labeltrain) train_label.append(np.array(Labeltrain, np.int32)) train_data.append(np.array(Xtrain, np.float32)) if cfg.mse == True: Labeltrain = label.label_1(Labeltrain) train_label.append(np.array(Labeltrain, np.float32)) train_data.append(np.array(Xtrain, np.float32)) #把形如[[0],[1]]的标签变成形如[[1,0],[0,1]]的标签 train_data = np.array(train_data) train_label = np.array(train_label) # print("现在打印所有的标签") # print(train_label) # print(len(train_label)) # print("现在打印所有的学习数据") # print(type(train_label)) # print(train_data) sample_size = len(train_data) print("我们的学习数据一共有%d个" % sample_size) # Set up a neural network cls = BLSTM model = cls( f_dim=cfg.inputN, n_labels=cfg.outputN, # (11*2) +1, dropout=hparams['dropout_ratio'], train=True, ) if gpu >= 0: cuda.get_device_from_id(gpu).use() model.to_gpu() # cuda.get_device_from_id(gpu) # model.to_gpu() optimizer = optimizers.Adam(alpha=cfg.lr) optimizer.setup(model) # optimizer.add_hook(WeightDecay(hparams['weight_decay'])) losslist = [] fause_ratelist = [] correct_ratelist = [] correct_flist = [] fause_flist = [] #从这里开始,训练和更新参数的代码都写在这里面了 for epoch in range(n_epoch): print("第%d个epoch的训练开始训练" % (epoch + 1)) batch_count = 0 loss = 0.0 accuracy = 0.0 perm = np.random.permutation(sample_size) y_batch_1 = [] yucezhi_1 = [] for i in range( 0, sample_size, batch_size ): #sample_size是语音数据的总个数,每一次循环就是一次训练,每一次训练使用batch_size个数据 # print("第%d次正向传播,这次正向传播的batch_size是%d"%((i/batch_size)+1,batch_size)) x_batch = train_data[perm[i:i + batch_size]] y_batch = train_label[perm[i:i + batch_size]] batch_count += 1 # print("这次正向传播的学习数据一共有%d个"%len(x_batch)) # print("下面是x_batch") # print(x_batch) # print("这次正向传播的学习数据的标签的个数有%d个"%len(y_batch)) # print("下面是y_batch") # print(y_batch) # model.cleargrads() batch_loss, preds_1, yucezhi = model( x_batch, y_batch) # 只要是往实例里面传递参数,就是调用了_call_函数 # 把batch_size传进去,才方便计算loss # print(y_batch) # print(yucezhi) # os.system("pause") for a in y_batch: # print(type(a)) # os.system("pause") y_batch_1.extend(a.tolist()) for b in yucezhi: # print(type(b.data)) # os.system("pause") yucezhi_1.extend((b.data).tolist()) #加了tolist居然好使了 print("下面打印的是这次正向传播的loss") print(batch_loss.data) loss += batch_loss.data # print("下面打印的是这次正向传播的准确率") # print(batch_accuracy) # accuracy += batch_accuracy # print("下面打印叠加之后的loss") # print(loss) print("下面打印batch_count") print(batch_count) # 这部分代码是胡欢的 # optimizer.target.cleargrads() # loss.backward() # optimizer.update() # 这部分代码是后藤的 # optimizer.target.zerograds() # loss.backward() # # loss.unchain_backward()#如果训练数据太长的话,比如说可以规定每过30个数据忘记一次参数,想要忘记参数的话就调用一次这个函数 # optimizer.update() if model.train == True: optimizer.target.zerograds() batch_loss.backward() batch_loss.unchain_backward() optimizer.update() confuse = confusion_matrix( y_batch_1, yucezhi_1) # 注意如果输出值跟真实值完全一致,且值都是0或者都是1,它只会输出一维的列表 fause = confuse[1][1] / (confuse[1][0] + confuse[1][1]) # fause_1 = confuse[1][1] / (confuse[0][1] + confuse[1][1]) correct = confuse[0][0] / (confuse[0][0] + confuse[0][1]) # correct_1 = confuse[0][0] / (confuse[0][0] + confuse[1][0]) # c = confuse[0][0] + confuse[0][1] # f = confuse[1][0] + confuse[1][1] # all = confuse[0][0] + confuse[0][1] + confuse[1][0] + confuse[1][1] # correct_f = (2 * correct * correct_1) / (correct + correct_1) # fause_f = (2 * fause * fause_1) / (fause + fause_1) # correct_f = correct_f/batch_count # fause_f = fause_f/batch_count print("本次epoch训练完之后的总的loss跟batch_count是") print(loss) print(batch_count) Log.i( "[%s] epoch %d - - #samples: %d, loss: %f, fause_rate: %f, correct_rate: %f" % ('training' if model.train else 'evaluation', epoch + 1, sample_size, loss / batch_count, fause, correct)) Log.v('-') loss_1 = loss / batch_count losslist.append(loss_1 / batch_size) #这里计算出来的loss就是每个语音文件的loss fause_ratelist.append(fause) correct_ratelist.append(correct) print("现在把第%d个epoach的模型保存下来") name = str(epoch + 1) + 'model' Log.i("saving the model to %s ..." % (epoch + 1) + 'model') serializers.save_npz(os.path.join(os.getcwd() + '/model/', name), model) np.savetxt(os.getcwd() + '/libs/train/loss.txt', losslist) #把loss存入文件中 np.savetxt(os.getcwd() + '/libs/train/fause_rate.txt', fause_ratelist) np.savetxt(os.getcwd() + '/libs/train/correct_rate.txt', correct_ratelist)
def main(self): if cfg.xunlian == True: Log.i("*** [START] ***") Log.i(" ") Log.i(" ") tr.train( n_epoch=self._args.epoch, batch_size=self._args.batchsize, gpu=self._args.gpu, save=self._args.save # 要不要保存训练好的模型 # save="kakilstm.model" if self._args.save else None, ) if cfg.bice == True: Log.i("*** [closetesting] ***") Log.i(" ") Log.i(" ") losslist = [] fause_ratelist = [] correct_ratelist = [] correct_flist = [] fause_flist = [] accuracy = [] cls = BLSTM model = cls( f_dim=cfg.inputN, n_labels=cfg.outputN, # (11*2)+1, dropout=0, train=False, ) if cfg.gpu >= 0: cuda.get_device_from_id(cfg.gpu) model.to_gpu() # cuda.get_device_from_id(gpu) # model.to_gpu() if cfg.bice_lianxu == True: for i in range(cfg.test_size): testloss, fause_rate, fause_f, correct_rate, correct_f, matomeaccu = ct.test( model_file=os.path.join(os.getcwd() + '/model/' + str(i + 1) + 'model'), moderu=model) # 执行closetest,连续测试各个模型 losslist.append(testloss) fause_ratelist.append(fause_rate) correct_ratelist.append(correct_rate) correct_flist.append(correct_f) fause_flist.append(fause_f) accuracy.append(matomeaccu) else: testloss, fause_rate, fause_f, correct_rate, correct_f, matomeaccu = ct.test( model_file=cfg.close_model, moderu=model) # 执行closetest,只测试一个模型 losslist.append(testloss) fause_ratelist.append(fause_rate) correct_ratelist.append(correct_rate) correct_flist.append(correct_f) fause_flist.append(fause_f) accuracy.append(matomeaccu) np.savetxt(os.getcwd() + '/libs/closetest/loss.txt', losslist) # 把loss存入文件中 np.savetxt(os.getcwd() + '/libs/closetest/fause_rate.txt', fause_ratelist) np.savetxt(os.getcwd() + '/libs/closetest/correct_rate.txt', correct_ratelist) np.savetxt(os.getcwd() + '/libs/closetest/correct_f.txt', correct_flist) np.savetxt(os.getcwd() + '/libs/closetest/fause_f.txt', fause_flist) np.savetxt(os.getcwd() + '/libs/closetest/accuracy.txt', accuracy) Log.i("*** [CLOSETESTDONE] ***") Log.i(" ") Log.i(" ") if cfg.kaice == True: Log.i("*** [opentesting] ***") Log.i(" ") Log.i(" ") losslist = [] fause_ratelist = [] correct_ratelist = [] correct_flist = [] fause_flist = [] accuracy = [] cls = BLSTM model_1 = cls( f_dim=cfg.inputN, n_labels=cfg.outputN, # (11*2)+1, dropout=0, train=False, ) if cfg.gpu >= 0: cuda.get_device_from_id(cfg.gpu) model_1.to_gpu() # cuda.get_device_from_id(gpu) # model.to_gpu() if cfg.kaice_lianxu == True: for i in range(cfg.test_size): testloss, fause_rate, fause_f, correct_rate, correct_f, matomeaccu = ot.test( model_file=os.path.join(os.getcwd() + '/model/' + str(i + 1) + 'model'), moderu=model_1) # 执行closetest,连续测试各个模型 losslist.append(testloss) fause_ratelist.append(fause_rate) correct_ratelist.append(correct_rate) correct_flist.append(correct_f) fause_flist.append(fause_f) accuracy.append(matomeaccu) else: testloss, fause_rate, fause_f, correct_rate, correct_f, matomeaccu = ot.test( model_file=cfg.open_model, moderu=model_1) # 执行closetest,只测试一个模型 losslist.append(testloss) fause_ratelist.append(fause_rate) correct_ratelist.append(correct_rate) correct_flist.append(correct_f) fause_flist.append(fause_f) accuracy.append(matomeaccu) np.savetxt(os.getcwd() + '/libs/opentest/loss.txt', losslist) # 把loss存入文件中 np.savetxt(os.getcwd() + '/libs/opentest/fause_rate.txt', fause_ratelist) np.savetxt(os.getcwd() + '/libs/opentest/correct_rate.txt', correct_ratelist) np.savetxt(os.getcwd() + '/libs/opentest/correct_f.txt', correct_flist) np.savetxt(os.getcwd() + '/libs/opentest/fause_f.txt', fause_flist) np.savetxt(os.getcwd() + '/libs/opentest/accuracy.txt', accuracy) Log.i("*** [OPENTESTDONE] ***") Log.i(" ") Log.i(" ")
def train(train_file, test_file, embed_file, n_epoch=20, batch_size=20, gpu=-1, save=None): # Load files Log.i('initialize preprocessor with %s' % embed_file) processor = Preprocessor(embed_file) reader = CorpusReader(processor) Log.i('load train dataset from %s' % str(train_file)) train_dataset = reader.load(train_file, train=True) Log.i('load test dataset from %s' % str(test_file)) test_dataset = reader.load(test_file, train=False) hparams = { 'dropout_ratio': 0.2, 'adagrad_lr': 0.2, 'weight_decay': 0.0001, } Log.v('') Log.v("initialize ...") Log.v('--------------------------------') Log.i('# Minibatch-size: %d' % batch_size) Log.i('# epoch: %d' % n_epoch) Log.i('# gpu: %d' % gpu) Log.i('# hyper-parameters: %s' % str(hparams)) Log.v('--------------------------------') Log.v('') # Set up a neural network cls = BLSTMCRF if _use_crf else BLSTM model = cls( embeddings=processor.embeddings, n_labels=4, dropout=hparams['dropout_ratio'], train=True, ) if gpu >= 0: cuda.get_device(gpu).use() model.to_gpu() eval_model = model.copy() eval_model.train = False # Setup an optimizer optimizer = optimizers.AdaGrad(lr=hparams['adagrad_lr']) optimizer.setup(model) optimizer.add_hook(WeightDecay(hparams['weight_decay'])) def _update(optimizer, loss): optimizer.target.zerograds() loss.backward() optimizer.update() def _process(dataset, model): size = len(dataset) batch_count = 0 loss = 0.0 accuracy = 0.0 p = ProgressBar(min_value=0, max_value=size, fd=sys.stderr).start() for i, (xs, ys) in enumerate( dataset.batch(batch_size, colwise=True, shuffle=model.train)): p.update((batch_size * i) + 1) batch_count += 1 batch_loss, batch_accuracy = model(xs, ys) loss += batch_loss.data accuracy += batch_accuracy if model.train: _update(optimizer, batch_loss) p.finish() Log.i("[%s] epoch %d - #samples: %d, loss: %f, accuracy: %f" % ('training' if model.train else 'evaluation', epoch + 1, size, loss / batch_count, accuracy / batch_count)) for epoch in range(n_epoch): _process(train_dataset, model) _process(test_dataset, eval_model) Log.v('-') if save is not None: Log.i("saving the model to %s ..." % save) serializers.save_npz(save, model)
__fig_name = '{}_{}'.format('mon' if is_mono else 'bin', time.strftime("%Y_%m_%d_%H_%M_%S")) nb_ch = cfg.nb_ch batch_size = cfg.batch_size # Decrease this if you want to run on smaller GPU's fft_point = cfg.fft_point seq_len = cfg.seq_len # Frame sequence length. Input to the CRNN. nb_epoch = cfg.nb_epoch # Training epochs patience = cfg.patience # Patience for early stopping sr = cfg.sr nfft = cfg.nfft frames_1_sec = cfg.frames_1_sec print( 'TRAINING PARAMETERS: nb_ch: {}, seq_len: {}, batch_size: {}, nb_epoch: {}, frames_1_sec: {}' .format(nb_ch, seq_len, batch_size, nb_epoch, frames_1_sec)) Log.i( 'TRAINING PARAMETERS: nb_ch: %d, seq_len: %s, batch_size: %d, nb_epoch: %d, frames_1_sec: %s' % (nb_ch, seq_len, batch_size, nb_epoch, frames_1_sec)) __models_dir = 'models/' utils.create_folder(__models_dir) cnn_nb_filt = cfg.cnn_nb_filt # CNN filter size cnn_pool_size = cfg.cnn_pool_size # Maxpooling across frequency. Length of cnn_pool_size = number of CNN layers rnn_nb = cfg.rnn_nb # Number of RNN nodes. Length of rnn_nb = number of RNN layers # rnn的层数等于rnn_nb的长度 fc_nb = cfg.fc_nb # Number of FC nodes. Length of fc_nb = number of FC layers dropout_rate = cfg.dropout_rate # Dropout after each layer ############################################################################################ ############################################################################################ print( 'MODEL PARAMETERS:\n cnn_nb_filt: {}, cnn_pool_size: {}, rnn_nb: {}, fc_nb: {}, dropout_rate: {}' .format(cnn_nb_filt, cnn_pool_size, rnn_nb, fc_nb, dropout_rate)) Log.i(
def train( train_file, test_file, embed_file, n_epoch=20, batch_size=20, gpu=-1, save=None): # Load files Log.i('initialize preprocessor with %s' % embed_file) processor = Preprocessor(embed_file) reader = CorpusReader(processor) Log.i('load train dataset from %s' % str(train_file)) train_dataset = reader.load(train_file, train=True) Log.i('load test dataset from %s' % str(test_file)) test_dataset = reader.load(test_file, train=False) hparams = { 'dropout_ratio': 0.2, 'adagrad_lr': 0.2, 'weight_decay': 0.0001, } Log.v('') Log.v("initialize ...") Log.v('--------------------------------') Log.i('# Minibatch-size: %d' % batch_size) Log.i('# epoch: %d' % n_epoch) Log.i('# gpu: %d' % gpu) Log.i('# hyper-parameters: %s' % str(hparams)) Log.v('--------------------------------') Log.v('') # Set up a neural network cls = BLSTMCRF if _use_crf else BLSTM model = cls( embeddings=processor.embeddings, n_labels=4, dropout=hparams['dropout_ratio'], train=True, ) if gpu >= 0: cuda.get_device(gpu).use() model.to_gpu() eval_model = model.copy() eval_model.train = False # Setup an optimizer optimizer = optimizers.AdaGrad(lr=hparams['adagrad_lr']) optimizer.setup(model) optimizer.add_hook(WeightDecay(hparams['weight_decay'])) def _update(optimizer, loss): optimizer.target.zerograds() loss.backward() optimizer.update() def _process(dataset, model): size = len(dataset) batch_count = 0 loss = 0.0 accuracy = 0.0 p = ProgressBar(min_value=0, max_value=size, fd=sys.stderr).start() for i, (xs, ys) in enumerate(dataset.batch(batch_size, colwise=True, shuffle=model.train)): p.update((batch_size * i) + 1) batch_count += 1 batch_loss, batch_accuracy = model(xs, ys) loss += batch_loss.data accuracy += batch_accuracy if model.train: _update(optimizer, batch_loss) p.finish() Log.i("[%s] epoch %d - #samples: %d, loss: %f, accuracy: %f" % ('training' if model.train else 'evaluation', epoch + 1, size, loss / batch_count, accuracy / batch_count)) for epoch in range(n_epoch): _process(train_dataset, model) _process(test_dataset, eval_model) Log.v('-') if save is not None: Log.i("saving the model to %s ..." % save) serializers.save_npz(save, model)