¿Alternativa para gremlin sideEffect ya que Neptune no lo admite?

Answer

1. 

   davy.ai

   July 21, 2023 at 12:12 am

   Solución

   Dado que Neptune no admite sideEffect, podemos utilizar project y map para realizar las mismas operaciones. La consulta actualizada se vería así:

   g.V().match(
       __.as("u1").outE("rated").as("r1"),
       __.as("r1").inV().as("m"),
       __.as("m").inE("rated").as("r2"),
       __.as("r2").outV().as("u2")
   ).where("u1", neq("u2"))
   .group()
       .by(select("u1","u2"))
       .by(select("r1","r2").by("rating"))
       .unfold()
       .project("usr1", "usr2", "rated1", "rated2")
           .by(select(keys).select("u1"))
           .by(select(keys).select("u2"))
           .by(select(values).select("r1"))
           .by(select(values).select("r2"))
       .map()
           .select("usr1", "usr2", "rated1", "rated2")
           .as("ratings")
           .select("ratings")
           .map(
               select("rated1", "rated2")
               .project("xyDotProduct", "xLength", "yLength")
                   .by(
                       map(values)
                       .map(select("r1", "r2")
                            .by(unfold())
                            .select(values).fold()
                            .map(
                               map(select(values))
                                   .values("rating")
                            )
                       )
                       .fold()
                       .map{ list -> list[0].zip(list[1])}
                       .map{ list -> 
                           list.collect{ratingList -> ratingList[0]*ratingList[1]}.sum()
                       }
                   )
                   .by(
                       map(values)
                       .map(select("r1")
                            .by(unfold())
                            .values("rating")
                            .map{ rating -> rating * rating }
                       )
                       .fold()
                       .map{ list -> Math.sqrt(list.sum()) }
                   )
                   .by(
                       map(values)
                       .map(select("r2")
                            .by(unfold())
                            .values("rating")
                            .map{ rating -> rating * rating }
                       )
                       .fold()
                       .map{ list -> Math.sqrt(list.sum()) }
                   )
               .select(values)
           )
           .unfold()
           .as("similarity")
           .select("ratings")
           .addE("similarity").from(select("usr1")).to(select("usr2")).as("e")
           .property("similarity", select("similarity"))
           .iterate()
   

   Explicación:

   • Primero, utilizamos match para obtener los vértices y aristas necesarios que se utilizarán para calcular la similitud.
   • Luego, agrupamos los resultados por pares de usuarios y sus calificaciones correspondientes.
   • Utilizando project y map, iteramos sobre el grupo y calculamos la similitud del coseno entre pares.
   • Finalmente, addE la arista similarity y establecemos la propiedad similarity para esa arista.

   Nota: Esta consulta asume que los vértices tienen una arista rated que almacena el valor de la calificación.

Comments are closed.