Uma Profunda Investigação em Algoritmos de Recomendação com Estudo de Caso da Netflix e Tecnologia de Aprendizagem Profunda da NVIDIA

Tutoriais

O que são Algoritmos de Recomendação?

Motores de Recomendação são o segredo por trás de todas as transações na Internet, seja no Amazon, Netflix, Flipkart, YouTube, TikTok, até mesmo no LinkedIn, Facebook, X(Twitter), Snapchat, Medium, Substack, HackerNoon… todos esses sites e quase todos os sites de curadoria de conteúdo ou mercados de produtos na Internet fazem seus grandes lucros the recomendação de algoritmos.

Parafraseando, um algoritmo de recomendação constrói um modelo dos seus gostos, desgostos, favoritos, coisas que você prefere, gêneros que você prefere, e itens que você prefere, e quando uma transação é feita no site, eles praticamente quase lêem a mente do usuário e preveem o próximo produto que você é mais provável comprar. Algumas das recomendações de algoritmos no YouTube e TikTok são tão precisas que conseguem manter os usuários fixados por horas. Eu ficaria surpreso se mesmo um leitor não tivesse relatado uma sessão de YouTube que veio apenas de rolar e clicar/toque por cerca de dez minutos.

Isso leva a melhor engagement do cliente, uma melhor experiência do cliente, renda aumentada, e mais dinheiro para a própria plataforma. A dependência é construída com a precisão e o assombroso desempenho desses algoritmos ultra-optimizados.

Fazemos desta forma que esses gigantes constroem sua audiência.

Os visitantes mensais para o YouTube, TikTok, Instagram e Facebook são (fonte):

Facebook: 2,9 Bilhões
YouTube: 2,2 Bilhões
Instagram: 1,4 bilhão
TikTok: 1 bilhão

E o segredo para o seu sucesso: algoritmos de recomendação fantásticos.

Tipos de Algoritmos de Recomendação

Filtragem Colaborativa (Baseada em Usuários)

A filtragem colaborativa baseada em usuários é uma técnica de recomendação que assume que usuários com preferências semelhantes terão gostos semelhantes. Ela utiliza dados de interação usuário-item para identificar semelhanças entre usuários, frequentemente empregando medidas como similaridade de cosinus ou correlação de Pearson. O método prevê as avaliações ou preferências de um usuário com base nas avaliações dadas por usuários semelhantes.

No entanto, ela pode enfrentar desafios, como o problema de início frio para novos usuários que ainda não interagiram com o sistema, e problemas de escalabilidade podem surgir quando se trata de um número elevado de usuários.

Python

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def user_based_cf(ratings_matrix, user_id, k=5):
    similarities = cosine_similarity(ratings_matrix)
    user_similarities = similarities[user_id]
    similar_users = np.argsort(user_similarities)[::-1][1:k+1]
    
    recommendations = np.zeros(ratings_matrix.shape[1])
    for similar_user in similar_users:
        recommendations += ratings_matrix[similar_user]
    
    return recommendations / k

Usa similaridade de cosinus para calcular semelhanças de usuários
Encontra os k usuários mais semelhantes ao usuário alvo
Agrega as avaliações de usuários semelhantes para gerar recomendações
Retorna a avaliação média de cada item dos usuários semelhantes
Implementação simples que pode ser facilmente modificada ou extendida

Filtragem Colaborativa (Baseada em Item)

Filtro colaborativo baseado em itens assume que os usuários preferirão itens semelhantes aos que tiveram afinidade em seu passado. Ele calcula a similaridade entre itens com base em avaliações de usuários ou interações. Esta abordagem é frequentemente mais escalável do que o filtro colaborativo baseado em usuários, particularmente quando há muitos usuários e poucos itens. Permite a computação prévia de similaridades de itens, o que pode tornar as recomendações em tempo real mais rápidas.

Enquanto ele trata de novos usuários melhor do que os métodos baseados em usuários, pode ter dificuldade com novos itens que carecem de avaliações suficientes. Adicionalmente, é menos afetado por mudanças nas preferências de usuários ao longo do tempo.

Python

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def item_based_cf(ratings_matrix, item_id, k=5):
    similarities = cosine_similarity(ratings_matrix.T)
    item_similarities = similarities[item_id]
    similar_items = np.argsort(item_similarities)[::-1][1:k+1]
    
    recommendations = np.zeros(ratings_matrix.shape[0])
    for similar_item in similar_items:
        recommendations += ratings_matrix[:, similar_item]
    
    return recommendations / k

Transpõe a matriz de avaliação para calcular similaridades de itens
Encontra os k itens mais semelhantes ao item alvo
Agrega avaliações de usuários para itens semelhantes
Retorna a avaliação média para cada usuário com base em itens semelhantes
Eficiente para sistemas com mais usuários do que itens

Fatoração de Matriz

Fatoração de matriz desmembra a matriz de interação usuário-item em matrizes de dimensão inferior, assumindo que as preferências dos usuários e as características dos itens podem ser representadas por fatores latentes. Técnicas como Decomposição de Valores Singulares (SVD) ou Mínimos Quadrados Alternados (ALS) são comumente usadas para esse fim.

Esta abordagem pode lidar eficientemente com grandes conjuntos de dados esparsos e frequentemente fornece melhor precisão comparada aos métodos de filtragem colaborativo baseados em memória. Adicionalmente, ela pode incorporar técnicas de regularização para prevenir overfitting, melhorando a generalização do modelo para dados não vistos.

Python

import numpy as np

def matrix_factorization(R, P, Q, K, steps=5000, alpha=0.0002, beta=0.02):
    Q = Q.T
    for step in range(steps):
        for i in range(len(R)):
            for j in range(len(R[i])):
                if R[i][j] > 0:
                    eij = R[i][j] - np.dot(P[i,:], Q[:,j])
                    for k in range(K):
                        P[i][k] += alpha * (2 * eij * Q[k][j] - beta * P[i][k])
                        Q[k][j] += alpha * (2 * eij * P[i][k] - beta * Q[k][j])
        
        e = 0
        for i in range(len(R)):
            for j in range(len(R[i])):
                if R[i][j] > 0:
                    e += pow(R[i][j] - np.dot(P[i,:], Q[:,j]), 2)
                    for k in range(K):
                        e += (beta/2) * (pow(P[i][k], 2) + pow(Q[k][j], 2))
        if e < 0.001:
            break
    return P, Q.T

Implementa um algoritmo básico de factorização de matriz
Usa o descida gradiente para minimizar o erro entre as avaliações previstas e reais
Incorpora regularização para evitar sobreajuste
Atualiza iterativamente os fatores latentes de usuário e item
Para quando o erro cai abaixo de um limiar ou quando se atinge o número máximo de passos

Filtragem Baseada em Conteúdo

A filtragem baseada em conteúdo recomenda itens com base em suas características e preferências de usuário. Ela constrói um perfil para cada usuário e item com base em suas características.

Técnicas como o TF-IDF (Term Frequency-Inverse Document Frequency) para análise de texto e similaridade de cosseno para correspondência são comumente empregadas. Este método resolve eficazmente o problema do novo item, já que não depende de interações de usuário anteriores.

Entretanto, ela pode sofrer de especialização excessiva, resultando em uma falta de diversidade nas recomendações. Adicionalmente, a implementação eficaz exige boa engenharia de características para garantir que as características relevantes dos itens sejam capturadas com precisão.

Python

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

def content_based_filtering(item_descriptions, user_profile, k=5):
    vectorizer = TfidfVectorizer()
    item_vectors = vectorizer.fit_transform(item_descriptions)
    user_vector = vectorizer.transform([user_profile])
    
    similarities = cosine_similarity(user_vector, item_vectors)
    top_items = np.argsort(similarities[0])[::-1][:k]
    
    return top_items

Usa o TF-IDF para converter descrições de texto em vetores numéricos
Calcula similaridade de cosseno entre o perfil do usuário e as descrições dos itens
Retorna os k itens mais semelhantes ao perfil do usuário
Eficiente para sistemas com características de item bem definidas
Pode ser facilmente estendido para incluir vários tipos de características

Sistema de Recomendação Híbrido

Sistemas de recomendação híbridos combinam duas ou mais técnicas de recomendação para aproveitar suas respectivas vantagens. Ao integrar múltiplos métodos, os sistemas híbridos podem mitigar as deficiências de métodos individuais, como o problema de cold-start. Combinamentos comuns incluem filtragem colaborativa e baseada em conteúdo. Vários métodos são usados para combinar essas técnicas, como ponderação, alternação, misturadas ou abordagens de nível meta.

Sistemas híbridos frequentemente fornecem recomendações mais robustas e precisas em comparação com sistemas de abordagem única. No entanto, a implementação eficaz exige cuidado ajuste para equilibrar os diferentes componentes e garantir desempenho ótimo.

Python

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def hybrid_recommender(ratings_matrix, content_matrix, user_id, alpha=0.5, k=5):
    cf_similarities = cosine_similarity(ratings_matrix)
    content_similarities = cosine_similarity(content_matrix)
    
    hybrid_similarities = alpha * cf_similarities + (1 - alpha) * content_similarities
    user_similarities = hybrid_similarities[user_id]
    
    similar_users = np.argsort(user_similarities)[::-1][1:k+1]
    
    recommendations = np.zeros(ratings_matrix.shape[1])
    for similar_user in similar_users:
        recommendations += ratings_matrix[similar_user]
    
    return recommendations / k

Combina filtragem colaborativa e similaridades baseadas em conteúdo
Usa soma ponderada com parâmetro alpha
Encontra usuários semelhantes baseado na similaridade híbrida
Gera recomendações a partir das avaliações dos usuários semelhantes
Permite ajuste fácil do equilíbrio entre CF e abordagens baseadas em conteúdo

Decomposição de Valores singulares (SVD)

Decomposição de Valores singulares (SVD) é uma técnica de factorização de matriz que descompõe uma matriz em três componentes: U, Σ, e V^T. nesta decomposição, U e V representam, respectivamente, os vetores singulares esquerdos e direitos, enquanto Σ contém os valores singulares.

SVD reduce a dimensionalidade mantendo apenas os k valores singulares superiores, o que ajuda a descobrir fatores latentes nas interações usuário-item.

Este método é eficiente para lidar com matrizes grandes e esparsas comuns em sistemas de recomendação. Além disso, o SVD oferece um bom equilíbrio entre precisão e eficiência computacional, tornando-se uma escolha popular para a geração de recomendações.

Python

import numpy as np
from scipy.sparse.linalg import svds

def svd_recommender(ratings_matrix, k=5):
    U, s, Vt = svds(ratings_matrix, k=k)
    
    sigma = np.diag(s)
    predicted_ratings = np.dot(np.dot(U, sigma), Vt)
    
    return predicted_ratings

Usa a função svd do scipy para realizar o SVD truncado
Reconstrói a matriz de avaliações usando apenas as k valores singulares maiores
Retorna uma matriz densa de avaliações preditas para todas as pares de usuário-item
Eficiente para matrizes de avaliações grandes e esparsas
Pode ser facilmente integrado the um sistema de recomendação maior

Fatorização de tensores

A técnica de fatorização de tensores extende a fatorização de matriz tradicional para dados multidimensionais, permitindo a incorporação de informações contextuais, como tempo e localização, nas recomendações. Ela utiliza métodos como a decomposição CP, que descompõe um tensor em uma soma de tensores componentes, capturando interações complexas entre múltiplos fatores. Esta abordagem exige mais dados e recursos computacionais em comparação com os métodos bidimensionais, já que ela lida com arrays de dimensões superiores.

No entanto, pode fornecer recomendações altamente personalizadas e contextuais, aproveitando as dimensões adicionais de dados. A complexidade aumentada da estrutura de dados permite uma compreensão mais nuanceda das preferências de usuário em diferentes contextos, aumentando a precisão global das recomendações.

Python

import numpy as np
import tensorly as tl
from tensorly.decomposition import parafac

def tensor_factorization_recommender(tensor, rank=10):
    factors = parafac(tensor, rank=rank)
    reconstructed_tensor = tl.kruskal_to_tensor(factors)
    return reconstructed_tensor

Usa a biblioteca TensorLy para operações de tensor e decomposição
Aplica a decomposição PARAFAC ao tensor de entrada.
Reconstrói o tensor a partir dos fatores decompostos
Retorna o tensor reconstituído como recomendações
Pode lidar com dados multidimensionais (por exemplo, usuário-item-contexto)

Filtragem Colaborativa Neuronal

Sistemas de recomendação baseados em aprendizagem profunda combinam técnicas de filtragem colaborativa com redes neurais. Este método permite aprender interações não-lineares entre usuário e item, que as funções de factorização de matriz tradicionais podem ter dificuldade em lidar. Os recomendadores de aprendizagem profunda normalmente usam camadas de embedding para representar usuários e itens em um espaço denso, de baixa dimensão. Isso permite a fácil integração de funcionalidades adicionais ou informações complementares, como demografia de usuários ou descrições de itens, para melhorar o desempenho da recomendação.

Quando treinados em grandes conjuntos de dados, os sistemas baseados em aprendizagem profunda frequentemente superam os métodos de factorização de matriz tradicionais em termos de precisão. No entanto, este benefício vem a custo de complexidade computacional aumentada e a necessidade de grandes quantidades de dados.

Os recomendadores de aprendizagem profunda também exigem uma configuração cuidadosa de hiperparâmetros para obter resultados ótimos, tornando-os mais difíceis de implementar e manter em comparação com abordagens mais simples de filtragem colaborativa.

Python

import tensorflow as tf
from tensorflow.keras.layers import Input, Embedding, Flatten, Dense, Concatenate
from tensorflow.keras.models import Model

def neural_collaborative_filtering(num_users, num_items, embedding_size=100):
    user_input = Input(shape=(1,), dtype='int32', name='user_input')
    item_input = Input(shape=(1,), dtype='int32', name='item_input')

    user_embedding = Embedding(num_users, embedding_size, name='user_embedding')(user_input)
    item_embedding = Embedding(num_items, embedding_size, name='item_embedding')(item_input)

    user_vecs = Flatten()(user_embedding)
    item_vecs = Flatten()(item_embedding)

    concat = Concatenate()([user_vecs, item_vecs])
    dense1 = Dense(128, activation='relu')(concat)
    dense2 = Dense(64, activation='relu')(dense1)
    output = Dense(1, activation='sigmoid')(dense2)

    model = Model(inputs=[user_input, item_input], outputs=output)
    model.compile(optimizer='adam', loss='binary_crossentropy')

    return model

Usam TensorFlow e Keras para construir um modelo de rede neural
Criam camadas de embedding para usuários e itens
Concatenam embeddings de usuário e item
Adicionam camadas densas para aprender interações não-lineares
Retorna um modelo compilado pronto para treinamento

O Caso de Estudo da Netflix

A jornada do algoritmo de recomendação da Netflix começou com CineMatch em 2000, um algoritmo de filtragem colaborativa que usava avaliações de membros para estimar quanto um usuário iria desfrutar de um filme. Em 2006, o Prêmio Netflix de 1 milhão de dólares foi lançado para desafiar os cientistas de dados a criar um modelo que batisse CineMatch em 10%. O algoritmo vencedor então foi implementado no sistema interno da Netflix.

A Netflix começou a acumular usuários e houve uma mudança para dados de streaming em 2007. Os espectadores foram expostos a algoritmos de aprendizagem por reforço e algoritmos de agrupamento que geravam sugestões em tempo real. Ao melhorar o algoritmo, cada vez mais usuários começaram a mudar para a Netflix, simplesmente devido à eficiência do algoritmo de recomendação. Cerca de 80% do conteúdo visto na Netflix é sugerido pelo algoritmo de recomendação.

A empresa estima que economiza 1 bilhão anualmente devido à perda de usuários causada pela eficiência do algoritmo de recomendação.

A Netflix usa técnicas avançadas de aprendizagem de máquina e agrupamento com um sistema de mais de 1300 clusters baseado nas metadados dos filmes que os usuários assistem. Isso permite que eles entreguem sugestões altamente otimizadas aos seus usuários. Mas a Netflix logo encontrou um problema: a escala. Com o número de usuários mensais chegando a centenas de milhões e o número total de usuários passando para mais de 200 milhões, a Netflix apostou tudo na computação em nuvem.

Simplificando, eles migraram toda a base de dados para os Serviços da Web Amazon (AWS), começando em 2008. O processo de transição completo demorou anos para ser concluído e acabou em 2015. A Netflix supostamente poupa 1 bilhão de dólares por ano usando o AWS. O AWS também tem suporte integrado para aprendizado de máquina, que a Netflix usa em sua totalidade. A Netflix supostamente usou mais de 100.000 servidores AWS e 1.000 fragmentos Kinesis para seu público global em 2022.

Desde 2015, a Netflix também começou a oferecer suas próprias produções, com milhares de filmes e programas em uma variedade ampla de formatos. Os algoritmos de recomendação da Netflix são altamente automatizados e executam milhares de testes A/B para usuários por dia. A base de assinaturas de usuários do Netflix atualmente supera os 280 milhões.

Embora a Netflix agora enfrente competição rigorosa, especialmente da Disney+, que adquiriu a marca Marvel e a franquia Star Wars, a empresa visa alcançar 500 milhões de assinantes até 2025.

No ano passado, a Netflix obteve um rendimento de 31 milhões de dólares em receita.

As partes principais de seus atuais sistemas de recomendação envolvem:

Aprendizado por reforço: Conforme o comportamento do usuário, a Netflix altera o conteúdo na tela em tempo real. Portanto, o sistema está em um estado de constante fluxo e muda dependendo das interações do usuário.
Rede neural networks profundas: Devido à escala dos dados (mais de 15.000 programas e quase 300 milhões de usuários), as técnicas de ML padrão não são fáceis de aplicar. Aprendizagem profunda é usada extensivamente, usando tecnologia da NVIDIA. (Veja no final deste artigo um programa que usa a mais recente tecnologia de aprendizagem profunda Merlin da NVIDIA).
Fatoração de matriz: Através do eficiente processo de Decomposição de Valores Singulares (SVD) em matrizes altamente esparsas e vastas, a Netflix estimula a importância e a atração de cada usuário para certos gêneros e programas.
Aprendizado de conjunto: Conexões inteligentes das algorithms listadas acima ajustam as recomendações em tempo real para que nenhum usuário veja o mesmo ecrã. Essa personalização é o que gera grandes lucros e manteve a Netflix no topo de todas as plataformas OTT.

Todos esses modelos e otimizações executam centenas de milhares de vezes por dia para centenas de milhares de usuários.

Tecnologia de Aprendizagem Profunda Moderna

Com tais escalas, nenhum computador único pode executar esses modelos de ML sozinho. É por isso que a AWS executa algoritmos de ML de forma distribuída em milhares de máquinas.

NVIDIA recentemente lançou vários produtos para permitir que os sistemas de recomendação sejam executados em escala. Os clusters de GPU da NVIDIA também desempenham um papel importante na execução dos algoritmos de ML. A NVIDIA recentemente lançou o Merlin, um algoritmo de recomendação de alto desempenho otimizado para executar em milhares de máquinas e entregar resultados superiores. Provavelmente isso só foi uma questão de tempo, uma vez que o tamanho dos conjuntos de dados excedeu muito o que computadores individuais podiam processar.

Os modernos sistemas de recomendação usam extensivamente aprendizagem profunda. Como parte do DL, os sistemas de computação GPU/TPU são usados intensivamente para acelerar o cálculo.

Algumas das ofertas recentes da NVIDIA para o Merlin incluem:

Sistemas de Recomendação da NVIDIA

(De Anunciando NVIDIA Merlin: Um Framework de Aplicação para Sistemas de Recomendação Profunda)

Disponível como projetos de código aberto:

NVTabular

NVTabular é uma biblioteca de engenharia de recursos e pré-processamento, projetada para manipular rapidamente e facilmente conjuntos de dados de escalas de terabytes. Ela é particularmente adequada para sistemas de recomendação, que requerem uma maneira escalável de processar informações adicionais, como metadados de usuário e item e informações contextuais. Fornece uma abstração de alto nível para simplificar o código e acelera o cálculo no GPU usando a biblioteca RAPIDS cuDF. Usando NVTabular, com apenas 10-20 linhas de código de API de alto nível, você pode configurar um pipeline de engenharia de dados e alcançar até 10 vezes a velocidade em relação a abordagens baseadas em CPU otimizadas, sem limitações de tamanho de conjunto de dados, independentemente da capacidade de memória GPU/CPU.

HugeCTR

HugeCTR é um framework GPU altamente eficiente projetado para treinamento de modelos de recomendação, que se concentra tanto na performance alta quanto na facilidade de uso. Ele suporta tanto modelos profundos simples quanto modelos híbridos de ponta como W&D, Deep Cross Network e DeepFM. Estamos também trabalhando para habilitar o DLRM com HugeCTR. Os detalhes do modelo e os parâmetros de hiper-amostragem podem ser especificados facilmente em formato JSON, permitindo a seleção rápida de uma gama de modelos comuns.

TensorRT e Servidor Triton para Inferência

A NVIDIA TensorRT é uma SDK para inferência de DL de alto desempenho. Ela inclui um otimizador de inferência de rede neural e tempo de execução que fornece baixa latência e alto throughput para aplicações de inferência. TensorRT pode aceitar redes neurais treinadas de todas as frameworks de DL usando uma interface comum, o formato de troca aberto de rede neural (ONNX).

O Servidor de Inferência NVIDIA Triton fornece uma solução de inferência em nuvem otimizada para GPUs NVIDIA. O servidor fornece um serviço de inferência via um ponto final HTTP ou gRPC, permitindo que clientes remotos solicitem inferência para qualquer modelo gerenciado pelo servidor. O Servidor Triton pode servir modelos de recomendação de DL usando vários backends, incluindo TensorFlow, PyTorch (TorchScript), tempo de execução ONNX e runtime TensorRT.

Exemplo de Código

O exemplo de código a seguir mostra o workflow de pré-processamento real necessário para transformar o conjunto de dados de anúncios Criteo de 1 TB, implementado com apenas uma dúzia de linhas de código usando NVTabular. Brevemente, as colunas numéricas e categóricas são especificadas. Em seguida, definimos um workflow NVTabular e fornecemos um conjunto de arquivos de treinamento e validação. Então, operções de pré-processamento são adicionadas ao workflow e os dados são persistidos no disco. Em comparação, códigos de processamento customizados, como o data util baseado em NumPy na implementação de DLRM do Facebook, pode ter de 500 a 1000 linhas de código para a mesma pipeline.

Python

import nvtabular as nvt
import glob
 
cont_names = ["I"+str(x) for x in range(1, 14)] # specify continuous feature names
cat_names = ["C"+str(x) for x in range(1, 27)] # specify categorical feature names
label_names = ["label"] # specify target feature
columns = label_names + cat_names + cont_names # all feature names
 
# Inicializar Workflow
proc = nvt.Worfklow(cat_names=cat_names, cont_names=cont_names, label_name=label_names)
 
# Criar conjuntos de dados a partir de arquivos de entrada
train_files = glob.glob("./dataset/train/*.parquet")
valid_files = glob.glob("./dataset/valid/*.parquet")
 
train_dataset = nvt.dataset(train_files, gpu_memory_frac=0.1)
valid_dataset = nvt.dataset(valid_files, gpu_memory_frac=0.1)
 
# Adicionar operações de engenharia de features e pré-processamento ao Workflow
proc.add_cont_feature([nvt.ops.ZeroFill(), nvt.ops.LogOp()])
proc.add_cont_preprocess(nvt.ops.Normalize())
proc.add_cat_preprocess(nvt.ops.Categorify(use_frequency=True, freq_threshold=15))
 
# Computar estatísticas, transformar dados, exportar para o disco
proc.apply(train_dataset, shuffle=True, output_path="./processed_data/train", num_out_files=len(train_files))
proc.apply(valid_dataset, shuffle=False, output_path="./processed_data/valid", num_out_files=len(valid_files))

Toda a pilha tecnológica pode ser encontrada no seguinte repositório GitHub:

NVIDIA-Merlin (github.com)

Conclusão

Sistemas de recomendação têm evoluído muito.

De simples modelagem estatística, filtragem baseada em conteúdo e filtragem colaborativa, agora temos redes neurais de aprendizagem profunda, nós de HPC, factorização de matriz e sua extensão a dimensões maiores, factorização de tensor.

O sistema de recomendação mais lucrativo para streaming é a NVIDIA, e eles executam seus algoritmos de aprendizagem automática inteiros na nuvem com AWS.

Sistemas de recomendação são usados em todo lugar, desde o Google até o Microsoft até o Amazon até o Flipkart. É uma parte crítica das empresas modernas e não há nenhuma empresa online que não os use de uma forma ou outra.

Hoje em dia, muitas empresas oferecem sistemas de recomendação personalizados online.

Algumas das principais incluem:

Netflix: Conhecido por seu sofisticado motor de recomendação que analisa o comportamento de visualização de usuários para sugerir filmes e séries de TV
Amazon: Utiliza um poderoso motor de recomendação que sugere produtos com base no histórico de compras de usuários e no comportamento de navegação.
Spotify: Emprega um sistema de recomendação que cura listas de reprodução de música e sugestões de músicas com base no histórico de ouvimento do usuário
YouTube: Usa um motor de recomendação para sugerir vídeos com base nos padrões de visualização e preferências dos usuários
LinkedIn: Recomenda empregos, conexões e conteúdo com base no perfil do usuário e no histórico profissional
Zillow: Sugere imóveis de propriedade customizados para as preferências e o histórico de busca do usuário
Airbnb: Fornece recomendações de alojamento com base no histórico de viagens e preferências do usuário
Uber: Recomenda opções de viagem com base nas preferências e viagens anteriores do usuário
IBM Corporation: Líder no mercado de motores de recomendação, oferecendo diversas soluções baseadas em AI
Google LLC (Alphabet Inc.): Fornece sistemas de recomendação em suas plataformas, aproveitando amplamente a análise de dados

Espero que um dia a sua empresa seja uma entre esta lista elitista. E parabéns por sua empresa.

Independentemente do setor em que você se encontra, se tiver presença online, precisa usar sistemas de recomendação de alguma forma. Continue explorando este segmento, e se tiver excelente experiência, tenha a certeza de que você será altamente procurado.

Nunca pare de aprender. Mantenha a entusiasmo. Sempre acredite no seu infinito potencial de crescimento. Seu futuro está nas suas mãos. Faça-o extraordinário!

Referências

Source:
https://dzone.com/articles/a-deep-dive-into-recommendation-algorithms-with-ne