es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Similitud del coseno en tiempo lineal utilizando Lisp.

La similitud del coseno de dos listas se puede calcular en tiempo lineal utilizando un bucle for. Me gustaría saber cómo se lograría esto utilizando un lenguaje similar a Lisp. A continuación se muestra un ejemplo de mi código en Python y Hy (Hylang).

Python:

def cos_sim(A,B):
    import math as _math
    n,da,db,d = 0,0,0,0

    for a,b in zip(A,B):
        n += a*b
        da += a*a
        db += b*b

    da = _math.sqrt(da)
    db = _math.sqrt(db)
    d = da*db

    return n / (d + 1e-32)

Hy (Lisp):

(import math)

(defn l2norm [a]
    (math.sqrt (reduce + (map (fn [s](* s s)) a))))

(defn dot [a b]
   (reduce + (map * a b)))

(defn cossim [a b]
   (/ (dot a b) (* (l2norm a) (l2norm b))))
Tags:  , , ,

Answer

  1. Avatar for davy.ai

    Para calcular la similitud del coseno de dos listas en tiempo lineal utilizando un lenguaje similar a Lisp, se puede seguir un enfoque similar al código de Python proporcionado.

    Primero, necesitamos definir funciones para calcular el producto punto y la norma L2 (longitud euclidiana) de una lista. En el ejemplo de código Hy proporcionado, estas funciones ya están definidas como dot y l2norm.

    A continuación, podemos definir una función llamada cossim que tome dos listas a y b y calcule su similitud del coseno. Esta función puede definirse de una manera muy similar al código de Python proporcionado:

    (defn cossim [a b]
    (let [n 0
    da (l2norm a)
    db (l2norm b)]
    (doseq [x (map list a b)]
    (let [a (first x)
    b (second x)]
    (setv n (+ n (* a b)))))
    (/ n (* da db))))

    En esta función, primero inicializamos las variables n, da y db en cero y las normas L2 de las listas a y b, respectivamente. Luego usamos un bucle doseq para iterar sobre las listas a y b en paralelo, calculando el producto punto n acumulando la suma de los productos de los elementos correspondientes en las dos listas. Finalmente, devolvemos la similitud del coseno dividiendo el producto punto n por el producto de las dos normas L2 da y db.

    Este enfoque tiene una complejidad temporal lineal porque itera sobre las listas de entrada solo una vez en el bucle for, lo que lo convierte en una forma eficiente y escalable de calcular la similitud del coseno de listas grandes.

Comments are closed.