Melhore os resultados de pesquisa do seu aplicativo com o ajuste automático

Isa Torres, Ethan Steininger5 min read • Published Oct 20, 2021 • Updated Aug 14, 2024

Atlas Pesquisa

Avalie esse Tutorial

Historicamente, a única maneira de melhorar a relevância da consulta de pesquisa do seu aplicativo é por meio de intervenção manual. Por exemplo, você pode introduzir oaumento de pontuação para multiplicar uma pontuação básica de relevância na presença de campos específicos. Isso garante que as pesquisas em que uma chave presente em alguns campos tenham um peso maior do que em outras. Isso, no entanto, é fixo por natureza. Os resultados são dinâmicos, mas a lógica em si não muda.

O projeto a seguir mostrará como aproveitar sinônimos para criar um loop de feedback auto-ajustável, a fim de fornecer resultados de pesquisa cada vez mais relevantes aos usuários, tudo sem modelos complexos de aprendizado de máquina!

Exemplo

Temos um aplicativo de busca de alimentos em que um usuário pesquisa por “Romanian Food.”. Supondo que estejamos registrando os dados de sequência de cliques de cada usuário (sua interação passo a passo com nosso aplicativo), podemos dar uma olhada nesse “sequence” e compará-lo com outros resultados que produziram um forte CTA (call to action): um checkout bem-sucedido.

Outro usuário pesquisou por "German Cuisine " e ele tinha uma sequência de cliques muito semelhante. Bem, podemos criar um script que analise os fluxos de cliques desses usuários (e de outros usuários), identificando similaridades, podemos dizer ao script para anexá-lo a um documento de sinônimos que contenha "German, " "Romanian, " e outros cozinhas mais comuns, como “Hungarian.”

Aqui está um fluxo de trabalho do que pretendemos realizar:

Tutorial

Etapa 1: registrar a atividade de fluxo de cliques do usuário

Em nossa camada de aplicativo, à medida que os eventos são disparados, nós os registramos em uma coleção de clickstreams, como:

Trecho de código

Nesta lista simplificada de eventos, podemos concluir que {"session_id":"1"} pesquisou "romanian food, " o que levou a uma taxa de conversão mais alta, deployment_success, em comparação com {"session_id":"2"}, que pesquisou "hungarian food " e parou após o evento add_to_cart. Você mesmo pode importar esses dados usando sample_data.json.

Vamos preparar os dados para nosso script search_tuner.

Etapa 2: Crie uma exibição que agrupe por session_id e filtre a presença de pesquisas

A propósito, não há problema que apenas alguns documentos tenham um campo de metadados. Nosso operador $group pode identificar de forma inteligente os que fazem e os que não fazem isso.

Trecho de código

[
    # first we sort by timestamp to get everything in the correct sequence of events,
    # as that is what we'll be using to draw logical correlations
    {
        '$sort': {
            'timestamp': 1
        }
    },
    # next, we'll group by a unique session_id, include all the corresponding events, and begin
    # the filter for determining if a search_query exists
    {
        '$group': {
            '_id': '$session_id',
            'events': {
                '$push': '$$ROOT'
            },
            'isSearchQueryPresent': {
                '$sum': {
                    '$cond': [
                        {
                            '$eq': [
                                '$event_id', 'search_query'
                            ]
                        }, 1, 0
                    ]
                }
            }
        }
    },
    # we hide session_ids where there is no search query
    # then create a new field, an array called searchQuery, which we'll use to parse
    {
        '$match': {
            'isSearchQueryPresent': {
                '$gte': 1
            }
        }
    },
    {
        '$unset': 'isSearchQueryPresent'
    },
    {
        '$set': {
            'searchQuery': '$events.metadata.search_value'
        }
    }
]

Vamos criar a visualização criando a query, depois acessando o Compass e adicionando-a como uma nova collection chamada group_by_session_id_and_search_query:

Veja como será:

Trecho de código

[
  {
    "session_id": "1",
    "events": [
      {
        "event_id": "search_query",
        "search_value": "romanian food"
      },
      {
        "event_id": "add_to_cart",
        "context": {
          "cuisine": "eastern european cuisine"
        }
      },
      {
        "event_id": "checkout"
      },
      {
        "event_id": "payment_success"
      }
    ],
    "searchQuery": "romanian food"
  }, {
    "session_id": "2",
    "events": [
      {
        "event_id": "search_query",
        "search_value": "hungarian food"
      },
      {
        "event_id": "add_to_cart",
        "context": {
          "cuisine": "eastern european cuisine"
        }
      },
      {
        "event_id": "checkout"
      }
    ],
    "searchQuery": "hungarian food"
  },
  {
    "session_id": "3",
    "events": [
      {
        "event_id": "search_query",
        "search_value": "italian food"
      },
      {
        "event_id": "add_to_cart",
        "context": {
          "cuisine": "western european cuisine"
        }
      }
    ],
    "searchQuery": "sad food"
  }
]

Etapa 3: Crie um trabalho agendado que compare fluxos de cliques semelhantes e envie os sinônimos resultantes para a collection de sinônimos

Trecho de código

// Provide a success indicator to determine which session we want to
// compare any incomplete sessions with
const successIndicator = "payment_success"

//  what percentage similarity between two sets of click/event streams
//  we'd accept to be determined as similar enough to produce a synonym
//  relationship
const acceptedConfidence = .9

//  boost the confidence score when the following values are present
//  in the eventstream
const eventBoosts = {
  successIndicator: .1
}

/**
 * Enrich sessions with a flattened event list to make comparison easier.
 * Determine if the session is to be considered successful based on the success indicator.
 * @param {*} eventList List of events in a session.
 * @returns {any} Calculated values used to determine if an incomplete session is considered to
 * be related to a successful session.
 */
const enrichEvents = (eventList) => {
  return {
    eventSequence: eventList.map(event => { return event.event_id }).join(';'),
    isSuccessful: eventList.some(event => { return event.event_id === successIndicator })
  }
}

/**
 * De-duplicate common tokens in two strings
 * @param {*} str1
 * @param {*} str2
 * @returns Returns an array with the provided strings with the common tokens removed
 */
const dedupTokens = (str1, str2) => {
  const splitToken = ' '
  const tokens1 = str1.split(splitToken)
  const tokens2 = str2.split(splitToken)
  const dupedTokens = tokens1.filter(token => { return tokens2.includes(token)});
  const dedupedStr1 = tokens1.filter(token => { return !dupedTokens.includes(token)});
  const dedupedStr2 = tokens2.filter(token => { return !dupedTokens.includes(token)});

return [ dedupedStr1.join(splitToken), dedupedStr2.join(splitToken) ]
}

// At this point we can assume that the sequence of events is the same, so we can
  // use the same index when comparing events
  for(let i = 0; i < incompleteSession.events.length; i++) {
    // if we have a context, let's compare the kv pairs in the context of
    // the incomplete session with the successful session
    if(incompleteSession.events[i].context){
      const eventWithContext = incompleteSession.events[i]
      const contextKeys = Object.keys(eventWithContext.context)

try {
        for(const key of contextKeys) {
          if(successfulSession.events[i].context[key] !== eventWithContext.context[key]){
            // context is not the same, not a match, let's get out of here
            contextMatch = false
            break;
          }
         }
      } catch (error) {
        contextMatch = false;
        console.log(`Something happened, probably successful session didn't have a context for an event.`);
      }
    }
  }

// Update results
  if(contextMatch){
    console.log(`VALIDATED`);
    const synonyms = dedupTokens(successfulSession.searchQuery, incompleteSession.searchQuery, true)
    const existingMatchingResultIndex = findMatchingIndex(synonyms, results)
    if(existingMatchingResultIndex >= 0){
      const synonymSet = new Set([...synonyms, ...results[existingMatchingResultIndex].synonyms])
      results[existingMatchingResultIndex].synonyms = Array.from(synonymSet)
    }
    else{
      const result = {
        "mappingType": "equivalent",
        "synonyms": synonyms
      }
      results.push(result)
    }

}
  else{
    console.log(`NOT A MATCH`);
  }

return results;
}

/**
 * Compare the event sequence of incomplete and successful sessions
 * @param {*} successfulSessions
 * @param {*} incompleteSessions
 * @returns
 */
const compareLists = (successfulSessions, incompleteSessions) => {
  let results = []
  for(const successfulSession of successfulSessions) {
    for(const incompleteSession of incompleteSessions) {
      // if the event sequence is the same, let's inspect these sessions
      // to validate that they are a match
      if(successfulSession.enrichments.eventSequence.includes(incompleteSession.enrichments.eventSequence)){
        processMatch(successfulSession, incompleteSession, results)
      }
    }
  }
  return results
}

const processSessions = (sessions) => {
  // console.log(`Processing the following list:`, JSON.stringify(sessions, null, 2));
  // enrich sessions for processing
  const enrichedSessions = sessions.map(session => {
    return { ...session, enrichments: enrichEvents(session.events)}
  })
  // separate successful and incomplete sessions
  const successfulEvents = enrichedSessions.filter(session => { return session.enrichments.isSuccessful})
  const incompleteEvents = enrichedSessions.filter(session => { return !session.enrichments.isSuccessful})

return compareLists(successfulEvents, incompleteEvents);
}

/**
 * Main Entry Point
 */
const main = () => {
  const results = processSessions(eventsBySession);
  console.log(`Results:`, results);
}

main();

module.exports = processSessions;

Execute o script você mesmo.

Etapa 4: Aprimore nossa consulta de pesquisa com os sinônimos recém-anexados

Trecho de código

Consulte o tutorial de sinônimos.

Próximos passos

Aqui está, pessoal. Pegamos dados brutos gravados em nosso servidor de aplicativos e os usamos criando um feedback que incentiva o comportamento positivo do usuário.

Ao medir esse ciclo de feedback em relação aos seus KPIs, você pode criar um teste A/B simples em relação a determinados sinônimos e padrões de usuário para otimizar seu aplicativo!

Avalie esse Tutorial

Relacionado

Tutorial

Parte #2: criar um modelo de endpoint com o Amazon SageMaker, o AWS Lambda e o AWS API Gateway

Sep 18, 2024 | 7 min read

Tutorial

Consulta flexível com Atlas Search

Jul 12, 2024 | 3 min read

Artigo

Implementação de pipelines RAG robustos: integração do Gemma 2 do Google (2B) técnicas de avaliação do MongoDB e LLM

Sep 12, 2024 | 20 min read

Tutorial

Crie rapidamente uma GraphQL API de alto desempenho para o MongoDB com Hasura

Feb 15, 2024 | 10 min read