分词器你真的搞明白了嘛

Posted 2020-12-10 gaowenxingxing

参考csdn

1.句子分割 text_to_word_sequence
	keras.preprocessing.text.text_to_word_sequence(text, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘, lower=True, split=" ")
	本函数将一个句子拆分成单词构成的列表。使用filters参数中定义的标点符号和split参数中定义的分隔符作为分割句子的标准。
	text_to_word_sequence，将文本转换为一个字符序列，即将文本转换为序列（即单词在字典中的下标构成的列表，从1算起）。
	参数：
		text：字符串，待处理的文本
		filters：需要滤除的字符的列表或连接形成的字符串，例如标点符号。
			默认值为 ‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘，包含标点符号，制表符和换行符等。
		lower：布尔值，是否将序列设为小写形式
		split：字符串，单词的分隔符，如空格
	返回值：字符串列表
	>>> import keras
	>>> text="我爱你!!你爱我么??"
	>>> keras.preprocessing.text.text_to_word_sequence(text, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘, lower=True, split=" ")
	[‘我爱你‘, ‘你爱我么‘]
	>>> text="好好学习,天天向上!!"
	>>> keras.preprocessing.text.text_to_word_sequence(text, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘, lower=True, split=" ")
	[‘好好学习‘, ‘天天向上‘]
	#使用了中文形式的标点符号，因此filters参数中也应加上中文形式的标点符号，才能正常分割句子
	>>> text="好好学习，天天向上！！"
	>>> keras.preprocessing.text.text_to_word_sequence(text, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
，！‘, lower=True, split=" ")
	[‘好好学习‘, ‘天天向上‘]
 
2.one-hot编码
	keras.preprocessing.text.one_hot(text, n, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘, lower=True, split=" ")
	本函数将一段文本编码为one-hot形式的码，即仅记录词在词典中的下标。
	从定义上，当字典长为n时，每个单词应形成一个长为n的向量，其中仅有单词本身在字典中下标的位置为1，其余均为0，这称为one-hot。
	为了方便起见，函数在这里仅把“1”的位置，即字典中词的下标记录下来。
	这个函数表示把一个string的文本编码成一个index的list，这里的index指的是在字典中的index。字典的规模可以制定，就是n。
	使用filters参数中定义的标点符号和split参数中定义的分隔符作为分割句子的标准。
	one_hot，对字符串序列进行独热编码。所谓的独热编码就是在整个文本中，根据字符出现的次数进行排序，以序号作为字符的索引构成词频字典，
	在一个字典长度的全零序列中将序号对应的元素置1来表示序号的编码。比如“我”的序号是5，全字典长度为10，
	那么“我”的独热编码为[0，0，0，0，1，0，0，0，0，0]。
	参数：
		text：字符串，待处理的文本
		n：整数，字典长度
		filters：需要滤除的字符的列表或连接形成的字符串，例如标点符号。
			默认值为 ‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘，包含标点符号，制表符和换行符等。
		lower：布尔值，是否将序列设为小写形式
		split：字符串，单词的分隔符，如空格
	返回值：整数列表，每个整数是[1,n]之间的值，代表一个单词（不保证唯一性，即如果词典长度不够，不同的单词可能会被编为同一个码）。
 
	>>> import keras
	#使用filters参数中定义的标点符号和split参数中定义的分隔符把句子进行分割之后，n为字典长度，每个被分割出来的单词先是被one-hot化，
	#相同的单词具有相同的one-hot码，其中单词会被放到字典中，单词在字典中的索引index作为one-hot向量中值为1的索引index，
	#函数返回值便是这个单词在one-hot向量中值为1的索引index，也同样为单词在字典中的索引index，最终封装为列表返回全部单词的索引。
	>>> text=‘Near is a good name, you should always be near to someone to save‘
	>>> keras.preprocessing.text.one_hot(text, 20, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘, lower=True, split=" ")
	[19, 12, 8, 15, 1, 4, 9, 14, 13, 19, 15, 3, 15, 12]
 
3.特征哈希hashing_trick
	keras.preprocessing.text.hashing_trick(text, n, hash_function=None, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘, lower=True, split=‘ ‘)
	将文本转换为固定大小的哈希空间中的索引序列。
	hashing_trick，对文本或者字符串进行哈希计算，将计算所得的哈希值作为存储该文本或者字符串的索引。
	参数
		text：字符串，待处理的文本
		n: 哈希空间的维度
		hash_function: 默认为 python hash 函数, 可以是 ‘md5‘ 或任何接受输入字符串, 并返回 int 的函数。
			      注意 hash 不是一个稳定的哈希函数, 因此在不同执行环境下会产生不同的结果, 作为对比, ‘md5‘ 是一个稳定的哈希函数。
		filters：需要滤除的字符的列表或连接形成的字符串，例如标点符号。
			默认值为 ‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘，包含标点符号，制表符和换行符等。
		lower：布尔值，是否将序列设为小写形式
		split：字符串，单词的分隔符，如空格
	返回值：整数列表
 
	>>> import keras
	>>> text=‘Near is a good name, you should always be near to someone to save‘
	>>> keras.preprocessing.text.hashing_trick(text, 20, hash_function=‘md5‘, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘, lower=True, split=‘ ‘)
	[5, 19, 14, 15, 15, 3, 13, 12, 7, 5, 6, 16, 6, 11]
 
4.填充序列pad_sequences
	keras.preprocessing.sequence.pad_sequences(sequences, maxlen=None, dtype=‘int32‘, padding=‘pre‘, truncating=‘pre‘, value=0.)
	将长为nb_samples的序列（标量序列）转化为形如(nb_samples,nb_timesteps)2D numpy array。
	如果提供了参数maxlen，nb_timesteps=maxlen，否则其值为最长序列的长度。其他短于该长度的序列都会在后部填充0以达到该长度。
	长于nb_timesteps的序列将会被截断，以使其匹配目标长度。padding和截断发生的位置分别取决于padding和truncating.
	参数
		sequences：浮点数或整数构成的两层嵌套列表
		maxlen：None或整数，为序列的最大长度。大于此长度的序列将被截短，小于此长度的序列将在后部填0.
		dtype：返回的numpy array的数据类型
		padding：‘pre’或‘post’，确定当需要补0时，在序列的起始还是结尾补
		truncating：‘pre’或‘post’，确定当需要截断序列时，从起始还是结尾截断
		value：浮点数，此值将在填充时代替默认的填充值0
	返回值
		返回形如(nb_samples,nb_timesteps)的2D张量
 
5.tensorflow中的分词器Tokenizer
	enc_vocab_size = 20000
	tokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=enc_vocab_size, oov_token=3)
    	tokenizer.fit_on_texts(texts)
	tensor = tokenizer.texts_to_sequences(texts)
 
	Tokenizer，一个将文本进行数字符号化的方法类，在进行神经网络训练时需要输入的数据是数值，因此需要将文本字符转换为可进行数学计算的数值。
	在这个方法类中提供了fit_on_sequences、fit_on_texts、get_config、sequences_to_matrix、sequences_to_texts和sequences_to_texts_generator等方法。
	在使用Tokenizer时，可以配置如下参数。
		? num_words：配置符号化的最大数量。
		? filters：配置需要过滤的文本符号，比如逗号、中括号等。
		? lower：配置是否需要将大写全部转换为小写。这个配置是相对于英文来说的，中文不存在大小写的问题。
		? split：配置进行分割的分隔符。
		? char_level：配置字符串的级别。如果配置为True，那么每个字符都会作为一个token。
		? oov_token：配置不在字典中的字符的替换数字，一般使用“3”这个数字来代替在字典中找不到的字符。
 
6.keras中的分词器Tokenizer
	keras.preprocessing.text.Tokenizer(num_words=None, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘, lower=True, split=" ", char_level=False)
	Tokenizer是一个用于向量化文本，或将文本转换为序列（即单词在字典中的下标构成的列表，从1算起）的类。
	1.参数：
		num_words: None或整数，处理的最大单词数量。若被设置为整数，则分词器将被限制为待处理数据集中最常见的num_words个单词
		filters：需要滤除的字符的列表或连接形成的字符串，例如标点符号。
			默认值为 ‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘，包含标点符号，制表符和换行符等。
		lower：布尔值，是否将序列设为小写形式
		split：字符串，单词的分隔符，如空格
		char_level: 如果为 True, 每个字符将被视为一个标记
 
	2.类方法
		fit_on_texts(texts)
			texts：要用以训练的文本列表
			
		texts_to_sequences(texts)
			texts：待转为序列的文本列表
			返回值：序列的列表，列表中每个序列对应于一段输入文本
 
		texts_to_sequences_generator(texts)
			本函数是texts_to_sequences的生成器函数版
			texts：待转为序列的文本列表
			返回值：每次调用返回对应于一段输入文本的序列
 
		texts_to_matrix(texts, mode)：
			texts：待向量化的文本列表
			mode：‘binary’，‘count’，‘tfidf’，‘freq’之一，默认为‘binary’
			返回值：形如(len(texts), nb_words)的numpy array
 
		fit_on_sequences(sequences):
			sequences：要用以训练的序列列表
			
		sequences_to_matrix(sequences):
			sequences：待向量化的序列列表
			mode：‘binary’，‘count’，‘tfidf’，‘freq’之一，默认为‘binary’
			返回值：形如(len(sequences), nb_words)的numpy array
 
	3.属性
		Tokenizer对象.word_counts: 获取字典{单词:单词出现次数}，将单词（字符串）映射为它们在训练期间出现的次数。仅在调用fit_on_texts之后设置。
		Tokenizer对象.word_docs: 获取字典{单词:单词出现次数}，将单词（字符串）映射为它们在训练期间所出现的文档或文本的数量。仅在调用fit_on_texts之后设置。
		Tokenizer对象.word_index: 获取字典{单词:单词在字典中的索引值}，将单词（字符串）映射为它们的排名或者索引。仅在调用fit_on_texts之后设置。
		Tokenizer对象.index_word[index]: 获取单词（字符串），根据传入单词所在字典中的索引值来获取该单词。
		Tokenizer对象.word_index[word]: 获取单词在字典中的索引值，根据传入单词，获取单词所在字典中的索引值。
		Tokenizer对象.document_count: 获取整数。分词器被训练的文档（文本或者序列）数量。仅在调用fit_on_texts或fit_on_sequences之后设置。
 
	>>> import keras
	>>> tokenizer = keras.preprocessing.text.Tokenizer(num_words=10, filters=‘!"#$%&()*+,-./:;<=>?@[]^_`{|}~	
‘, lower=True, split=" ", char_level=False)
	>>> text = ["今天 北京 下雨 了", "我 今天 加班"]
	>>> tokenizer.fit_on_texts(text)
	>>> tokenizer.word_counts
	OrderedDict([(‘今天‘, 2), (‘北京‘, 1), (‘下雨‘, 1), (‘了‘, 1), (‘我‘, 1), (‘加班‘, 1)])
	>>> tokenizer.word_docs
	defaultdict(<class ‘int‘>, {‘下雨‘: 1, ‘了‘: 1, ‘今天‘: 2, ‘北京‘: 1, ‘加班‘: 1, ‘我‘: 1})
	#word_index返回每个被分割的单词在字典中的索引值，从1算起。
	>>> tokenizer.word_index
	{‘今天‘: 1, ‘北京‘: 2, ‘下雨‘: 3, ‘了‘: 4, ‘我‘: 5, ‘加班‘: 6}
	>>> tokenizer.document_count
	2
	#texts_to_sequences返回每个被分割的单词在字典中的索引值，从1算起。
	#每个句子对应一个列表，每个列表中元素值为该句子中的单词在字典中的索引值。
	>>> tokenizer.texts_to_sequences(text)
	[[1, 2, 3, 4], [5, 1, 6]]
	#每个句子所转换为列表，如果列表中单词所对应的索引值数量不满maxlen，则默认补0，可指定padding=‘post‘在后面做填充
	>>> keras.preprocessing.sequence.pad_sequences(tokenizer.texts_to_sequences(text), maxlen=10, padding=‘post‘)
	array([[1, 2, 3, 4, 0, 0, 0, 0, 0, 0],
                [5, 1, 6, 0, 0, 0, 0, 0, 0, 0]])

真的知识不容许你太快了_{还是扎实一些，一步一个脚印吧}