NLP算法工程师知识点_npl算法工程

NLP算法工程师知识点

• 想要使非叶子结点也有grad，则需要设置l.retain_grad()
• 写数据 result_file = open(‘./work/result.txt’,‘w’,encoding=‘utf-8’) result_file = open(‘./work/result.txt’,‘w’,encoding=‘utf-8’) result_file.writelines(y_wrt_list) result_file.close()
• pbar = tqdm.tqdm(train_dataloader) pbar.set_description(‘[!]Batch loss{:.3f}’.format(loss.item())) tqdm显示数据
• transformers.AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=learning_rate, eps=adam_epsilon) 选择模型中requires_grad为True的参数做优化
• 当requires_grad = True 以及is_leaf 为True时，才会计算梯度值
• 转置运算 Tensor.permute()，_version是否经过in-place操作
• 进行in-place操作 ： （1） t.detach() (2) t.data (3)with torch.no_grad():
• 切换环境 activate base 用Jupyter打开当前目录作为工作目录 jupyter lab： jupyter lab ./ jupyter notebook ：jupyter notebook ./
• 传统事件抽取方法大多采用人工构建的方式进行特征表示，并通过分类模型进行事件触发词分类和论元角色识别。
• 神经网络方法的优势在于能够自动学习构建特征，从而避免了繁琐的特征工程。
• 归一化：防止量纲不同导致数值大的对结果产生较大影响
  • 线性函数归一化 [0，1] (x - min)/(max - min)
  • 零均值归一化 1、求均值 2、求标准差 3、z = (x - 均值)/ 标准差
  • 作用：梯度下降快
• 需要归一化：线性会贵、支持向量机、神经网络 （需要类似wx + b。不需要的：决策树。
• pytorch学习记录，其主要的17个模块功能概述
• nlp = nlu + nlg(理解和生成)
• 语言模型（LM）:判断语句是不是人话，多大概率
• viterb算法：机器翻译translation model 和languge model 融合
• 句法分析：分析句子结构
• 依存分析：分析单词之间的关系、联系
• 分词工具包：
  
• 分词：前项最大匹配、后向最大匹配、双向最大匹配（max -length）
• 最短编辑距离：
• Filtering word:词过滤
• Stemming:one way to normalize
• one hot编码：boolean count td-idf
• 文本相似度计算
  • 欧式距离d = |s1 - s2| 无方向
  • 余弦相似度（有方向有距离）d = (s1(内积)s2)/(|s1|*|s2|）
• Tf-idf:
• 分布式表示方法：word2vec（词向量）
• 句子向量：平均法则、LSTM\RNN
• 集成学习：多个模型做决策
• PCA（主成分分析）: 无监督学习，通过协方差进行降维
• ICA（独立成分分析）：。无监督学习，通过进行降维
• MF（矩阵分解）：
• LSA（）：文本分析工作
• LDA：通过分析文本分析主题，LSA的高级版本
• 特征决定上限，模型不断逼近这个上限
• 端到端的方法就是去掉人工特征工程，使用AI进行学习，适应于图像领域，很多领域使用端到端不是很理想
• 限定域事件抽取根据粒度不同，分为句子级、文档级限定域事件抽取
• ACE事件模式包括8种事件类型和33种细分事件类 型，每种细分事件类型对应一组论元角色集合，所有细分事件共包 含36种论元角色
• 按照面向文本形式的不同，开放 域事件抽取的研究可以分为面向新闻文章的开放域事件抽取和面向社交媒体 （如推特脸书）短文本的开放域事件抽取两大类。
• 当遇到连乘比较时，可以加log，不会出现上溢和下溢
• jupyter 可以运行linux的命令 cat data.csv
• 马尔可夫(Markov)假设——未来的事件，只取决于有限的历史
• python

# lambda表达式格式： lambda 参数列表：函数体
add_lambda = lambda x, y : x + y
#三元表达式
print(1 if True else 2) # 1
print(1 if False else 2) # 2
#map函数
list1 = [1,2,3,4,5]
r = map(lambda x : 2 * x, list1)  # r = [2,4,5,6,8,10]
r = map(lambda x, y : x + y, [1,2,3],[2,4,6])
#filter 过滤器
def is_not_none(s):
	return s and len(s.strip()) > 0
list2 = [' ','', None, 'hello']
result = filter(  ,list2) # ['hello']
#reduce 函数
from functools import reduce
f = lambda x, y : x + y
r = reduce(f,[1,2,3,4,5],10)  # 25 初始化为10
#列表推导式（根据已有的列表推导出新的列表）
list1 = [1,2,3,4,5,6]
f = map(lambda x: x + x,list1)

list2 = [i + i for i in list1]
list3 = [i ** 3 for i in list1]
# 有选择性的筛选
list4 = [i*i for i in list1 if i > 3 ]
#集合推导式{}
#字典推导式
s = {
	"zhangsan":20,
	"lisi":15
}
# 拿出所有的key，并变成列表
s_key = [key for key,value in s.items()]
# key 和value颠倒
s1 = {value :key for key, value in s.items()}
#只拿出符合条件的值
s2 = {key:value for key,value in s.items() if key == "zhangsan"}

# 闭包 ：一个返回值是函数的函数
import time
def runtime():
	def now_time():
		print(time.time())
	return now_time
f = runtime()

# 读出一个文件中带有某些关键字的行
def make_filter(keep):
	def the_filter(file_name):
		file = open(file_name):
		lines = line.readlines()
		file.close()
		filter_doc = [i for i in lines if keep in i]
		return filter_doc
	return the_filter
filter1 = make_filter("8")
filter_result = filter1("data.csv")
print(filter_result)

#装饰器、语法糖、注解

#获取函数运行的时间
import time

def runtime(func)
	def get_time():
		print(time.time())
		func()
	return get_time
@runtime
def student_run():
	print("学生跑")
	func()
student_run()

# 如果函数有参数
# 有不定长参数的装饰器
def runtime(func)
	def get_time(*args):
		print(time.time())
		func(*args)
	return get_time
@runtime
def student_run(i):
	print("学生跑")
	func()
student_run(1)
# 有不定长参数的装饰器
def runtime(func)
	def get_time(**args):
		print(time.time())
		func(**args)
	return get_time
@runtime
def student_run(i,j):
	print("学生跑")
	func(1)
student_run()

# 有不定长参数的装饰器
def runtime(func)
	def get_time(*args):
		print(time.time())
		func(*args)
	return get_time
@runtime
def student_run(i):
	print("学生跑")
	func()
student_run(1)
# 有不定长+有提示(关键字)参数的装饰器
def runtime(func)
	def get_time(*arg,**args):
		print(time.time())
		func(*arg,**args)
	return get_time
@runtime
def student_run(i,j):
	print("学生跑")
	func(1)
student_run()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

• numpy

# numpy ： series dataframe
import numpy as np
data = [1,2,3,4,5]
n = np.array(data * 10)
print(data)
print(n)
#每一个np数组都有一个shape和一个dtype
n.shape # shape属性表示获取到np数组的维度
n.dtype # dtype属性表示获取数组的类型
#嵌套系列 ： 由一组等长列组成的列表
arr = [[1,2,3,4],[1,2,3,4]]
arr2 = np.array(arr)
print(arr2.ndim) #ndim 代表维度
#np对数据类型的一个判断
arr = [['1','2',3],[2,3,4]]
arr2 = np.array(arr) # arr2 内容全部转成了字符串，当成员中有一个为float，则全部都会是float
#numpy进行指定长度数组的创建
np.zeros(10)
np.ones((2,3))
np.empty((2,3,4))
np.arange(10) #arange是range函数的数组版本  
# int类型 8 16 32 64
# float 16 32 64 128
#矢量化
#数组通常不用在编写循环的情况下就可以进行批量运算
# arr1 + arr2
# arr1 - arr2
# arr1 * 5
#numpy 数组的索引和切片操作
arr[1]
arr[4:]
arr[0:4] = 11
arr.copy() #复制一份  
# 二维numpy中 arr[1][2] 等价于 arr[1,2]
arr == '1' # 获取增加数组
arr[[4,3,0,8]] #以一个特定的顺序来选取行中的子集，我们传入一个用于指定顺序的整数列表或数组
arr[[4,3,0,8],[0,1,2,1]] # 获取4，3，0，8行的某一个索引值
# 在选完1，5，7，2行的数据后，我们进行列上的一个选择
arr[[1,5,7,2]][:,[0,3,1,2]]
arr[np.ix_([1,5,7,2],[0,3,1,2])]
# 数组转置 和 轴对换
arr.transpose()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

• random.randrange(start, stop[, step])
• torch.gather
• 防止梯度进行追踪，backward是梯度进行更新

            self.model.eval()
            with torch.no_grad(): # 防止跟踪
                action = self.model(state)
1
2
3

• python中map用于将一个函数应用于可迭代对象（例如列表、元组等）的每个元素，并返回一个新的可迭代对象，其中包含了应用函数后的结果。eg: map(function, iterable)
• 12种特征融合的方法：拼接、相加（减少噪声的影响）、相乘（增强特征的语义信息）、注意力机制（对不同特征进行加权）、金字塔池化（有效捕捉不同尺度的信息，提高模型的性能）、反卷积、Weighing(给每个特征向量赋予权重，进行加权和得到一个融合向量)、Concatenation+FC（拼接多个特征向量的基础上，使用全连接层学习特征之间的关系和依赖，得到最终的融合向量）、Multi-layer Perceptron（使用多层感知机对特征进行融合）、Bi-directional LSTM（适用于特征来自于序列数据）、Attention Mechanism（使用注意力机制来学习不同特征之间的关系和依赖，对特征进行加权融合）、GCN（适用于不同特征之间的存在图结构关系时
• ）
• 
• 有的时候环境不一样，某个环境报错，有的不报错，可能是包版本的问题。