tensorflow怎么配置

这篇文章主要介绍“tensorflow怎么配置”，在日常操作中，相信很多人在tensorflow怎么配置问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”tensorflow怎么配置”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

1.训练样本文件转换为集合
[]整个文件
[]每段话
[]分词,tag

2.将IOB模式标签转换为IOBES/B 开头，I 中间，E 结尾，S 单独，O 其他
B- => S-
I- => E-

3.创建字符和ID映射关系

当pkl文件不存在时
1)创建字符和ID映射字典
提取chars(所有词组)生成dico(词组加词频)倒序排列后生成char_to_id,id_to_char
2)同理创建标签和id的映射字典
提取tags(所有tag)生成dico(tag加频率)倒序排列后生成tag_to_id,id_to_tag,且写到tag_to_id.txt和id_to_tag.txt中
3)将映射关系存储到pkl文件中
(将映射关系对象obj序列化保存到文件中)
char_to_id,id_to_char,tag_to_id,id_to_tag

当pkl文件存在时
反序列化映射关系对象，将文件中的数据解析为char_to_id,id_to_char,tag_to_id,id_to_tag

4.将样本数据转为 单字符、对应的id、对应的分词转为（123）、对应的标签id 列表  train_data
data = []   data.append([string, chars, segs, tags])
string: 一段话中所有词组的list
chars: string中每个词在char_to_id字典中的id的list
segs:
    tmp = [2] * len(str(word))
    tmp[0] = 1
    tmp[-1] = 3
    seg_feature.extend(tmp)
    string通过segment分词后的word_list遍历word后得到的seg_feature(是个list:[0,0,0,1,2,3,1,2,2,2,3,0,0])
    
tags: string中每个tag在tag_to_id字典中的id的list

5.批量管理,将一批数据按批次大小拆分
train_manager: batch_data
               len_data
               
batch_data: list()  batch_data.append([strings, chars, segs, targets]) 

6.生成相关路径,生成配置文件
result_path,ckpt_path,config_file

7.tensorflow配置
设置步长
加载缓存

创建空模型:
通过checkpoint文件查找模型文件名
tf.global_variables_initializer()添加节点用于初始化所有的全局变量(GraphKeys.VARIABLES)。
返回一个初始化所有全局变量的操作(op),在构建完整个模型并在会话中加载模型后，运行这个节点。

设置使用CPU/GPU
设置训练次数
遍历乱序train_manager后的batch进行模型训练
step, batch_loss = model.run_step(sess, True, batch)
loss.append(batch_loss)

每20批次(步长steps_check)计算下剩余批次所需时间并打印日志(MSE表示了预测值与目标值之间差值
的平方和然后求平均 np.mean(loss)))

通过dev文件优化模型并保存
evaluate(sess, model, "dev", dev_manager, id_to_tag)

def evaluate(sess, model, name, data, id_to_tag): #logger = None
    logger.info("evaluate:{}".format(name))
    ner_results = model.evaluate(sess, data, id_to_tag)
    eval_lines = test_ner(ner_results, FLAGS.result_path)
    message = 'eval_lines value:{}'.format(eval_lines)
    # print(message)
    logger.info(message)
    f1 = float(eval_lines[1].strip().split()[-1])

    if name == "dev":
        best_test_f1 = model.best_dev_f1.eval()
        if f1 > best_test_f1:
            tf.assign(model.best_dev_f1, f1).eval()
            # print("new best dev f1 score:{:>.3f}".format(f1))
            logger.info("new best dev f1 score:{:>.3f}".format(f1))
        return f1 > best_test_f1
    elif name == "test":
        best_test_f1 = model.best_test_f1.eval()
        if f1 > best_test_f1:
            tf.assign(model.best_test_f1, f1).eval()
            # print("new best test f1 score:{:>.3f}".format(f1))
            logger.info("new best test f1 score:{:>.3f}".format(f1))
        return f1 > best_test_f1

def evaluate(self, sess, data_manager, id_to_tag):
    results = []
    trans = self.trans.eval()
    for batch in data_manager.iter_batch():
        strings = batch[0]
        tags = batch[-1]
        lengths, scores = self.run_step(sess, False, batch)
        batch_paths = self.decode(scores, lengths, trans)
        for i in range(len(strings)):
            result = []
            string = strings[i][:lengths[i]]
            gold = iobes_iob([id_to_tag[int(x)] for x in tags[i][:lengths[i]]])
            pred = iobes_iob([id_to_tag[int(x)] for x in batch_paths[i][:lengths[i]]])
            # gold = iob_iobes([id_to_tag[int(x)] for x in tags[i][:lengths[i]]])
            # pred = iob_iobes([id_to_tag[int(x)] for x in batch_paths[i][:lengths[i]]])
            for char, gold, pred in zip(string, gold, pred):
                result.append(" ".join([char, gold, pred]))
            results.append(result)
    return results

def test_ner(results, path):
    output_file = os.path.join(path, "ner_predict.utf8")
    with open(output_file, "w",encoding='utf8') as f:
        to_write = []
        for block in results:
            for line in block:
                to_write.append(line + "\n")
            to_write.append("\n")

        f.writelines(to_write)
    eval_lines = return_report(output_file)
    return eval_lines
            
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
标注实体识别 
1.加载config_file的配置参数、tensorflow参数、是否使用gpu
2.在指定路径下新建result_file、打开map_file文件读取char_to_id, id_to_char, tag_to_id, id_to_tag
3.将tf_config入参加载缓存
通过读取ckpt_path下的ckpt文件加载训练好的模型    
4. test_list = readText2Json("/data0/nlp/test/ner/test.txt") 将相应路径下的测试文件内容转换成dict

    strs = line.replace('\n','').split('\t')
    res = {}
    string = strs[0]
    res['string'] = string
    value_list = []
    wl = []
    tag_num = 0
    for str in strs[1:]:
        value = {}
        pos = find_last(str,':') //英国牛津大学:ORG
        word = str[:pos]    
        type = str[pos+1:]
        if not type == 'O':
            # print(type)
            tag_num += 1     //排除类型为O的计数
        value['word'] = word
        value['type'] = type
        value_list.append(value) //[{'type':'ORG','word':'英国牛津大学'}]
        wl.append(word)
    if len(value_list) == 0:
        continue
    res['value'] = value_list
    res['wl'] = wl
    res['tag_num'] = tag_num
    res_list.append(res) 

return res_list

5.遍历res_list
for tests in test_list:
    line = tests['string'].replace(' ', '').replace('\t', '').replace('\s', '')
    res_list = tests['value']

{'tag_num': 1, 
'wl': ['英国牛津大学', '出版社', '出版', '的', '多种', '英语词典', '的', '统称'], 
'value': [{'type': 'ORG', 'word': '英国牛津大学'}, {'type': 'O', 'word': '出版社'}, {'type': 'O', 'word': '出版'}, {'type': 'O', 'word': '的'}, {'type': 'O', 'word': '多种'}, {'type': 'O', 'word': '英语词典'}, {'type': 'O', 'word': '的'}, {'type': 'O', 'word': '统称'}], 
'string': '英国牛津大学出版社出版的多种英语词典的统称'}    

inputs = input_from_line(string, char_to_id, word_list=wl)            
将string进行全角符号转换为半角、html转码处理

inputs = list()
inputs.append([line])
inputs.append([[char_to_id[char] if char in char_to_id else char_to_id["<UNK>"]   //将line根据字典表转为id
                for char in line]])
inputs.append([get_seg_features(line, word_list=word_list)])          //将line进行get_seg_features 矩阵处理        
inputs.append([[]])            

6.进行模型训练得到训练结果result            
result = model.evaluate_line(sess, inputs, id_to_tag)            

def evaluate_line(self, sess, inputs, id_to_tag):
    trans = self.trans.eval(session=sess)
    lengths, scores = self.run_step(sess, False, inputs)
    batch_paths = self.decode(scores, lengths, trans)
    tags = [id_to_tag[idx] for idx in batch_paths[0]] //得到的id转为tag
    return result_to_json(inputs[0][0], tags)   //分词标注结果转换为json

entities = result['entities']            
[{'start': 0, 'end': 1, 'type': 'O', 'word': '英'}, {'start': 1, 'end': 6, 'type': 'ORGANIZATION', 'word': '国牛津大学'}, {'start': 6, 'end': 9, 'type': 'O', 'word': '出版社'}, {'start': 9, 'end': 11, 'type': 'O', 'word': '出版'}, {'start': 11, 'end': 12, 'type': 'O', 'word': '的'}, {'start': 12, 'end': 14, 'type': 'O', 'word': '多种'}, {'start': 14, 'end': 16, 'type': 'O', 'word': '英语'}, {'start': 16, 'end': 18, 'type': 'O', 'word': '词典'}, {'start': 18, 'end': 19, 'type': 'O', 'word': '的'}, {'start': 19, 'end': 21, 'type': 'O', 'word': '统称'}]            

7.遍历entities,排除掉type为O的数据，将标准答案 res_list 中的该下标的res的word、    type和识别结果 entities    中的type、word作为一行lin写入到result_file中。
  并统计正确结果的个数
-------------------------
for tests in test_list:
    test_acc += tag_num
-------------------------
  
for index, i in enumerate(entities):
    word = i['word']
    type = i['type']
    if index > len(res_list)-1:
        break
    # if type == 'O' and res_list[index]['type'] == 'O':
    #     continue
    if type == 'O':
        continue
    test_rec += 1
    lin = res_list[index]['word']+'\t'+res_list[index]['type']+'\t'+type+'\t'+word+'\n'
    start_in = 0
    end_in = -1
    if index > 5:
        start_in = index - 5
    if len(res_list) - index > 5:
        end_in = index + 5
    result_file.write(lin)
    for j in res_list[start_in:end_in]:
        if word == j['word'] and type == j['type']:
            test_right = test_right + 1
            break            

8.打印准确率、召回率等相关信息
zq = round(test_right / test_rec, 4) * 100
zh = round(test_right / test_acc, 4) * 100
f1 = round(2 * zq * zh / (zq + zh))
print('总标签数：{},识别标签数：{}，识别对数量:{}，准确率：{},召回率：{},f1:{}'.format(test_acc, test_rec, test_right, zq, zh, f1))

总标签数：8773,识别标签数：12260，识别对数量:3542，准确率：28.89,召回率：40.37,f1:34

test_acc：标准答案中所有排除other类型的标签个数
test_rec：通过模型实体识别后的结果中实际识别的非other类型标签的总数

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
分类模型训练：
1.准备post.xls、other.xls文件
train_datas = []
data = pd.read_excel(constant.clfytrain_path + '/{}'.format(file_name),  header=None)
将文件内容读取到train_datas中
将两个excel文件中的数据根据0轴(列)进行融合
pn = pd.concat(train_datas,  ignore_index=True)

到此，关于“tensorflow怎么配置”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注亿速云网站，小编会继续努力为大家带来更多实用的文章！