Incentive avaliações úteis de produtos com a IA da Web no dispositivo

Maud Nalpas

Kenji Baheux

Alexandra Klepper

Avaliações positivas e negativas podem influenciar a decisão de compra de um comprador.

De acordo com pesquisas externas, 82% dos compradores on-line procuram ativamente avaliações antes de fazer uma compra. Essas avaliações negativas são úteis para clientes e empresas, já que a disponibilidade de avaliações negativas pode ajudar reduzir as taxas de devolução e ajudar os fabricantes a melhorar os produtos.

Veja algumas maneiras de melhorar a qualidade das avaliações:

• Verificar a toxicidade de cada avaliação antes de enviar. Podemos incentivar os usuários a remover linguagem ofensiva, assim como outras observações inúteis, para que a avaliação deles ajude melhor os outros usuários a tomar uma melhor decisão de compra.
  • Negativa: essa bolsa é uma porcaria, e eu odeio.
  • Ponto negativo com feedback útil: os zíperes são muito rígidos e o material é barato. Devolva esta bolsa.
• Gerar automaticamente uma classificação com base no idioma usado na avaliação.
• Determine se a avaliação é negativa ou positiva.

.

Neste exemplo, o comentário do revisor recebe um sentimento positivo e uma nota de cinco estrelas.

Em última análise, o usuário deve ter a palavra final sobre a classificação do produto.

O codelab a seguir oferece soluções no dispositivo e no navegador. Sem IA conhecimento de desenvolvimento, servidores ou chaves de API.

Atenção :embora a IA da Web no dispositivo ofereça possibilidades empolgantes, esteja ciente das limitações, especialmente com IA generativa e modelos de linguagem grandes (LLMs). Esses modelos têm tamanhos substanciais de download e requisitos exigentes de hardware, que podem afetar o desempenho e a experiência do usuário. Certifique-se de entender essas restrições e avaliar se o dispositivo é adequado para seu caso de uso.

Pré-requisitos

Enquanto a IA do lado do servidor com soluções (como a API Gemini ou API OpenAPI) oferecem soluções robustas para muitos aplicativos, neste guia vamos nos concentrar na IA da Web no dispositivo. IA da Web no dispositivo ocorre quando os modelos de IA são executados no navegador, para melhorar a experiência dos usuários da Web sem idas e voltas ao servidor.

Neste codelab, usamos uma combinação de técnicas para mostrar o que há na sua caixa de ferramentas. da IA da Web no dispositivo.

Usamos as seguintes bibliotecas e modelos:

• TensforFlow.js para análise de toxicidade. O TensorFlow.js é uma biblioteca de machine learning de código aberto para inferência e treinamento na Web.
• transformers.js para análise de sentimento. O Transformers.js é uma biblioteca de IA da Web do Hugging Face.
• Gemma 2B para notas. O Gemma é uma família de modelos abertos e leves desenvolvidos com base na pesquisa e na tecnologia que o Google usou para criar os modelos do Gemini. Para executar o Gemma no navegador, usamos a API experimental LLM Inference do MediaPipe.

Considerações sobre UX e segurança

Há algumas considerações para garantir a melhor experiência e segurança do usuário:

• Permitir que o usuário edite a nota. Em última análise, o usuário deve ter a última na classificação do produto.
• Deixe claro para o usuário que a classificação e as avaliações são automáticas.
• Permitir que os usuários publiquem uma avaliação classificada como tóxica, mas executar uma segunda verificação no servidor. Isso evita uma experiência frustrante quando uma avaliação não tóxica é erroneamente classificados como tóxicos (falsos positivos). Isso também inclui casos em que um usuário mal-intencionado consegue burlar a verificação do lado do cliente.
• Uma verificação de toxicidade do lado do cliente é útil, mas pode ser ignorada. Certifique-se de execute também uma verificação no lado do servidor.

Analisar a toxicidade com o TensorFlow.js

Comece a analisar a toxicidade de uma avaliação de usuário com o TensorFlow.js.

1. Instalar e import a biblioteca do TensorFlow.js e o modelo de toxicidade.
2. Defina uma confiança mínima de previsão. O padrão é 0,85 e, em nosso exemplo, nós o definimos como 0,9.
3. Carregue o modelo de forma assíncrona.
4. Classificar a avaliação de forma assíncrona. Nosso código identifica previsões que excedem um limite de 0,9 para qualquer categoria.

Esse modelo pode categorizar toxicidade por ataque de identidade, insulto, obscenidade e muito mais.

Exemplo:

import * as toxicity from '@tensorflow-models/toxicity';

// Minimum prediction confidence allowed
const TOXICITY_COMMENT_THRESHOLD = 0.9;

const toxicityModel = await toxicity.load(TOXICITY_COMMENT_THRESHOLD);
const toxicityPredictions = await toxicityModel.classify([review]);
// `predictions` is an array with the raw toxicity probabilities
const isToxic = toxicityPredictions.some(
    (prediction) => prediction.results[0].match
);

Determinar sentimentos com Transformers.js

1. Instalar e importar a biblioteca Transformers.js.

2. Configurar a análise de sentimento tarefa com um pipeline dedicado. Quando um pipeline é usado pela primeira vez, o modelo é transferido por download e armazenado em cache. A partir desse momento, a análise de sentimento será muito mais rápida.

   Observação: a menos que você especifique um modelo, o Transformers.js usará o modelo padrão para esse pipeline específico.

3. Classificar a avaliação de forma assíncrona. Use um limite personalizado para definir o nível de confiança que você considera útil para seu aplicativo.

Exemplo:

import { pipeline } from '@xenova/transformers';

const SENTIMENT_THRESHOLD = 0.9;
// Create a pipeline (don't block rendering on this function)
const transformersjsClassifierSentiment = await pipeline(
  'sentiment-analysis'
);

// When the user finishes typing
const sentimentResult = await transformersjsClassifierSentiment(review);
const { label, score } = sentimentResult[0];
if (score > SENTIMENT_THRESHOLD) {
  // The sentiment is `label`
} else {
  // Classification is not conclusive
}

Sugerir uma nota com o Gemma e o MediaPipe

Com a API LLM Inference, você pode executar modelos de linguagem grandes (LLMs) completamente no navegador.

Essa nova capacidade é particularmente transformadora, considerando a memória e demandas de computação dos LLMs, que são cem vezes maiores que as com os modelos tradicionais no dispositivo. As otimizações na pilha do dispositivo facilitam isso possível, incluindo novas operações, quantização, armazenamento em cache e compartilhamento de peso. Fonte: "Large Language Models On-Device with MediaPipe and TensorFlow Lite" (em inglês).

1. Instalação e importação a API de inferência do MediaPipe LLM.
2. Faça o download de um modelo. Aqui, usamos o Gemma 2B, baixado do Kaggle. O Gemma 2B é o menor modelo de peso aberto do Google.
3. Aponte o código para os arquivos de modelo corretos, com o FilesetResolver. Isso é é importante porque os modelos de IA generativa podem ter uma estrutura de diretórios para seus ativos.
4. Carregar e configurar o modelo com a interface LLM do MediaPipe. Prepare o modelo a ser usado: especifique a localização do modelo, o tamanho preferido das respostas, e o nível preferido de criatividade com a temperatura.
5. Faça um comando ao modelo (veja um exemplo).
6. Aguarde a resposta do modelo.
7. Analisar a classificação: extrai a nota da resposta do modelo.

.

Observação: a variante do Gemma que estamos usando é ajustada por instruções (consulte "isso" na nome do modelo). Isso significa que é possível interagir com o modelo concedendo instruções, como em interfaces de bate-papo, como Gemini ou ChatGPT.

import { FilesetResolver, LlmInference } from '@mediapipe/tasks-genai';

const mediaPipeGenAi = await FilesetResolver.forGenAiTasks();
const llmInference = await LlmInference.createFromOptions(mediaPipeGenAi, {
    baseOptions: {
        modelAssetPath: '/gemma-2b-it-gpu-int4.bin',
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.5,
    randomSeed: 101,
});

const prompt = …
const output = await llmInference.generateResponse(prompt);

const int = /\d/;
const ratingAsString = output.match(int)[0];
rating = parseInt(ratingAsString);

Exemplo de comando

Observação: como o Gemma 2B é um LLM pequeno, ele precisa de um comando detalhado para ser produzido. resultados satisfatórios. Aqui, usamos técnicas como comandos da cadeia de pensamento e comandos few-shot.

const prompt = `Analyze a product review, and then based on your analysis give me the
corresponding rating (integer). The rating should be an integer between 1 and 5.
1 is the worst rating, and 5 is the best rating. A strongly dissatisfied review
that only mentions issues should have a rating of 1 (worst). A strongly
satisfied review that only mentions positives and upsides should have a rating
of 5 (best). Be opinionated. Use the full range of possible ratings (1 to 5). \n\n
  \n\n
  Here are some examples of reviews and their corresponding analyses and ratings:
  \n\n
  Review: 'Stylish and functional. Not sure how it'll handle rugged outdoor use, but it's perfect for urban exploring.'
  Analysis: The reviewer appreciates the product's style and basic functionality. They express some uncertainty about its ruggedness but overall find it suitable for their intended use, resulting in a positive, but not top-tier rating.
  Rating (integer): 4
  \n\n
  Review: 'It's a solid backpack at a decent price. Does the job, but nothing particularly amazing about it.'
  Analysis: This reflects an average opinion. The backpack is functional and fulfills its essential purpose. However, the reviewer finds it unremarkable and lacking any standout features deserving of higher praise.
  Rating (integer): 3
  \n\n
  Review: 'The waist belt broke on my first trip! Customer service was unresponsive too. Would not recommend.'
  Analysis: A serious product defect and poor customer service experience naturally warrants the lowest possible rating. The reviewer is extremely unsatisfied with both the product and the company.
  Rating (integer): 1
  \n\n
  Review: 'Love how many pockets and compartments it has. Keeps everything organized on long trips. Durable too!'
  Analysis: The enthusiastic review highlights specific features the user loves (organization and durability), indicating great satisfaction with the product. This justifies the highest rating.
  Rating (integer): 5
  \n\n
  Review: 'The straps are a bit flimsy, and they started digging into my shoulders under heavy loads.'
  Analysis: While not a totally negative review, a significant comfort issue leads the reviewer to rate the product poorly. The straps are a key component of a backpack, and their failure to perform well under load is a major flaw.
  Rating (integer): 1
  \n\n
  Now, here is the review you need to assess:
  \n
  Review: "${review}" \n`;

Aprendizados

Não é necessário ter experiência em IA/ML. Projetar um comando requer iterações, mas o restante do código é de desenvolvimento padrão da Web.

Os modelos no dispositivo são bastante precisos. Se você executar os snippets deste documento, você vai observar que a toxicidade e a análise de sentimento resultados precisos. As classificações Gemma, na maioria, corresponderam ao modelo Gemini para algumas avaliações de referência testadas. Para validar essa precisão, mais testes são necessários.

Mas criar comandos para o Gemma 2B exige trabalho. Como o Gemma 2B é um LLM pequeno, precisa de um comando detalhado para produzir resultados satisfatórios, especialmente mais detalhada do que a API Gemini.

A inferência pode ser muito rápida. Se você executar os snippets deste documento, observe que a inferência pode ficar rápida, potencialmente mais rápida do que viagens de ida e volta, em diversos dispositivos. Dito isso, a velocidade de inferência pode variar tanto. É necessário fazer comparações detalhadas nos dispositivos de destino. Esperamos no dispositivo inferência para ficar mais rápido com a GPU da Web, o WebAssembly e as atualizações de bibliotecas. Por exemplo, o Transformers.js adiciona Suporte a GPUs da Web na v3, o que pode acelerar a inferência no dispositivo muitas vezes.

Os tamanhos de download podem ser muito grandes. A inferência no navegador é rápida, mas carregar modelos de IA pode ser um desafio. Para realizar a IA no navegador, você normalmente precisam de uma biblioteca e um modelo, que são adicionados ao tamanho de download do seu aplicativo da Web.

Já o modelo de toxicidade do TensorFlow, um modelo clássico de processamento de linguagem natural, com poucos kilobytes, modelos de IA generativa como o padrão modelo de análise de sentimento do Google alcança 60 MB. Modelos de linguagem grandes como o Gemma podem ser até 1,3 GB. Isso excede a mediana 2,2 MB de tamanho de página da Web, que é já é muito maior do que o recomendado para o melhor desempenho de longe. No dispositivo a IA generativa é viável em cenários específicos.

O campo da IA generativa na Web está evoluindo rapidamente! Menores, os modelos otimizados para a Web esperado para o surgimento no futuro.

Próximas etapas

O Chrome está testando outra maneira de executar a IA generativa no navegador. Você pode se inscrever no programa de testes antecipados para testá-lo.