1. ¿Qué es la ingeniería de funciones?
El maestro Andrew Ng, un maestro en el campo del aprendizaje automático, dijo: "Crear funciones es difícil, requiere mucho tiempo y requiere conocimiento experto. El "aprendizaje automático aplicado" es básicamente ingeniería de funciones". Industria en la que los datos y las características
determinan el límite superior del aprendizaje automático, y los modelos y algoritmos solo se acercan a este límite superior.
La ingeniería de características es el proceso de utilizar conocimientos y habilidades profesionales para procesar datos de modo que las características puedan desempeñar un mejor papel en los algoritmos de aprendizaje automático. Importancia
: afectará directamente el efecto del aprendizaje automático.
2. ¿Qué utilizar para la ingeniería de funciones?
Actualmente es sklearn
3. Comparación de ubicación y procesamiento de datos de ingeniería de características.
Primero, pandas
es una herramienta muy conveniente para la lectura de datos y formatos de procesamiento básicos.
Segundo, sklearn
proporciona una interfaz potente para el procesamiento de funciones.
3. La ingeniería de funciones incluye
(1) extracción de funciones
(2) preprocesamiento de funciones
(3) reducción de la dimensionalidad de las funciones
4. Extracción de características/extracción de características.
Por ejemplo, hay un artículo breve en inglés y el artículo debe clasificarse:
algoritmo de aprendizaje automático - método estadístico - fórmula matemática.
La fórmula matemática no puede manejar cadenas y el tipo de cadena de texto a convertir en un
problema numérico es: texto ¿Cómo convertir un tipo a un valor numérico?
Clasificación Posición del barco
Pregunta: ¿Convertir tipo a valor numérico?
codificación onehot o variable ficticia
4. Extracción de características
1. ¿Qué es la extracción de características?
Convierta cualquier dato (como texto o imagen) en características digitales que puedan usarse para el aprendizaje automático.
Nota: La valorización de características es para que la computadora comprenda mejor los datos
(1) Extracción de características del diccionario (discretización de características )
(2) Extracción de características de texto
(3) Extracción de características de imagen (se introducirá el aprendizaje profundo)
2. API de extracción de funciones
sklearn.feature_extraction
5. Extracción de funciones del diccionario
sklearn.feature_extraction.DictVectorizer(sparse=True, ...)
Función: caracterizar datos de campo
Explicación:
vector es un vector en matemáticas y
una matriz vectorial en física. Una matriz bidimensional.
Si el vector se almacena en una computadora, se puede almacenar en una matriz unidimensional.
1. DicVectorizer.fit_transform(X)
X: campo o iterador que contiene el diccionario
Valor de retorno: devuelve una matriz dispersa
2. DicVectorizer.inverse_transform(X)
X: matriz de matriz o matriz dispersa
Valor de retorno: formato de datos antes de la conversión
3.
Valor de retorno de DicVectorizer.get_feature_names(): nombre de categoría de retorno
4. Ejemplo
Realizamos extracción de características en los siguientes datos.
[{'city': '北京','temperature':100}
{'city': '上海','temperature':60}
{'city': '深圳','temperature':30}]
La fila superior representa nombres de características y las tres filas inferiores son datos.
Para explicarlo, si hay tres ciudades, habrá 3 ceros. Cualquiera que sea el 0 que esté en el orden del diccionario se convierte en 1. Es un poco como si una
muestra de codificación binaria fuera una Matriz con tres filas y dos columnas. Después de la extracción de características del diccionario, el tamaño de la muestra pasa a ser de 4 columnas y
la categoría de ciudad se convierte en codificación one-hot.
5. Modificar day01_machine_learning.py
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
def datasets_demo():
"""
sklearn数据集使用
"""
#获取数据集
iris = load_iris()
print("鸢尾花数据集：\n", iris)
print("查看数据集描述：\n", iris["DESCR"])
print("查看特征值的名字：\n", iris.feature_names)
print("查看特征值几行几列：\n", iris.data.shape)
#数据集的划分
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
print("训练集的特征值：\n", x_train, x_train.shape)
return None
def dict_demo():
"""
字典特征抽取
"""
data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
# 1、实例化一个转换器类
transfer = DictVectorizer()
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new)
return None
if __name__ == "__main__":
# 代码1：sklearn数据集使用
#datasets_demo()
# 代码2：字典特征抽取
dict_demo()resultado de la operación:
data_new：
(0, 1) 1.0
(0, 3) 100.0
(1, 0) 1.0
(1, 3) 60.0
(2, 2) 1.0
(2, 3) 30.0¿Por qué aparece este resultado? Después de que
esta API
pasa
data_new：
[[ 0. 1. 0. 100.]
[ 1. 0. 0. 60.]
[ 0. 0. 1. 30.]]Cómo mirar matrices dispersas: en algunas matrices, hay muchos menos elementos distintos de cero que 0 elementos. Método de almacenamiento típico: método triplete (fila, columna, valor del elemento)
marca la posición de los elementos distintos de cero en la matriz dispersa y el valor correspondiente. En términos sencillos: el valor en la fila 0 y la columna 1 es 1. En el resultado esperado Puedes encontrarlo aquí
La ventaja es ahorrar memoria y mejorar la eficiencia de carga.
Agregar nombre de función de impresión:
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
def datasets_demo():
"""
sklearn数据集使用
"""
#获取数据集
iris = load_iris()
print("鸢尾花数据集：\n", iris)
print("查看数据集描述：\n", iris["DESCR"])
print("查看特征值的名字：\n", iris.feature_names)
print("查看特征值几行几列：\n", iris.data.shape)
#数据集的划分
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
print("训练集的特征值：\n", x_train, x_train.shape)
return None
def dict_demo():
"""
字典特征抽取
"""
data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
# 1、实例化一个转换器类
transfer = DictVectorizer(sparse=False)
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new)
print("特征名字：\n", transfer.get_feature_names())
return None
if __name__ == "__main__":
# 代码1：sklearn数据集使用
#datasets_demo()
# 代码2：字典特征抽取
dict_demo()data_new：
[[ 0. 1. 0. 100.]
[ 1. 0. 0. 60.]
[ 0. 0. 1. 30.]]
特征名字：
['city=上海', 'city=北京', 'city=深圳', 'temperature']6. Extracción de características de texto
1. Función:
caracterizar datos de texto.
Las palabras se utilizan como características y las palabras características son
2. Método 1: CountVectorizer
sklearn.feature_extraction.text.CountVectorizer(stop_words=[])
valor de retorno: matriz de frecuencia de palabras de retorno
3. CountVectorizer.fit_transform(X)
X: texto o un objeto iterable que contiene una cadena de texto
Valor de retorno: devuelve una matriz dispersa
4. CountVectorizer.inverse_transform(X)
X: matriz o matriz dispersa
Valor de retorno: formato de datos antes de la conversión
5. CountVectorizer.get_feature_names()
valor de retorno: lista de palabras
6. Ejemplo:
extraigamos características de los siguientes datos.
["life is short,i like python",
"life is too long,i dislike python"]
¿Por qué no hay i? Porque cuando se diseñó la API, se consideró que la clasificación de palabras o el análisis de sentimientos tenían poca importancia.
7. Modificar day01_machine_learning.py
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_extraction.text import CountVectorizer
def datasets_demo():
"""
sklearn数据集使用
"""
#获取数据集
iris = load_iris()
print("鸢尾花数据集：\n", iris)
print("查看数据集描述：\n", iris["DESCR"])
print("查看特征值的名字：\n", iris.feature_names)
print("查看特征值几行几列：\n", iris.data.shape)
#数据集的划分
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
print("训练集的特征值：\n", x_train, x_train.shape)
return None
def dict_demo():
"""
字典特征抽取
"""
data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
# 1、实例化一个转换器类
transfer = DictVectorizer(sparse=False)
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new)
print("特征名字：\n", transfer.get_feature_names())
return None
def count_demo():
"""
文本特征抽取
"""
data = ["life is short,i like like python", "life is too long,i dislike python"]
# 1、实例化一个转换器类
transfer = CountVectorizer()
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new.toarray())
print("特征名字：\n", transfer.get_feature_names())
return None
if __name__ == "__main__":
# 代码1：sklearn数据集使用
#datasets_demo()
# 代码2：字典特征抽取
#dict_demo()
# 代码3：文本特征抽取
count_demo()resultado de la operación:
data_new：
[[0 1 1 2 0 1 1 0]
[1 1 1 0 1 1 0 1]]
特征名字：
['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']Cuente el número de apariciones de palabras destacadas en cada muestra.
8. Extracción de características de texto chino
Pregunta: ¿Qué pasa si reemplazamos los datos al chino?
Entonces, el resultado es que toda la oración se trata como una sola palabra, ¡y el borrado manual no admite ni una sola palabra china!
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_extraction.text import CountVectorizer
def datasets_demo():
"""
sklearn数据集使用
"""
#获取数据集
iris = load_iris()
print("鸢尾花数据集：\n", iris)
print("查看数据集描述：\n", iris["DESCR"])
print("查看特征值的名字：\n", iris.feature_names)
print("查看特征值几行几列：\n", iris.data.shape)
#数据集的划分
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
print("训练集的特征值：\n", x_train, x_train.shape)
return None
def dict_demo():
"""
字典特征抽取
"""
data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
# 1、实例化一个转换器类
transfer = DictVectorizer(sparse=False)
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new)
print("特征名字：\n", transfer.get_feature_names())
return None
def count_demo():
"""
文本特征抽取
"""
data = ["life is short,i like like python", "life is too long,i dislike python"]
# 1、实例化一个转换器类
transfer = CountVectorizer()
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new.toarray())
print("特征名字：\n", transfer.get_feature_names())
return None
def count_chinese_demo():
"""
中文文本特征抽取
"""
data = ["我 爱 北京 天安门", "天安门 上 太阳 升"]
# 1、实例化一个转换器类
transfer = CountVectorizer()
# 2、调用fit_transform
data_new = transfer.fit_transform(data)
print("data_new:\n", data_new.toarray());
print("特征名字：\n", transfer.get_feature_names())
return None
if __name__ == "__main__":
# 代码1：sklearn数据集使用
#datasets_demo()
# 代码2：字典特征抽取
#dict_demo()
# 代码3：文本特征抽取
#count_demo()
# 代码4：中文文本特征抽取
count_chinese_demo()
resultado de la operación:
data_new:
[[1 1 0]
[0 1 1]]
特征名字：
['北京', '天安门', '太阳']9. Stop_words de CountVectorizer stop_words
: Palabras vacías.
Creemos que hay algunas palabras que no son beneficiosas para la clasificación final. Puedes buscar en la lista de palabras vacías.
10. Convierta las siguientes tres oraciones en valores propios.
Hoy es cruel, mañana será aún más cruel y pasado mañana será maravilloso,
pero la mayoría de ellos morirán mañana por la noche, así que no te rindas hoy.
La luz que vemos desde galaxias distantes fue emitida hace millones de años,
por lo que cuando vemos el universo, estamos mirando su pasado.
Realmente no entiendes algo si sólo lo entiendes de una manera.
El secreto para comprender lo que realmente significa algo depende de cómo se relaciona con lo que sabemos.
(1) Prepare oraciones, use jieba.cut para la segmentación de palabras e instale la biblioteca: pip3 install jieba
(2) Cree una instancia de CountVectorizer
(3) Convierta el resultado de la segmentación de palabras en una cadena como valor de entrada de fit_transform
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_extraction.text import CountVectorizer
import jieba
def datasets_demo():
"""
sklearn数据集使用
"""
#获取数据集
iris = load_iris()
print("鸢尾花数据集：\n", iris)
print("查看数据集描述：\n", iris["DESCR"])
print("查看特征值的名字：\n", iris.feature_names)
print("查看特征值几行几列：\n", iris.data.shape)
#数据集的划分
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
print("训练集的特征值：\n", x_train, x_train.shape)
return None
def dict_demo():
"""
字典特征抽取
"""
data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
# 1、实例化一个转换器类
transfer = DictVectorizer(sparse=False)
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new)
print("特征名字：\n", transfer.get_feature_names())
return None
def count_demo():
"""
文本特征抽取
"""
data = ["life is short,i like like python", "life is too long,i dislike python"]
# 1、实例化一个转换器类
transfer = CountVectorizer()
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new.toarray())
print("特征名字：\n", transfer.get_feature_names())
return None
def count_chinese_demo():
"""
中文文本特征抽取
"""
data = ["我 爱 北京 天安门", "天安门 上 太阳 升"]
# 1、实例化一个转换器类
transfer = CountVectorizer()
# 2、调用fit_transform
data_new = transfer.fit_transform(data)
print("data_new:\n", data_new.toarray());
print("特征名字：\n", transfer.get_feature_names())
return None
def cut_word(text):
"""
进行中文分词
"""
return " ".join(list(jieba.cut(text))) #返回一个分词生成器对象，强转成list，再join转成字符串
def count_chinese_demo2():
"""
中文文本特征抽取，自动分词
"""
# 1、将中文文本进行分词
data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
"我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
data_new = []
for sent in data:
data_new.append(cut_word(sent))
print(data_new)
# 2、实例化一个转换器类
transfer = CountVectorizer()
# 3、调用fit_transform()
data_final = transfer.fit_transform(data_new)
print("data_final：\n", data_final.toarray())
print("特征名字：\n", transfer.get_feature_names())
return None
if __name__ == "__main__":
# 代码1：sklearn数据集使用
#datasets_demo()
# 代码2：字典特征抽取
#dict_demo()
# 代码3：文本特征抽取
#count_demo()
# 代码4：中文文本特征抽取
#count_chinese_demo()
# 代码5：中文文本特征抽取，自动分词
count_chinese_demo2()
# 代码6： 测试jieba库中文分词
#print(cut_word("我爱北京天安门"))
Resultados de:
Building prefix dict from the default dictionary ...
Loading model from cache /tmp/jieba.cache
Loading model cost 1.304 seconds.
Prefix dict has been built successfully.
['今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。', '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 前 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。', '如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。']
data_final：
[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]
[0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]
[1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]
特征名字：
['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '这样']Este método se basa en la cantidad de veces que aparece una palabra en un artículo. Sin embargo, algunas palabras como "nosotros" y "tú" aparecen muchas veces en todos los artículos. Lo que preferimos es que aparezcan muchas veces en artículos de una determinada categoría pero rara vez en artículos de otras categorías. De esta manera las palabras son más propicias. a nuestra clasificación.
Encuentre esta palabra clave. Se introdujo TfidfVectorizer
11, Método 2: TfidfVectorizer
sklearn.feature_extraction.text.TfidfVectorizer
12. Extracción de características de texto tf-idf
(1) La idea principal de TF-IDF es: si una palabra o frase tiene una alta probabilidad de aparecer en un artículo y rara vez aparece en otros artículos, entonces esta palabra o frase se considera Tiene buena capacidad de discriminación de categorías y es adecuado para clasificación
(2) Función TF-IDF: se utiliza para evaluar la importancia de una palabra para un conjunto de documentos o uno de los documentos de un corpus.
13. Fórmula Tf-idf
(1) La frecuencia del término (tf) se refiere a la frecuencia de una palabra determinada que aparece en el documento
(2) La frecuencia inversa del documento (idf) es la importancia universal de una palabra medida de sexo. El idf de una palabra específica se puede obtener dividiendo el número total de archivos por el número de archivos que contienen la palabra y luego tomando el logaritmo en base 10 para obtener el cociente (3) El resultado final puede entenderse como el grado de
importancia
Nota: Si el número total de palabras en un documento es 100 y la palabra "muy" aparece 5 veces, entonces la frecuencia de palabras de la palabra "muy" en el documento es 5/100 = 0,05. El método para calcular la frecuencia de archivos (IDF) es dividir el número total de archivos en el conjunto de archivos por el número de archivos en los que aparece la palabra "muy". Por lo tanto, si la palabra "muy" aparece en 1.000 documentos y el número total de documentos es 10.000.000, la frecuencia inversa del documento es lg (10.000.000/1.0000) = 3. Finalmente, la puntuación "muy" de tf-idf para este documento es 0,05 * 3=0,15
14. Tf-idf indica el grado de importancia.
Dos palabras: economía, muy
1000 artículos - corpus
100 artículos - muy
10 artículos - economía
dos artículos
Artículo A (100 palabras): 10 veces económico
tf: 10/ 100 = 0,1
idf: log 10 (1000/10) = 2
tf-idf: 0,2
Artículo B (100 palabras): 10 veces muy
tf: 10/100 = 0,1
idf: log 10 (1000/100) = 1
tf-idf: ¿0,1
logaritmo?
2 ^ 3 = 8
registro 2 (8) = 3
registro 10 (10) = 1
15. API
sklearn.feature_extraction.text.TfidfVectorizer(stop_words=None,...)
Valor de retorno: Devuelve la matriz de pesos de las palabras
16. TfidfVectorizer.fit_transform(X)
X: Texto u objeto iterable que contiene una cadena de texto
Valor de retorno: Devuelve una matriz dispersa
17. TfidfVectorizer.inverse_transform(X)
X: matriz de matriz o matriz dispersa
Valor de retorno: formato de datos antes de la conversión
18.
Valor de retorno de TfidfVectorizer.get_feature_names(): lista de palabras
19. Utilice tfidf para extraer funciones
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
import jieba
def datasets_demo():
"""
sklearn数据集使用
"""
#获取数据集
iris = load_iris()
print("鸢尾花数据集：\n", iris)
print("查看数据集描述：\n", iris["DESCR"])
print("查看特征值的名字：\n", iris.feature_names)
print("查看特征值几行几列：\n", iris.data.shape)
#数据集的划分
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
print("训练集的特征值：\n", x_train, x_train.shape)
return None
def dict_demo():
"""
字典特征抽取
"""
data = [{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}]
# 1、实例化一个转换器类
transfer = DictVectorizer(sparse=False)
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new)
print("特征名字：\n", transfer.get_feature_names())
return None
def count_demo():
"""
文本特征抽取
"""
data = ["life is short,i like like python", "life is too long,i dislike python"]
# 1、实例化一个转换器类
transfer = CountVectorizer()
# 2、调用fit_transform()
data_new = transfer.fit_transform(data)
print("data_new：\n", data_new.toarray())
print("特征名字：\n", transfer.get_feature_names())
return None
def count_chinese_demo():
"""
中文文本特征抽取
"""
data = ["我 爱 北京 天安门", "天安门 上 太阳 升"]
# 1、实例化一个转换器类
transfer = CountVectorizer()
# 2、调用fit_transform
data_new = transfer.fit_transform(data)
print("data_new:\n", data_new.toarray());
print("特征名字：\n", transfer.get_feature_names())
return None
def cut_word(text):
"""
进行中文分词
"""
return " ".join(list(jieba.cut(text))) #返回一个分词生成器对象，强转成list，再join转成字符串
def count_chinese_demo2():
"""
中文文本特征抽取，自动分词
"""
# 1、将中文文本进行分词
data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
"我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
data_new = []
for sent in data:
data_new.append(cut_word(sent))
print(data_new)
# 2、实例化一个转换器类
transfer = CountVectorizer()
# 3、调用fit_transform()
data_final = transfer.fit_transform(data_new)
print("data_final：\n", data_final.toarray())
print("特征名字：\n", transfer.get_feature_names())
return None
def tfidf_demo():
"""
用tf-idf的方法进行文本特征抽取
"""
# 1、将中文文本进行分词
data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
"我们看到的从很远星系来的光是在几百万年前之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
data_new = []
for sent in data:
data_new.append(cut_word(sent))
print(data_new)
# 2、实例化一个转换器类
transfer = TfidfVectorizer()
# 3、调用fit_transform()
data_final = transfer.fit_transform(data_new)
print("data_final：\n", data_final.toarray())
print("特征名字：\n", transfer.get_feature_names())
return None
if __name__ == "__main__":
# 代码1：sklearn数据集使用
#datasets_demo()
# 代码2：字典特征抽取
#dict_demo()
# 代码3：文本特征抽取
#count_demo()
# 代码4：中文文本特征抽取
#count_chinese_demo()
# 代码5：中文文本特征抽取，自动分词
#count_chinese_demo2()
# 代码6： 测试jieba库中文分词
#print(cut_word("我爱北京天安门"))
# 代码7：用tf-idf的方法进行文本特征抽取
tfidf_demo()
Resultados de:
Building prefix dict from the default dictionary ...
Loading model from cache /tmp/jieba.cache
Loading model cost 1.415 seconds.
Prefix dict has been built successfully.
['今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。', '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 前 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。', '如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。']
data_final：
[[0. 0. 0.21821789 0. 0. 0.
0.43643578 0. 0. 0. 0. 0.
0.21821789 0. 0.21821789 0. 0. 0.
0. 0.21821789 0.21821789 0. 0.43643578 0.
0.21821789 0. 0.43643578 0.21821789 0. 0.
0. 0.21821789 0.21821789 0. 0. 0. ]
[0. 0. 0. 0.2410822 0. 0.
0. 0.2410822 0.2410822 0.2410822 0. 0.
0. 0. 0. 0. 0. 0.2410822
0.55004769 0. 0. 0. 0. 0.2410822
0. 0. 0. 0. 0.48216441 0.
0. 0. 0. 0. 0.2410822 0.2410822 ]
[0.15698297 0.15698297 0. 0. 0.62793188 0.47094891
0. 0. 0. 0. 0.15698297 0.15698297
0. 0.15698297 0. 0.15698297 0.15698297 0.
0.1193896 0. 0. 0.15698297 0. 0.
0. 0.15698297 0. 0. 0. 0.31396594
0.15698297 0. 0. 0.15698297 0. 0. ]]
特征名字：
['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '这样']20. La importancia del
algoritmo de aprendizaje automático de clasificación Tf-idf para el procesamiento temprano de datos en la clasificación de artículos.