Cómo clasificar documentos para una consulta usando NLP

Deja un comentario / Por /

En este artículo, veremos los siguientes modelos que intentan clasificar los documentos en función de una consulta determinada.

  • Regresión lineal

    • Los modelos lingüísticos han recorrido un largo camino desde su creación a principios de la década de 2000. Diseñados originalmente para predecir la siguiente palabra en una oración o documento, han evolucionado para convertirse en herramientas sofisticadas capaces de realizar una variedad de tareas, desde la traducción de idiomas hasta la generación de texto.

    Antes de entrar en el artículo, todos los enlaces a conjuntos de datos y Jupyter Notebooks se proporcionan al final del artículo en la sección de enlaces.

    Puede encontrar el conjunto de datos aquí

    También te puede interesarPasado, presente y futuro de la inteligencia artificial: un estudio de caso de la evolución de la IA

    Tengo que describir el conjunto de datos antes de pasar a la parte de construcción del modelo.

    Descripción de datos
    1. docs.txt: un archivo de «documentos», cada uno con una identificación única (.I) y contenido (.W).
    2. consultas.txt: un archivo que contiene consultas, cada una con una identificación única (.I) y un texto de consulta (.W).
    3. relevancia.txt: un archivo que contiene la asignación de ID de consulta (columna 0) a ID de documento (columna 1). Puede ignorar las otras columnas.

    En los archivos de relevancia, para cada par, el documento es relevante para la consulta.
    Una consulta puede asignarse a más de un ID de documento.
    Contienen la «verdad básica» que vincula las consultas a los documentos.
    Úselos para entrenar y probar su algoritmo. Algunas consultas no tienen pares en este archivo.

    Dado que se trata de datos de texto sin procesar, tenemos que crear un conjunto de datos viable que podamos usar para construir nuestro modelo

    También te puede interesarMagia animada con GPT-4 y Manim: crea una esfera rodante en menos de 1 minuto

    Primero crearemos un marco de datos de documentos

    import pandas as pd
    f=open('docs.txt')
    doc_str = f.read()
    docs = doc_str.split(".I")
    docs_data = []
    for t in docs:
    if t.strip() != "":
    i = t.split(".Wn")[0]
    w = t.split(".Wn")[1]
    docs_data.append({"I": i.strip(), "W": w.strip()})
    df_docs = pd.DataFrame(docs_data)
    df_docs.head()
    También te puede interesarA Short History of Artificial Intelligence

    El marco de datos de sus documentos debe verse como el siguiente

    Del mismo modo, crearemos un marco de datos de consultas.

    f=open('queries.txt')
    query_str = f.read()
    queries = query_str.split(".I")
    queries_data = []
    for t in queries:
    if t.strip() != "":
    i = t.split(".Wn")[0]
    w = t.split(".Wn")[1]
    queries_data.append({"I": i.strip(), "W": w.strip()})
    df_queries = pd.DataFrame(queries_data)
    df_queries.head()
    También te puede interesarComenzando con el Análisis de Sentimiento.

    El marco de datos de sus consultas debe verse como el siguiente

    Ahora, para crear el marco de datos final, tenemos que mapear las consultas y los documentos usando relevancia.txt

    f=open('relevance.txt')
    relevance_str = f.read()
    relevance = relevance_str.strip().split("n")
    # Split each line into columns
    rows = [list(map(float, line.strip().split())) for line in relevance]
    # Create a DataFrame from the rows
    df_relevance = pd.DataFrame(rows, columns=["query", "doc", "col3", "col4"])
    df_relevance = df_relevance.drop(['col3', 'col4'], axis=1)
    df_relevance = df_relevance.astype(int)
    df_docs['I'] = df_docs['I'].astype(int)
    df_queries['I'] = df_queries['I'].astype(int)
    df_rele_doc = pd.merge(df_relevance, df_docs, left_on='doc', right_on='I')
    df = pd.merge(df_rele_doc, df_queries, left_on='query', right_on='I')
    df = df.rename(columns={'W_x':'docs', 'W_y':'queries'})
    final_df = df[['docs', 'queries', 'doc', 'query']]

    Su marco de datos de trabajo final debe verse como el siguiente

    Los pasos anteriores son los mismos para todos los modelos, por lo que no los repetiré nuevamente.

    Pase directamente a la sección Spacy a continuación si desea ver mejores modelos de clasificación

    Primero, comenzaremos con el modelo de regresión lineal simple y luego veremos otros modelos avanzados.

    Usaremos el conjunto de datos (final_df) que preparamos en el paso anterior

    Paso 1: importaciones

    Importar todas las bibliotecas necesarias

    import pandas as pd
    import numpy as np
    import nltk
    import string
    import re  
    import spacy
    import collections
    import pandas as pd
    from sklearn.feature_extraction.text import TfidfVectorizer
    from sklearn.linear_model import LinearRegression
    from sklearn.metrics import mean_squared_error

    Paso 2: Ingeniería de características

    Ahora vamos a crear las siguientes características

  • los caracteres cuentan
    • nltk.download('stopwords')
    nltk.download('wordnet')
    from nltk.corpus import stopwords
    from nltk import word_tokenize
    

    def count_chars(text):
    return len(text)
    

    def count_words(text):
    return len(text.split())
    

    def count_capital_words(text):
    return len([w for w in text.split() if w.isupper()])
    

    def count_punctuations(text):
    return len([w for w in text if w in list(string.punctuation)])
    

    def count_words_in_quotes(text):
    x = re.findall("'.'|"."", text)
    count=0
    if x is None:
    return 0
    else:
    for i in x:
    t=i[1:-1]
    count+=count_words

    Entradas relacionadas

    Scroll al inicio