Modelo tf-idf para clasificación de páginas

tf-idf significa Término frecuencia-frecuencia de documento inversa . El peso tf-idf es un peso que se usa a menudo en la recuperación de información y minería de texto. Los motores de búsqueda suelen utilizar variaciones del esquema de ponderación tf-idf para puntuar y clasificar la relevancia de un documento dada una consulta. Este peso es una medida estadística utilizada para evaluar qué tan importante es una palabra para un documento en una colección o corpus. La importancia aumenta proporcionalmente al número de veces que aparece una palabra en el documento, pero se compensa con la frecuencia de la palabra en el corpus (conjunto de datos). 

Cómo calcular: tf-idf es un esquema de ponderación que asigna a cada término de un documento un peso basado en su frecuencia de término (tf) y su frecuencia de documento inversa (idf). Los términos con puntajes de peso más altos se consideran más importantes. Por lo general, el peso tf-idf está compuesto por dos términos:

1. Frecuencia de Término Normalizada (tf)
2. Frecuencia de documento inversa (idf)

Tomemos 3 documentos para mostrar cómo funciona esto. 

Doc 1: Ben estudia sobre computadoras en Computer Lab. 

Doc 2: Steve enseña en la Universidad de Brown. 

Doc 3: Los científicos de datos trabajan en grandes conjuntos de datos. Digamos que estamos haciendo una búsqueda en estos documentos con la siguiente consulta: 

Científicos de datos La consulta es una consulta de texto libre. Significa una consulta en la que los términos de la consulta se escriben de forma libre en la interfaz de búsqueda, sin ningún operador de búsqueda de conexión.

Paso 1: Cálculo de la frecuencia del término (tf)

La frecuencia indica el número de ocurrencias de un término particular t en el documento d . Por lo tanto,

tf(t, d) = N(t, d), wherein tf(t, d) = term frequency for a term t in document d.

N(t, d)  = number of times a term t occurs in document d

Podemos ver que a medida que un término aparece más en el documento se vuelve más importante, lo cual es lógico. Podemos usar un vector para representar el documento en el modelo de bolsa de palabras, ya que el orden de los términos no es importante. Hay una entrada para cada término único en el documento con el valor de su frecuencia de término. A continuación se presentan los términos y su frecuencia en cada uno de los documentos. [N(t, d)] tf para el documento 1:

Representación de espacio vectorial para Doc 1: [1, 1, 2, 1] tf para documento 2:

Representación de espacio vectorial para Doc 2: [1, 1, 1, 1] tf para documento 3:

Representación de espacio vectorial para Doc 3: [1, 1, 1, 1, 1] Por lo tanto, la representación de documentos como vectores en un espacio vectorial común se conoce como Modelo de espacio vectorial y es fundamental para la recuperación de información. Dado que estamos tratando con el término frecuencia que se basa en el recuento de ocurrencias, los documentos más largos se verán más favorecidos. Para evitar esto, normalice el término frecuencia

tf(t, d) = N(t, d) / ||D||
wherein, ||D|| = Total number of term in the document

||D|| para cada documento:

A continuación se muestra la frecuencia de término normalizada para todos los documentos, es decir, [N(t, d) / ||D||] TF normalizada para el Documento 1:

Representación de espacio vectorial para el documento 1: [0.143, 0.143, 0.286, 0.143] tf normalizada para el documento 2:

Representación de espacio vectorial para el documento 2: [0.2, 0.2, 0.2, 0.2] tf normalizado para el documento 3:

Representación de espacio vectorial para el documento 3: [0.167, 0.167, 0.167, 0.167, 0.167] La ​​siguiente función en Python hará el cálculo de TF normalizado: 

def termFrequency(term, doc):
     
    """
    Input: term: Term in the Document, doc: Document
    Return: Normalized tf: Number of times term occurs
      in document/Total number of terms in the document
    """
    # Splitting the document into individual terms
    normalizeTermFreq = doc.lower().split()
 
    # Number of times the term occurs in the document
    term_in_document = normalizeTermFreq.count(term.lower())
 
    # Total number of terms in the document
    len_of_document = float(len(normalizeTermFreq ))
 
    # Normalized Term Frequency
    normalized_tf = term_in_document / len_of_document
 
    return normalized_tf

Paso 2: Calcule la frecuencia inversa del documento – idf

Por lo general, mide la importancia de un término. El objetivo principal de realizar una búsqueda es encontrar documentos relevantes que coincidan con la consulta. Dado que tf considera que todos los términos son igualmente importantes, no podemos usar únicamente frecuencias de términos para calcular el peso de un término en el documento. Sin embargo, se sabe que ciertos términos, como “es”, “de” y “eso”, pueden aparecer muchas veces pero tienen poca importancia. Por lo tanto, debemos reducir los términos frecuentes mientras aumentamos los raros. Los logaritmos nos ayudan a resolver este problema. En primer lugar, encuentre la frecuencia de documentos de un término t contando el número de documentos que contienen el término:

df(t) = N(t)

where-
df(t) = Document frequency of a term t
N(t) = Number of documents containing the term t

La frecuencia de los términos es el recuento de ocurrencias de un término en un solo documento en particular; mientras que la frecuencia del documento es el número de documentos diferentes en los que aparece el término, por lo que depende de todo el corpus. Ahora veamos la definición de frecuencia de documento inversa. El idf de un término es el número de documentos en el corpus dividido por la frecuencia de documentos de un término.

idf(t) = N/ df(t) = N/N(t)

Se espera que el término más frecuente se considere menos importante, pero el factor (probablemente números enteros) parece demasiado duro. Por lo tanto, tomamos el logaritmo (con base 2) de las frecuencias inversas del documento. Entonces, la idf de un término t se convierte en:

idf(t) = log(N/ df(t))

Esto es mejor, y dado que log es una función que aumenta monótonamente, podemos usarla con seguridad. Calculemos IDF para el término Computadora:

idf(computer) = log(Total Number Of Documents / Number Of Documents with term Computer in it)

Hay 3 documentos en total = Documento1, Documento2, Documento3

The term Computer appears in Document1

idf(computer) = log(3 / 1)
          = 1.5849

A continuación se muestra el idf para los términos que aparecen en todos los documentos :

A continuación se muestra la función en python para calcular idf: 

def inverseDocumentFrequency(term, allDocs):
    num_docs_with_given_term = 0
 
    """
    Input: term: Term in the Document,
           allDocs: List of all documents
    Return: Inverse Document Frequency (idf) for term
            = Logarithm ((Total Number of Documents) /
            (Number of documents containing the term))
    """
    # Iterate through all the documents
    for doc in allDocs:
         
        """
        Putting a check if a term appears in a document.
        If term is present in the document, then
        increment "num_docs_with_given_term" variable
        """
        if term.lower() in allDocs[doc].lower().split():
            num_docs_with_given_term += 1
 
    if num_docs_with_given_term > 0:
        # Total number of documents
        total_num_docs = len(allDocs)
 
        # Calculating the IDF
        idf_val = log(float(total_num_docs) / num_docs_with_given_term)
        return idf_val
    else:
        return 0

Paso 3: Puntuación tf-idf

Ahora hemos definido tanto tf como idf y ahora podemos combinarlos para producir la puntuación final de un término t en el documento d. Por lo tanto,

tf-idf(t, d) = tf(t, d)* idf(t, d)

Para cada término de la consulta, multiplique su frecuencia de término normalizada por su IDF en cada documento. En Document3 para los datos del término, la frecuencia del término normalizado es 0,167 y su IDF es 1,5849. Multiplicándolos juntos obtenemos 0.2646. A continuación se muestran los cálculos de TF * IDF para datos y científicos en todos los documentos.

Usaremos cualquiera de las medidas de similitud (p. ej., el método de similitud del coseno) para encontrar la similitud entre la consulta y cada documento. Por ejemplo, si usamos el Método de similitud del coseno para encontrar la similitud, entonces el ángulo más pequeño, mayor es la similitud. Usando la fórmula dada a continuación, podemos encontrar la similitud entre dos documentos cualesquiera, digamos d1, d2.

Cosine Similarity (d1, d2) =  Dot product(d1, d2) / ||d1|| * ||d2||

Dot product (d1, d2) = d1[0] * d2[0] + d1[1] * d2[1] * … * d1[n] * d2[n]
||d1|| = square root(d1[0]^2 + d1[1]^2 + ... + d1[n]^2)
||d2|| = square root(d2[0]^2 + d2[1]^2 + ... + d2[n]^2)

  Referencias:

• Wikipedia
• Arden Dertat | Implementación de motores de búsqueda