Do CLIP ao JinaCLIP: Aprendizado Geral de Representações Texto-Imagem para Busca e RAG Multimodal
Recentemente, o aumento dos modelos de embeddings multimodais capturou a atenção em vários setores, transformando a forma como as máquinas interpretam texto e imagens. No entanto, apesar de avanços significativos, esses modelos enfrentam desafios centrais, um dos quais é a lacuna de modalidade. Essa lacuna se manifesta na forma como os embeddings de imagem e texto ficam espacialmente distantes no espaço latente, mesmo quando descrevem o mesmo objeto.
Em um recente Unstructured Data Meetup organizado pela Zilliz, Bo Wang, Engineering Manager na Jina AI, nos guiou pelas complexidades da lacuna de modalidade e pela transição do modelo CLIP da OpenAI para o JinaCLIP.
Neste blog, recapitularemos seus principais pontos e também implementaremos um sistema de busca por similaridade multimodal. Esse sistema usará o JinaCLIP para gerar embeddings multimodais e o banco de dados vetorial Milvus para armazenar e recuperar embeddings semelhantes dada uma determinada consulta. Para mais detalhes, recomendamos que você assista à apresentação completa de Bo no YouTube.
O que torna um modelo de embedding bom?
A função principal de um modelo de embedding é mapear coisas como textos e imagens em vetores, representações numéricas que capturam relações semânticas dentro dos dados. Por exemplo, a distância entre dois vetores deve refletir a similaridade dos dois itens que eles representam, sejam duas imagens, dois textos ou um de cada.
Os modelos de embedding estão no centro de tarefas modernas de IA, como busca semântica, recuperação de imagens e muito mais. Mas o que torna um modelo de embedding bom?
Versatilidade entre domínios
Um bom modelo de embedding deve ter bom desempenho em uma ampla variedade de domínios sem exigir ajuste fino. Essa adaptabilidade garante que os embeddings sejam universalmente úteis, seja a entrada texto, imagens ou outros tipos de dados. Por exemplo, se uma imagem for incorporada em um espaço vetorial e um texto relacionado for incorporado no mesmo espaço, os dois embeddings devem estar próximos, significando sua similaridade semântica. Essa ampla aplicabilidade é essencial para tarefas de IA como busca por similaridade, recuperação de imagens e aplicações entre domínios.
Similaridade semântica precisa
Uma característica fundamental de um bom modelo de embedding é sua capacidade de conectar esquerda e direita produzindo embeddings com altas pontuações de similaridade para itens semanticamente relacionados. Isso vai além de apenas dados de texto; aplica-se a quaisquer entradas multimodais. Seja comparando texto com texto, imagem com imagem ou texto com imagem, o modelo deve refletir as relações corretas por meio da proximidade dos embeddings no espaço vetorial.
No entanto, modelos mais antigos que conectavam modalidades de texto e imagem tinham mais dificuldade em alcançar esse objetivo. Eles dependiam de processos manuais, como marcar imagens com tags ou usar texto ao redor, para estabelecer conexões. Esses métodos resultavam em pouca generalização, particularmente em cenários fora da distribuição.
O desafio das tarefas multimodais
Antes da introdução de modelos como CLIP, conectar modalidades (texto e imagens) era uma tarefa altamente manual e orientada por hipóteses. Fossem tags do Flickr ou descrições textuais adicionadas por usuários, o processo estava longe de ser fluido. Abordagens supervisionadas, frequentemente usando rótulos de classificadores, eram propensas à instabilidade, e seu desempenho fora do domínio era insatisfatório. Isso significava que, embora fosse possível conectar imagens e textos, os resultados nem sempre eram consistentes, especialmente quando a entrada era complexa.
Para resolver esse problema, o CLIP, um modelo de pré-treinamento contrastivo linguagem-imagem, foi desenvolvido para melhorar o desempenho de modelos multimodais treinando-os em pares imagem-texto. A capacidade do CLIP de alinhar as duas modalidades em um espaço de embeddings compartilhado foi inovadora. No entanto, esse modelo também tem suas limitações.
Modelo CLIP: Um Avanço Com Restrições
O CLIP estabeleceu um novo padrão ao treinar dois codificadores separados, um para texto e outro para imagens. A ideia central era aprender um espaço de embeddings compartilhado onde vetores de texto e imagem pudessem coexistir, com textos e imagens semanticamente semelhantes posicionados mais próximos uns dos outros. Os resultados foram impressionantes: o CLIP permitiu tarefas multimodais usando uma função simples de similaridade de cosseno.
Figura: Como o modelo CLIP funciona
No entanto, o CLIP tem suas deficiências. Uma questão significativa é sua incapacidade de lidar de forma eficaz com tarefas apenas de texto. Como o CLIP foi otimizado principalmente para legendas curtas (frequentemente com menos de 77 caracteres), textos mais longos representam um desafio. Além disso, o CLIP carecia de exemplos negativos difíceis em seu processo de treinamento. Negativos difíceis são exemplos que são próximos, mas incorretos, e são cruciais para refinar modelos, especialmente em tarefas como recuperação de texto. Sem eles, o desempenho do CLIP atingia um platô em tarefas que exigiam compreensão textual detalhada.
Transição para o JinaCLIP: Abordando as Deficiências do Clip
JinaCLIP se baseia na arquitetura original do CLIP para abordar suas limitações. Ele expande a entrada de texto e usa uma arquitetura BERT v2 adaptada para codificação de texto. Para processamento de imagens, o JinaCLIP incorpora o modelo EVA-02. O processo de treinamento do JinaCLIP, concentra-se em superar os desafios apresentados por entradas de texto curtas em legendas de imagens e em introduzir negativos difíceis. Esse processo ocorre em três etapas, conforme mostrado abaixo:
Figura: Processo de Treinamento do JinaCLIP
As etapas são aprendizado de alinhamento, integração de texto longo e ajuste fino:
Aprendizado de Alinhamento com Textos Curtos e Legendas: Nesta etapa, o modelo é treinado usando tanto dados de imagens legendadas quanto pares de textos com significados semelhantes. O objetivo é alinhar embeddings de imagem e texto otimizando conjuntamente a similaridade texto-imagem e texto-texto. Esse processo de co-treinamento garante que, enquanto o modelo aprende a associar texto a imagens, ele também mantém suas capacidades apenas de texto. Embora o desempenho apenas de texto diminua ligeiramente em comparação com o treinamento exclusivamente em pares de texto, essa fase preserva uma abordagem equilibrada.
Integração de Descrições de Texto Longas: Durante a segunda etapa, dados sintéticos são introduzidos para treinar o modelo. Esses dados alinham imagens com textos mais longos gerados por modelos de IA, descrevendo o conteúdo com mais detalhes. Simultaneamente, pares apenas de texto continuam a ser usados para treinamento. O modelo aprende a lidar com descrições textuais mais extensas enquanto mantém o alinhamento com as imagens, aprimorando sua capacidade de entender relações texto-imagem tanto curtas quanto longas.
Ajuste fino com triplas de texto e negativos difíceis: A etapa final se concentra no uso de triplas de texto que incluem negativos difíceis, pares de textos em que dois são semanticamente semelhantes, mas um é deliberadamente diferente. Isso ajuda o modelo a fazer distinções semânticas mais refinadas, especialmente em cenários apenas com texto. Ao mesmo tempo, o modelo continua treinando com pares sintéticos de imagem-texto longo. Esta fase melhora significativamente o desempenho do modelo apenas com texto, ao mesmo tempo garantindo que o alinhamento imagem-texto aprendido nas etapas anteriores permaneça robusto.
Essa abordagem mantém um forte desempenho em tarefas multimodais enquanto aprimora as capacidades em cenários apenas com texto. Vamos ver como essa nova abordagem se compara ao Clip original.
As métricas de desempenho indicam mudanças no desempenho de recuperação em comparação com o modelo CLIP original: uma mudança de 165% em texto-para-texto, 12% em imagem-para-imagem, 6% em imagem-para-texto e 2% em texto-para-imagem, conforme mostrado na imagem abaixo.
Figura: Comparação de desempenho do modelo entre jina-clip, openai-clip-vit-b-16 e jina-embeddings-v2-base-en
O novo processo de treinamento aprimora a generalização entre tarefas e ajuda a reduzir a lacuna de modalidade. Vamos discutir a lacuna de modalidade, um grande obstáculo em modelos de IA multimodais, e por que esse problema acontece.
A Lacuna de Modalidade: Por Que Ela Acontece
A lacuna de modalidade é a separação espacial entre embeddings de diferentes tipos de entrada, como textos e imagens que são semanticamente semelhantes, mas estão distantes no espaço vetorial. Essa lacuna enfraquece a eficácia dos sistemas de recuperação multimodal, pois os embeddings não refletem totalmente a verdadeira relação entre entradas relacionadas. Como você pode ver na imagem abaixo, a representação parece um cone truncado, com embeddings de imagem em uma extremidade e embeddings de texto na outra, mostrando claramente a lacuna de modalidade.
Figura: As posições iniciais dos embeddings de imagem e texto no Jina CLIP, com pesos totalmente randomizados e sem treinamento prévio, projetadas em duas dimensões
Há algumas razões principais pelas quais essa lacuna surge, mesmo em modelos modernos:
O Efeito Cone Durante a Inicialização
Modelos multimodais, particularmente aqueles que lidam com entradas de texto e imagem, frequentemente usam codificadores separados para cada modalidade. Esses codificadores são normalmente inicializados com pesos aleatórios ou pré-treinados, o que faz com que embeddings de texto se agrupem em uma região do espaço vetorial e embeddings de imagem em outra, como visto na imagem acima. Essa separação inicial, chamada de efeito cone, dificulta o alinhamento adequado de embeddings de diferentes modalidades (por exemplo, imagens e textos relacionados). Por exemplo, o embedding de texto para um gato fofo e o embedding de imagem de um gato podem começar distantes devido a esse viés de inicialização, embora sejam semanticamente relacionados.
Escalonamento de Temperatura
Durante o treinamento, modelos de IA usam uma técnica chamada escalonamento de temperatura em sua função de perda contrastiva para ajustar quão proximamente os embeddings são alinhados. Embora ajude a ajustar as distâncias entre embeddings, o escalonamento de temperatura também pode preservar inadvertidamente a separação inicial entre modalidades, reforçando a lacuna de modalidade. Por exemplo, se o escalonamento de temperatura não for cuidadosamente ajustado, os embeddings para um filhote brincalhão e a imagem de um cachorro podem permanecer distantes demais no espaço vetorial, embora descrevam o mesmo conceito.
Falsos Negativos no Lote
Ao treinar com grandes conjuntos de dados, pares não correspondentes de pontos de dados (por exemplo, uma imagem de um cachorro pareada com o texto “uma maçã vermelha”) são tratados como exemplos negativos. No entanto, esses falsos negativos ainda podem compartilhar alguma sobreposição semântica. Por exemplo, se ambos os itens estiverem relacionados a uma categoria ampla de animais (por exemplo, uma foto de um cachorro e o texto “um lobo brincalhão”), o modelo poderia afastar esses embeddings mais do que o necessário, piorando ainda mais a lacuna de modalidade ao tratá-los incorretamente como totalmente não relacionados.
Entender por que a lacuna de modalidade acontece é apenas o primeiro passo. Para preencher essa lacuna, várias estratégias de treinamento foram desenvolvidas para aproximar embeddings de diferentes modalidades, garantindo uma recuperação mais precisa em tarefas multimodais.
Abordando a Lacuna de Modalidade: Técnicas de Treinamento e Além
A lacuna de modalidade é um problema estrutural que não tem uma solução fácil, mas existem estratégias para mitigar seu impacto. A chave é reduzir a separação entre embeddings de diferentes modalidades durante o treinamento, garantindo que imagens e textos que pertencem juntos sejam mapeados mais próximos no espaço vetorial.
Escalonamento de Temperatura Mais Alta
Na prática, aumentar a temperatura durante o treinamento pode incentivar embeddings de diferentes modalidades a se aproximarem, adicionando mais aleatoriedade ao processo de aprendizagem do modelo. Por exemplo, aumentar a temperatura pode ajudar a alinhar mais de perto os embeddings de uma imagem de um gato e o texto “um gato fofo”. No entanto, isso vem ao custo de uma convergência mais lenta e exige mais recursos computacionais. Embora modelos treinados com escalonamento de alta temperatura tendam a melhorar o alinhamento de embeddings de texto e imagem, a contrapartida costuma ser tempos de treinamento mais longos e maiores demandas computacionais.
Amostragem de Negativos Difíceis
Introduzir exemplos negativos difíceis, pares não correspondentes que são semanticamente próximos, é outra técnica para reduzir a lacuna de modalidade. Esses pares negativos difíceis levam o modelo a aprender distinções mais sutis entre conceitos relacionados, melhorando a precisão da recuperação. Por exemplo, parear uma imagem de um gato com o texto “um tigre pequeno” pode parecer uma incompatibilidade, mas o modelo aprende que essas duas entradas têm semânticas sobrepostas (ambos são felinos) e ainda devem estar um pouco alinhadas no espaço de embeddings. Esse processo ensina o modelo a reconhecer tanto as semelhanças quanto as diferenças entre conceitos relacionados, refinando sua capacidade de diferenciar entre correspondências próximas.
Recuperação Multimodal com Milvus e JinaCLIP: Um Exemplo Prático
Agora que exploramos os motivos técnicos por trás da lacuna de modalidade, vamos mergulhar em um exemplo prático de como criar um sistema de recuperação multimodal usando Milvus, um banco de dados vetorial open-source, e JinaCLIP.
Milvus gerencia, pesquisa e consulta vetores de alta dimensionalidade, tornando-o uma solução ideal para tarefas de recuperação multimodal e tarefas de Geração Aumentada por Recuperação (RAG). Esteja você lidando com texto, imagens ou outros tipos de dados, o Milvus permite armazenar embeddings de forma eficiente e recuperar resultados relevantes usando técnicas avançadas de busca por similaridade.
Nesta seção, percorreremos o processo de uso do Milvus para criar um sistema de recuperação multimodal que lida com embeddings de texto e imagem. O sistema permitirá que os usuários insiram texto ou imagens e recuperem os resultados mais semanticamente relevantes de um conjunto de dados misto.
Etapa 1: Configurando o Ambiente
Primeiro, precisamos instalar as bibliotecas de que precisaremos para nosso sistema em nosso ambiente:
!pip install pymilvus transformers torch timm
Em seguida, precisamos importar as bibliotecas necessárias e configurar nossa classe de codificador.
# Import necessary libraries
from transformers import AutoModel
from pymilvus import MilvusClient
import torch
# Defina a classe Encoder para lidar com a geração de embeddings de texto e imagem
class Encoder:
def __init__(self, model_name: str):
# Initialize the model (AutoModel from transformers instead of SentenceTransformer)
self.model = AutoModel.from_pretrained(model_name, trust_remote_code=True)
def encode_text(self, text: list[str]) -> list[float]:
# Generate embeddings for text only
with torch.no_grad():
text_emb = self.model.encode_text(text)
return text_emb
def encode_image(self, image_urls: list[str]) -> list[list[float]]:
# Generate embeddings for images only
with torch.no_grad():
image_emb = self.model.encode_image(image_urls)
return image_emb
# Initialize the encoder with the model jinaai/jina-clip-v1
model_name = "jinaai/jina-clip-v1"
encoder = Encoder(model_name)
No código acima, primeiro importamos as bibliotecas necessárias: AutoModel de transformers para nosso modelo de codificação, MilvusClient para interagir com o Milvus e torch para operações com tensores.
Em seguida, definimos uma classe Encoder que encapsula o AutoModel de transformers. Os métodos encode_text e encode_image usam o modelo para gerar embeddings para texto e imagens, respectivamente. O gerenciador de contexto torch.no_grad() é usado para desativar o cálculo de gradientes, que não é necessário para inferência e economiza memória.
Por fim, inicializamos o codificador com o modelo jinaai/jina-clip-v1, que pode codificar tanto texto quanto imagens em um espaço de embeddings compartilhado.
Etapa 2: Preparando os Dados
Em seguida, prepararemos nossos dados de exemplo para embedding e inserção no Milvus.
# Load data: images and text for embeddings
sentences = ['A blue cat', 'A red cat', 'A red cat generated by AI', 'A dog biting on a stick']
image_urls = [
'https://i.pinimg.com/600x315/21/48/7e/21487e8e0970dd366dafaed6ab25d8d8.jpg',
'https://i.pinimg.com/736x/c9/f2/3e/c9f23e212529f13f19bad5602d84b78b.jpg',
'https://images.fineartamerica.com/images/artworkimages/mediumlarge/1/red-cat-art-3771-bb-james-ahn.jpg',
'https://images.squarespace-cdn.com/content/v1/54822a56e4b0b30bd821480c/29708160-9b39-42d0-a5ed-4f8b9c85a267/labrador+retriever+dans+pet+care.jpeg?format=1500w'
]
# Generate embeddings for text and images
text_embeddings = encoder.encode_text(sentences)
image_embeddings = encoder.encode_image(image_urls)
# Ensure consistent dimensions
dim = len(image_embeddings[0])
Aqui, definimos listas de frases de exemplo e URLs de imagens. As URLs contêm imagens de gatos vermelhos, gatos azuis e um cachorro. Em seguida, usamos nosso codificador para gerar embeddings tanto para o texto quanto para as imagens. A variável dim armazena a dimensão dos embeddings, que precisaremos ao criar nossa coleção do Milvus.
Etapa 3: Configurando o Milvus
Agora, configuraremos nosso cliente Milvus e criaremos uma coleção para nossos dados multimodais.
# Insert embeddings into Milvus
collection_name = "multimodal_rag_demo"
milvus_client = MilvusClient(uri="./milvus_demo.db")
# Check if collection exists and drop it if so
if milvus_client.has_collection(collection_name):
print(f"Collection {collection_name} already exists. Deleting it...")
milvus_client.drop_collection(collection_name)
# Create Milvus collection
milvus_client.create_collection(
collection_name=collection_name,
auto_id=True,
dimension=dim,
enable_dynamic_field=True,
)
Inicializamos um cliente Milvus e nos conectamos a um arquivo de banco de dados local. Verificamos se uma coleção com o nome desejado já existe e, em caso afirmativo, a removemos para garantir um começo limpo.
Em seguida, criamos uma nova coleção com o nome especificado. O parâmetro auto_id=True informa ao Milvus para gerar IDs automaticamente para nossas entradas. Definimos a dimension para corresponder aos nossos embeddings e habilitamos campos dinâmicos, o que nos permite adicionar metadados adicionais às nossas entradas.
Etapa 4: Criando um Índice
Antes de inserir dados, criaremos um índice para otimizar o desempenho da busca:
index_params = MilvusClient.prepare_index_params()
index_params.add_index(
field_name="vector", # The field to be indexed (your embedding field)
metric_type="COSINE", # Can be L2, COSINE, etc.
index_type="FLAT", # FLAT ensures exact search, ideal for small datasets
)
# Create the index for the collection
milvus_client.create_index(collection_name, index_params)
print(f"Index created successfully for collection: {collection_name}")
O código acima cria um índice FLAT usando similaridade de cosseno como métrica de distância.
Etapa 5: Inserindo Dados no Milvus
Com nossa coleção e índice configurados, agora podemos inserir nossos dados no Milvus.
data_to_insert = []
# Insert text embeddings
for idx, txt_emb in enumerate(text_embeddings):
data_to_insert.append({"text": sentences[idx], "vector": txt_emb})
# Insert image embeddings
for idx, img_emb in enumerate(image_embeddings):
data_to_insert.append({"image_url": image_urls[idx], "vector": img_emb})
# Insert data into Milvus
insert_result = milvus_client.insert(
collection_name=collection_name,
data=data_to_insert,
)
print(f"Insert result: {insert_result}")
milvus_client.load_collection(collection_name)
No código acima, criamos uma lista de dicionários, cada um contendo uma frase de texto ou uma URL de imagem, junto com seu vetor de embedding correspondente. Em seguida, usamos o método insert do cliente Milvus para adicionar esses dados à nossa coleção. Após a inserção, carregamos a coleção na memória para prepará-la para a busca.
Etapa 6: Realizando Busca Multimodal
Por fim, realizamos uma busca multimodal usando consultas de imagem e texto.
# Multimodal search with a combination of image and text query
query_image_url = 'https://imgcdn.stablediffusionweb.com/2024/4/5/5e70d71c-a7f6-44e9-972d-8c5a27d45c3d.jpg'
query_text = "Give me similar red cats"
# Generate query embedding (image + text)
query_embedding_image = encoder.encode_image([query_image_url])[0]
query_embedding_text = encoder.encode_text([query_text])[0]
# Perform search in Milvus using image embedding
search_results_image = milvus_client.search(
collection_name=collection_name,
data=[query_embedding_image],
output_fields=["image_url", "text"], # Ensure both fields are included in the results
limit=5, # Number of results to return
search_params={"metric_type": "COSINE", "params": {"nprobe": 10}}
)
# Perform search in Milvus using text embedding
search_results_text = milvus_client.search(
collection_name=collection_name,
data=[query_embedding_text],
output_fields=["image_url", "text"], # Ensure both fields are included in the results
limit=5, # Number of results to return
search_params={"metric_type": "COSINE", "params": {"nprobe": 10}}
)
# Retrieve and print results from image query
print("Image Query Results:")
for result in search_results_image:
for hit in result:
image_url = hit['entity'].get('image_url')
text = hit['entity'].get('text')
if image_url:
print(f"Retrieved Image URL (from image query): {image_url}")
if text:
print(f"Retrieved Text (from image query): {text}")
# Retrieve and print results from text query
print("Text Query Results:")
for result in search_results_text:
for hit in result:
image_url = hit['entity'].get('image_url')
text = hit['entity'].get('text')
if image_url:
print(f"Retrieved Image URL (from text query): {image_url}")
if text:
print(f"Retrieved Text (from text query): {text}")
No código acima, demonstramos o processo de realizar uma busca multimodal. Começamos definindo tanto uma URL de imagem de consulta quanto um texto de consulta. A imagem de consulta se parece com isto:
Figura 2: Imagem de entrada de consulta de um gato vermelho e branco
Em seguida, codificamos essas consultas usando nosso codificador para gerar seus respectivos embeddings. Depois, realizamos duas buscas separadas no Milvus: uma usando o embedding da imagem e outra usando o embedding do texto. Para cada busca, solicitamos tanto os campos image_url quanto text na saída, permitindo-nos recuperar ambos os tipos de dados. Limitamos nossos resultados a 5 para cada busca e empregamos a similaridade de cosseno como nossa métrica de distância. O parâmetro nprobe em nossos parâmetros de busca nos permite ajustar finamente o número de clusters a pesquisar, oferecendo um equilíbrio entre velocidade e precisão da busca. Por fim, exibimos os resultados, mostrando quais imagens ou textos foram recuperados para cada tipo de consulta, demonstrando assim a capacidade do sistema de lidar com consultas baseadas tanto em texto quanto em imagem e correlacioná-las.
Você pode encontrar o código completo aqui.
Aqui estão resultados de exemplo:
Como você pode ver, quando usamos uma imagem para realizar uma busca vetorial, obtemos tanto URLs de imagens quanto texto relacionado à imagem, e vice-versa. Esse é o poder da busca multimodal. Aqui está uma das imagens que é recuperada como uma imagem semelhante em ambos os casos.
Figura 3: Imagem de saída de um gato vermelho após realizar uma busca por similaridade no Milvus
Como você pode ver, a imagem é semelhante à imagem do gato vermelho que fornecemos ao sistema como nossa consulta.
Você pode adicionar um reranker a este sistema para organizar os resultados da busca em termos de relevância, com os resultados mais relevantes aparecendo no topo. Embora, como é evidente, o Milvus faça um bom trabalho ao recuperar primeiro as melhores correspondências. Você também pode avançar este sistema para criar um sistema RAG multimodal.
Conclusão
Bo Wang explicou as complexidades de superar a lacuna de modalidade em modelos multimodais e demonstrou a transição do CLIP para o JinaCLIP. Ele detalhou os principais desafios do alinhamento texto-imagem e demonstrou como o JinaCLIP aborda essas questões.
Neste artigo, expandimos seus insights criando um sistema de busca por similaridade multimodal usando o JinaCLIP para gerar embeddings e o Milvus para obter recuperação eficiente. Com esse conhecimento, agora você pode implementar suas aplicações de busca multimodal, garantindo desempenho contínuo em consultas baseadas em texto e imagem, e até levá-lo mais longe integrando técnicas avançadas de busca, como reranking.
Recursos adicionais
Continue lendo
Zilliz Cloud On-Demand Compute: Pay Only for What You Use
The customer case behind Zilliz Cloud On-Demand: how a $10K vector search bill came down to under $500, and the engineering changes that made it possible.
Balancing Precision and Performance: How Zilliz Cloud's New Parameters Help You Optimize Vector Search
Optimize vector search with Zilliz Cloud’s level and recall features to tune accuracy, balance performance, and power AI applications.
Why Deepseek is Waking up AI Giants Like OpenAI And Why You Should Care
Discover how DeepSeek R1's open-source AI model with superior reasoning capabilities and lower costs is disrupting the AI landscape and challenging tech giants like OpenAI.