paper qa
v5.5.0
O PaperQA2 é um pacote para fazer geração aumentada de recuperação de alta precisão (RAG) em PDFs ou arquivos de texto, com foco na literatura científica. Veja nosso artigo recente de 2024 para ver exemplos do desempenho sobre -humano do PaperQA2 em tarefas científicas, como resposta a perguntas, resumo e detecção de contradição.
ask manualmenteNeste exemplo, pegamos uma pasta de PDFs de papel de pesquisa, magicamente obtemos seus metadados - incluindo contagens de citações com uma verificação de retração, depois analisar e cache PDFs em um índice de pesquisa de texto completo e, finalmente, responder à pergunta do usuário com um agente LLM.
pip install paper-qa
cd my_papers
pqa ask ' How can carbon nanotubes be manufactured at a large scale? 'Pergunta: Alguém projetou redes neurais que computam com proteínas ou DNA?
A alegação de que as redes neurais foram projetadas para calcular com o DNA é suportada por várias fontes. O trabalho de Qian, Winfree e Bruck demonstra o uso de cascatas de deslocamento de fios de DNA para construir componentes de rede neural, como neurônios artificiais e memórias associativas, usando um sistema baseado em DNA (Páginas Qian2011neurais 1-2, Qian2011neural 15-16, Qian2011neural páginas 54-56). Esta pesquisa inclui a implementação de um portão XOR de 3 bits e uma memória associativa de quatro neurônios Hopfield, mostrando o potencial do DNA para o cálculo da rede neural. Além disso, a aplicação de técnicas de aprendizado profundo à genômica, que envolve a computação com sequências de DNA, está bem documentado. Estudos aplicaram redes neurais convolucionais (CNNs) para prever características genômicas, como ligação ao fator de transcrição e acessibilidade do DNA (páginas EASLAN2019DEEP 4-5, Páginas Eraslan2019Deep 5-6). Esses modelos aproveitam as sequências de DNA como dados de entrada, usando efetivamente redes neurais para calcular com o DNA. Embora os trechos fornecidos não mencionem explicitamente o cálculo da rede neural baseada em proteínas, eles destacam o uso de redes neurais em tarefas relacionadas a sequências de proteínas, como prever a ligação ao DNA-proteína (páginas concolivas ZENG2016 1-2). No entanto, o foco principal permanece na computação baseada em DNA.
O PaperQA2 é projetado para ser o melhor modelo de pano agêntico para trabalhar com artigos científicos. Aqui estão alguns recursos:
Por padrão, ele usa incorporações e modelos OpenAI com um banco de dados vetorial Numpy para incorporar e pesquisar documentos. No entanto, você pode usar facilmente outros modelos ou incorporação de código aberto e de código aberto (veja os detalhes abaixo).
O PaperQA2 depende de algumas bibliotecas/APIs incríveis que tornam possível nosso repositório. Aqui estão alguns em nenhuma ordem específica:
Trabalhamos duro em atualizações fundamentais há um tempo e seguimos principalmente Semver. Significando que aumentamos o número principal da versão em cada mudança de quebra. Isso nos leva ao número atual da versão principal v5. Então, por que ligar é o repo agora chamado PaperQA2? Queríamos observar o fato de que excedemos o desempenho humano em muitas métricas importantes. Por isso, chamamos arbitrariamente a versão 5 e o papel de paperqa2 e as versões antes dele como papelqa1 para denotar a mudança significativa no desempenho. Reconhecemos que somos desafiados a nomear e contar em Futurehouse, por isso nos reservamos o direito a qualquer momento de alterar arbitrariamente o nome para Papercrow.
Versão 5 adicionada:
pqaDocs Observe que os objetos Docs em conserva de versões anteriores do PaperQA são incompatíveis com a versão 5 e precisarão ser reconstruídas. Além disso, nossa versão mínima do Python foi aumentada para o Python 3.11.
Para entender o PaperQA2, vamos começar com os pedaços do algoritmo subjacente. O fluxo de trabalho padrão do PaperQA2 é o seguinte:
| Fase | Ações do PaperQA2 |
|---|---|
| 1. Pesquisa em papel | - Obtenha documentos de candidatos da Palavra-chave gerada por LLM |
| - Shunk, incorporar e adicionar documentos candidatos ao estado | |
| 2. Reúna evidências | - Consulta incorporada ao vetor |
| - Rank Top K Document Chunks no estado atual | |
| - Crie um resumo pontuado de cada pedaço no contexto da consulta atual | |
| - Use LLM para re-escore e selecione os resumos mais relevantes | |
| 3. Gere a resposta | - Coloque os melhores resumos no prompt com contexto |
| - Gere uma resposta com o prompt |
As ferramentas podem ser invocadas em qualquer ordem por um agente de idiomas. Por exemplo, um agente LLM pode fazer uma pesquisa estreita e ampla, ou usar frases diferentes para a etapa de evidência de coleta a partir da etapa de resposta gerar.
Para uma configuração de não desenvolvimento, instale o PaperQA2 (também conhecido como versão 5) da Pypi. Nota A versão 5 requer Python 3.11+.
pip install paper-qa > =5Para configuração de desenvolvimento, consulte o arquivo contribuinte.md.
O PaperQA2 usa um LLM para operar, portanto, você precisará definir uma variável de ambiente de chave de API apropriada (ou seja, export OPENAI_API_KEY=sk-... ) ou configurar um servidor LLM de código aberto (ou seja, usando o Llamafile. Qualquer modelo compatível com litellm pode ser configurado para usar com o PaperQA2.
Se você precisar indexar um grande conjunto de trabalhos (mais de 100), provavelmente desejará uma chave da API para o CrossRef e o semântico Scholar, que permitirá que você evite atingir os limites das taxas públicas usando esses serviços de metadados. Eles podem ser exportados como variáveis CROSSREF_API_KEY e SEMANTIC_SCHOLAR_API_KEY .
A maneira mais rápida de testar o PaperQA2 é através da CLI. Primeiro navegue para um diretório com alguns papéis e use a pqa CLI:
$ pqa ask ' What manufacturing challenges are unique to bispecific antibodies? 'Você verá o PaperQA2 indexar seus arquivos PDF locais, reunindo os metadados necessários para cada um deles (usando o CrossRef e o semântico), pesquisará esse índice e, em seguida, dividir os arquivos em contextos de evidências, classificar -os e, finalmente, gerar uma resposta. Na próxima vez que este diretório for consultado, seu índice já será construído (exceto as diferenças detectadas, como novos papéis adicionados), para que pulará as etapas de indexação e chunking.
Todas as respostas anteriores serão indexadas e armazenadas, você poderá visualizá -las consultando através do subcomando search ou acessá -las no seu diretório PQA_HOME , que indica ~/.pqa/ .
$ pqa search -i ' answers ' ' antibodies ' O PaperQA2 é altamente configurável, ao fugir da linha de comando, pqa --help mostra todas as opções e descrições curtas. Por exemplo, para executar com uma temperatura mais alta:
$ pqa --temperature 0.5 ask ' What manufacturing challenges are unique to bispecific antibodies? ' Você pode visualizar todas as configurações com pqa view . Outra coisa útil é mudar para outras configurações modeladas - por exemplo, fast é uma configuração que responde mais rapidamente e você pode vê -lo com pqa -s fast view
Talvez você tenha algumas novas configurações que deseja salvar? Você pode fazer isso com
pqa -s my_new_settings --temperature 0.5 --llm foo-bar-5 saveE então você pode usá -lo com
pqa -s my_new_settings ask ' What manufacturing challenges are unique to bispecific antibodies? ' Se você executar pqa com um comando que exigir uma nova indexação, digamos se você alterar o Chunk_size padrão, um novo índice será criado automaticamente para você.
pqa --parsing.chunk_size 5000 ask ' What manufacturing challenges are unique to bispecific antibodies? ' Você também pode usar pqa para fazer pesquisa de texto completo com o uso do LLMS View o comando de pesquisa. Por exemplo, vamos salvar o índice de um diretório e dar um nome:
pqa -i nanomaterials indexAgora posso procurar artigos sobre termoelétricos:
pqa -i nanomaterials search thermoelectricsOu posso usar o pedido normal
pqa -i nanomaterials ask ' Are there nm scale features in thermoelectric materials? 'Tanto o CLI quanto o módulo têm configurações pré-configuradas com base no desempenho anterior e em nossas publicações, elas podem ser invocadas da seguinte forma:
pqa --settings < setting name > ask ' Are there nm scale features in thermoelectric materials? ' Inside paperqa/configs agrupamos configurações úteis conhecidas:
| Nome da configuração | Descrição |
|---|---|
| High_quality | Altamente performante, relativamente caro (devido à consulta evidence_k = 15) usando um agente ToolSelector . |
| rápido | Definir para obter respostas barato e rapidamente. |
| Wikicrow | Definir para imitar a redação do artigo da Wikipedia usada em nossa publicação do Wikicrow. |
| Contracrow | Definir para encontrar contradições nos artigos, sua consulta deve ser uma reivindicação que precisa ser sinalizada como uma contradição (ou não). |
| depurar | Definir útil apenas para depuração, mas não em qualquer aplicativo real além da depuração. |
| Tier1_limits | Configurações que correspondem aos limites da taxa de abertura para cada camada, você pode usar tier<1-5>_limits para especificar o nível. |
Se você estiver atingindo limites de taxa, digamos com o plano OpenAi Tier 1, poderá adicioná -los ao PaperQA2. Para cada camada do OpenAI, existe uma configuração pré-criada para limitar o uso.
pqa --settings ' tier1_limits ' ask ' Are there nm scale features in thermoelectric materials? 'Isso limitará seu sistema a usar o Tier1_limits e desacelerar suas consultas para acomodar.
Você também pode especificá -los manualmente com qualquer string de limite de taxa que corresponda à especificação no módulo Limits:
pqa --summary_llm_config ' {"rate_limit": {"gpt-4o-2024-08-06": "30000 per 1 minute"}} ' ask ' Are there nm scale features in thermoelectric materials? ' Ou adicionando um objeto Settings , se chamando imperativamente:
from paperqa import Settings , ask
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings (
llm_config = { "rate_limit" : { "gpt-4o-2024-08-06" : "30000 per 1 minute" }},
summary_llm_config = { "rate_limit" : { "gpt-4o-2024-08-06" : "30000 per 1 minute" }},
),
)O fluxo de trabalho completo do PaperQA2 pode ser acessado via Python diretamente:
from paperqa import Settings , ask
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings ( temperature = 0.5 , paper_directory = "my_papers" ),
)Consulte nossos documentos de instalação sobre como instalar o pacote do Pypi.
ask manualmente O objeto de resposta possui os seguintes atributos: formatted_answer , answer (resposta sozinha), question e context (os resumos das passagens encontradas para a resposta). ask usará a ferramenta SearchPapers , que consultará um índice local de arquivos, você pode especificar esse local através do objeto Settings :
from paperqa import Settings , ask
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings ( temperature = 0.5 , paper_directory = "my_papers" ),
) ask é apenas um invólucro de conveniência em torno do ponto de entrada real, que pode ser acessado se você quiser executar cargas de trabalho assíncronas simultâneas:
from paperqa import Settings , agent_query , QueryRequest
answer = await agent_query (
QueryRequest (
query = "What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings ( temperature = 0.5 , paper_directory = "my_papers" ),
)
) O agente padrão usará um agente baseado em LLM, mas você também pode especificar um agente "fake" para usar um caminho de chamada codificado de pesquisa -> Reúna evidências -> Resposta para reduzir o uso do token.
Se você preferir controle de granulação fina e deseja adicionar objetos aos documentos que se objeta (em vez de usar a ferramenta de pesquisa), a interface do objeto Docs anteriormente existente pode ser usada:
from paperqa import Docs , Settings
# valid extensions include .pdf, .txt, and .html
doc_paths = ( "myfile.pdf" , "myotherfile.pdf" )
docs = Docs ()
for doc in doc_paths :
docs . add ( doc )
settings = Settings ()
settings . llm = "claude-3-5-sonnet-20240620"
settings . answer . answer_max_sources = 3
answer = docs . query (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = settings ,
)
print ( answer . formatted_answer ) O PaperQA2 foi escrito para ser usado de forma assíncrona. A API síncrona é apenas um invólucro ao redor do Async. Aqui estão os métodos e seus equivalentes async :
| Sincronização | Assíncrono |
|---|---|
Docs.add | Docs.aadd |
Docs.add_file | Docs.aadd_file |
Docs.add_url | Docs.aadd_url |
Docs.get_evidence | Docs.aget_evidence |
Docs.query | Docs.aquery |
A versão síncrona apenas chama a versão assíncrona em um loop. A maioria dos ambientes Python modernos suporta async nativamente (incluindo notebooks Jupyter!). Então você pode fazer isso em um notebook Jupyter:
import asyncio
from paperqa import Docs
async def main () -> None :
docs = Docs ()
# valid extensions include .pdf, .txt, and .html
for doc in ( "myfile.pdf" , "myotherfile.pdf" ):
await docs . aadd ( doc )
answer = await docs . aquery (
"What manufacturing challenges are unique to bispecific antibodies?"
)
print ( answer . formatted_answer )
asyncio . run ( main ()) Por padrão, ele usa modelos OpenAI com gpt-4o-2024-08-06 para a etapa de renomeamento e resumo, a configuração summary_llm e para a etapa de resposta, a configuração llm . Você pode ajustar isso facilmente:
from paperqa import Settings , ask
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings (
llm = "gpt-4o-mini" , summary_llm = "gpt-4o-mini" , paper_directory = "my_papers"
),
) Você pode usar antropia ou qualquer outro modelo suportado por litellm :
from paperqa import Settings , ask
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings (
llm = "claude-3-5-sonnet-20240620" , summary_llm = "claude-3-5-sonnet-20240620"
),
)Você pode usar llama.cpp para ser o LLM. Observe que você deve usar modelos relativamente grandes, porque o PaperQA2 requer seguindo muitas instruções. Você não terá um bom desempenho com os modelos 7B.
A maneira mais fácil de configurar é baixar um arquivo llama e executá -lo com -cb -np 4 -a my-llm-model --embedding que permitirá lote e incorporação contínuos.
from paperqa import Settings , ask
local_llm_config = dict (
model_list = [
dict (
model_name = "my_llm_model" ,
litellm_params = dict (
model = "my-llm-model" ,
api_base = "http://localhost:8080/v1" ,
api_key = "sk-no-key-required" ,
temperature = 0.1 ,
frequency_penalty = 1.5 ,
max_tokens = 512 ,
),
)
]
)
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings (
llm = "my-llm-model" ,
llm_config = local_llm_config ,
summary_llm = "my-llm-model" ,
summary_llm_config = local_llm_config ,
),
) Modelos hospedados com ollama também são suportados. Para executar o exemplo abaixo, certifique-se de baixar o LLAMA3.2 e o MXBAI-EBBED-LARGE via Ollama.
from paperqa import Settings , ask
local_llm_config = {
"model_list" : [
{
"model_name" : "ollama/llama3.2" ,
"litellm_params" : {
"model" : "ollama/llama3.2" ,
"api_base" : "http://localhost:11434" ,
},
}
]
}
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings (
llm = "ollama/llama3.2" ,
llm_config = local_llm_config ,
summary_llm = "ollama/llama3.2" ,
summary_llm_config = local_llm_config ,
embedding = "ollama/mxbai-embed-large" ,
),
) O PaperQA2 é o padrão de usar o OpenAI ( text-embedding-3-small ), mas possui opções flexíveis para lojas vetoriais e opções de incorporação. A maneira mais simples de alterar uma incorporação é através do argumento embedding ao construtor de objetos de Settings :
from paperqa import Settings , ask
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings ( embedding = "text-embedding-3-large" ),
) embedding aceita qualquer nome de modelo de incorporação suportado pela Litellm. O PaperQA2 também suporta uma entrada de incorporação de "hybrid-<model_name>" ie "hybrid-text-embedding-3-small" para usar uma palavra-chave esparsa híbrida (com base em uma incorporação de módulo de token) e incorporação de vetor denso, onde qualquer modelo litellm pode ser usado no nome denso do modelo. "sparse" pode ser usado para usar apenas uma palavra -chave esparsa incorporando.
Os modelos de incorporação são usados para criar o índice do PaperQA2 dos vetores de incorporação de texto completo (argumento texts_index ). O modelo de incorporação pode ser especificado como uma configuração quando você está adicionando novos papéis ao objeto Docs :
from paperqa import Docs , Settings
docs = Docs ()
for doc in ( "myfile.pdf" , "myotherfile.pdf" ):
docs . add ( doc , settings = Settings ( embedding = "text-embedding-large-3" )) Observe que o PaperQA2 usa o Numpy como uma loja de vetor densa. Seu design de usar uma pesquisa de palavras -chave reduz inicialmente o número de pedaços necessários para cada resposta para um número relativamente pequeno <1k. Portanto, NumpyVectorStore é um bom lugar para começar, é uma loja simples na memória, sem um índice. No entanto, se for necessária uma loja vetorial maior do que a memória, atualmente estamos faltando aqui.
As incorporações híbridas podem ser personalizadas:
from paperqa import (
Docs ,
HybridEmbeddingModel ,
SparseEmbeddingModel ,
LiteLLMEmbeddingModel ,
)
model = HybridEmbeddingModel (
models = [ LiteLLMEmbeddingModel (), SparseEmbeddingModel ( ndim = 1024 )]
)
docs = Docs ()
for doc in ( "myfile.pdf" , "myotherfile.pdf" ):
docs . add ( doc , embedding_model = model ) Os modelos de incorporação esparsa (palavra -chave) são padrão para ter 256 dimensões, mas isso pode ser especificado através do argumento ndim .
Você pode usar um modelo de SentenceTransformerEmbeddingModel se instalar sentence-transformers , que é uma biblioteca de incorporação local com suporte para modelos Huggingface e muito mais. Você pode instalá -lo adicionando os extras local .
pip install paper-qa[local] e então prefixo incorporar nomes de modelos com st- :
from paperqa import Settings , ask
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings ( embedding = "st-multi-qa-MiniLM-L6-cos-v1" ),
)ou com um modelo híbrido
from paperqa import Settings , ask
answer = ask (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = Settings ( embedding = "hybrid-st-multi-qa-MiniLM-L6-cos-v1" ),
) Você pode ajustar o número de fontes (passagens do texto) para reduzir o uso do token ou adicionar mais contexto. k refere -se aos principais K mais relevantes e diversificados (maio de diferentes fontes) passagens. Cada passagem é enviada ao LLM para resumir ou determinar se é irrelevante. Após esta etapa, um limite de max_sources é aplicado para que a resposta final possa se encaixar na janela de contexto LLM. Assim, k > max_sources e max_sources é o número de fontes usadas na resposta final.
from paperqa import Settings
settings = Settings ()
settings . answer . answer_max_sources = 3
settings . answer . k = 5
docs . query (
"What manufacturing challenges are unique to bispecific antibodies?" ,
settings = settings ,
)Você não precisa usar papéis - você pode usar o código ou o HTML bruto. Observe que esta ferramenta está focada em responder perguntas, para que não se sai bem na redação do código. Uma observação é que a ferramenta não pode inferir citações do código, então você precisará fornecê -las você mesmo.
import glob
import os
from paperqa import Docs
source_files = glob . glob ( "**/*.js" )
docs = Docs ()
for f in source_files :
# this assumes the file names are unique in code
docs . add ( f , citation = "File " + os . path . name ( f ), docname = os . path . name ( f ))
answer = docs . query ( "Where is the search bar in the header defined?" )
print ( answer )Você pode querer cache textos e incorporação analisada em um banco de dados ou arquivo externo. Você pode construir um objeto Docs a partir dos que diretamente:
from paperqa import Docs , Doc , Text
docs = Docs ()
for ... in my_docs :
doc = Doc ( docname = ..., citation = ..., dockey = ..., citation = ...)
texts = [ Text ( text = ..., name = ..., doc = doc ) for ... in my_texts ]
docs . add_texts ( texts , doc ) Os índices serão colocados no diretório inicial por padrão. Isso pode ser controlado através da variável de ambiente PQA_HOME .
Os índices são fabricados lendo arquivos no Settings.paper_directory . Por padrão, lemos recursivamente a partir dos subdiretos do diretório de papel, a menos que desativado usando Settings.index_recursively . O diretório de papel não é modificado de forma alguma, é apenas ler.
O processo de indexação tenta inferir metadados em papel como o título e o DOI usando o processamento de texto movido a LLM. Você pode evitar esse ponto de incerteza usando um arquivo "manifesto", que é um CSV contendo três colunas (a ordem não importa):
file_location : caminho relativo para o PDF do artigo no diretório de índicedoi : doi do papeltitle : Título do artigoAo fornecer essas informações, garantimos que as consultas a provedores de metadados como o CrossRef sejam precisas.
Os índices de pesquisa local são criados com base em um hash do objeto Settings atuais. Portanto, especifique corretamente o paper_directory para o objeto Settings . Em geral, é aconselhável:
import os
from paperqa import Settings
from paperqa . agents . main import agent_query
from paperqa . agents . models import QueryRequest
from paperqa . agents . search import get_directory_index
async def amain ( folder_of_papers : str | os . PathLike ) -> None :
settings = Settings ( paper_directory = folder_of_papers )
# 1. Build the index. Note an index name is autogenerated when unspecified
built_index = await get_directory_index ( settings = settings )
print ( settings . get_index_name ()) # Display the autogenerated index name
print ( await built_index . index_files ) # Display the index contents
# 2. Use the settings as many times as you want with ask
answer_response_1 = await agent_query (
query = QueryRequest (
query = "What is the best way to make a vaccine?" , settings = settings
)
)
answer_response_2 = await agent_query (
query = QueryRequest (
query = "What manufacturing challenges are unique to bispecific antibodies?" ,
settings = settings ,
)
) Em paperqa/agents/task.py , você encontrará:
GradablePaperQAEnvironment : um ambiente que pode classificar as respostas, dada uma função de avaliação.LitQAv2TaskDataset : um conjunto de dados de tarefas projetado para puxar o Litqa V2 de abraçar o rosto e criar um GradablePaperQAEnvironmentAqui está um exemplo de como usá -los:
import os
from aviary . env import TaskDataset
from ldp . agent import SimpleAgent
from ldp . alg . callbacks import MeanMetricsCallback
from ldp . alg . runners import Evaluator , EvaluatorConfig
from paperqa import QueryRequest , Settings
from paperqa . agents . task import TASK_DATASET_NAME
async def evaluate ( folder_of_litqa_v2_papers : str | os . PathLike ) -> None :
base_query = QueryRequest (
settings = Settings ( paper_directory = folder_of_litqa_v2_papers )
)
dataset = TaskDataset . from_name ( TASK_DATASET_NAME , base_query = base_query )
metrics_callback = MeanMetricsCallback ( eval_dataset = dataset )
evaluator = Evaluator (
config = EvaluatorConfig ( batch_size = 3 ),
agent = SimpleAgent (),
dataset = dataset ,
callbacks = [ metrics_callback ],
)
await evaluator . evaluate ()
print ( metrics_callback . eval_means )Um dos recursos mais poderosos do PaperQA2 é sua capacidade de combinar dados de várias fontes de metadados. Por exemplo, o Unpaywall pode fornecer status de acesso aberto/links diretos para PDFs, o Crossref pode fornecer Bibtex e o Scholar Semântico pode fornecer licenças de citação. Aqui está uma breve demonstração de como fazer isso:
from paperqa . clients import DocMetadataClient , ALL_CLIENTS
client = DocMetadataClient ( clients = ALL_CLIENTS )
details = await client . query ( title = "Augmenting language models with chemistry tools" )
print ( details . formatted_citation )
# Andres M. Bran, Sam Cox, Oliver Schilter, Carlo Baldassari, Andrew D. White, and Philippe Schwaller.
# Augmenting large language models with chemistry tools. Nature Machine Intelligence,
# 6:525-535, May 2024. URL: https://doi.org/10.1038/s42256-024-00832-8,
# doi:10.1038/s42256-024-00832-8.
# This article has 243 citations and is from a domain leading peer-reviewed journal.
print ( details . citation_count )
# 243
print ( details . license )
# cc-by
print ( details . pdf_url )
# https://www.nature.com/articles/s42256-024-00832-8.pdf O client.query deve verificar as correspondências exatas do título. É um pouco robusto (como invadir, perdendo uma palavra). Existem duplicatas para títulos - para que você também possa adicionar autores a desambiguar. Ou você pode fornecer um DOI diretamente client.query(doi="10.1038/s42256-024-00832-8") .
Se você estiver fazendo isso em larga escala, pode não querer usar ALL_CLIENTS (basta omitir o argumento) e pode especificar quais campos específicos deseja acelerar as consultas. Por exemplo:
details = await client . query (
title = "Augmenting large language models with chemistry tools" ,
authors = [ "Andres M. Bran" , "Sam Cox" ],
fields = [ "title" , "doi" ],
)retornará muito mais rápido que a primeira consulta e teremos certeza de que os autores correspondem.
Bem, essa é uma pergunta muito boa! Provavelmente é melhor baixar os PDFs de papéis que você acha que ajudará a responder sua pergunta e começar a partir daí.
Já faz um tempo desde que testamos isso - então deixe -nos saber se ele ocorre em problemas!
Se você usar o Zotero para organizar sua bibliografia pessoal, poderá usar o paperqa.contrib.ZoteroDB para consultar papéis da sua biblioteca, que depende do Pyzotero.
Instale pyzotero através do zotero extra para este recurso:
pip install paperqa[zotero]Primeiro, observe que o PaperQA2 analisa os PDFs de papéis para armazenar no banco de dados, para que todos os documentos relevantes tenham PDFs armazenados dentro do seu banco de dados. Você pode fazer com que o Zotero faça isso automaticamente, destacando as referências que deseja recuperar, clicando com o botão direito do mouse e selecionando "Encontre os PDFs disponíveis" . Você também pode arrastar manualmente os PDFs para cada referência.
Para baixar artigos, você precisa obter uma chave de API para sua conta.
ZOTERO_USER_ID .https://www.zotero.org/groups/groupname e passa o link de configurações. O ID é o número inteiro após /grupos /. ( H/T Pyzotero! )ZOTERO_API_KEY .Com isso, podemos baixar papéis da nossa biblioteca e adicioná -los ao paperqa2:
from paperqa import Docs
from paperqa . contrib import ZoteroDB
docs = Docs ()
zotero = ZoteroDB ( library_type = "user" ) # "group" if group library
for item in zotero . iterate ( limit = 20 ):
if item . num_pages > 30 :
continue # skip long papers
docs . add ( item . pdf , docname = item . key ) que baixarão os 20 primeiros artigos no seu banco de dados Zotero e os adicionarão ao objeto Docs .
Também podemos fazer consultas específicas da nossa biblioteca Zotero e iterar sobre os resultados:
for item in zotero . iterate (
q = "large language models" ,
qmode = "everything" ,
sort = "date" ,
direction = "desc" ,
limit = 100 ,
):
print ( "Adding" , item . title )
docs . add ( item . pdf , docname = item . key ) Você pode ler mais sobre a sintaxe de pesquisa digitando zotero.iterate? em ipython.
Se você deseja procurar trabalhos fora de sua própria coleção, encontrei um projeto não relacionado chamado papel-raspador que parece ajudar. Mas, cuidado, esse projeto parece usar algumas ferramentas de raspagem que podem violar os direitos do editor ou estar em uma área cinzenta da legalidade.
from paperqa import Docs
keyword_search = "bispecific antibody manufacture"
papers = paperscraper . search_papers ( keyword_search )
docs = Docs ()
for path , data in papers . items ():
try :
docs . add ( path )
except ValueError as e :
# sometimes this happens if PDFs aren't downloaded or readable
print ( "Could not read" , path , e )
answer = docs . query (
"What manufacturing challenges are unique to bispecific antibodies?"
)
print ( answer )Para executar uma função em cada parcela das conclusões do LLM, você precisa fornecer uma função que possa ser executada em cada pedaço. Por exemplo, para obter uma visão de máquina de escrever das conclusões, você pode fazer:
def typewriter ( chunk : str ) -> None :
print ( chunk , end = "" )
docs = Docs ()
# add some docs...
docs . query (
"What manufacturing challenges are unique to bispecific antibodies?" ,
callbacks = [ typewriter ],
) Em geral, as incorporações são armazenadas em cache quando você pega um Docs independentemente do vetor que você usa. Portanto, desde que você salve seu objeto Docs subjacentes, você poderá evitar reembolsar seus documentos.
Você pode personalizar qualquer um dos prompts usando configurações.
from paperqa import Docs , Settings
my_qa_prompt = (
"Answer the question '{question}' n "
"Use the context below if helpful. "
"You can cite the context using the key like (Example2012). "
"If there is insufficient context, write a poem "
"about how you cannot answer. n n "
"Context: {context}"
)
docs = Docs ()
settings = Settings ()
settings . prompts . qa = my_qa_prompt
docs . query ( "Are covid-19 vaccines effective?" , settings = settings )Após a sintaxe acima, você também pode incluir prompts executados após a consulta e antes da consulta. Por exemplo, você pode usar isso para criticar a resposta.
Internamente no Futurehouse, temos um conjunto de ferramentas ligeiramente diferentes. Estamos tentando colocar alguns deles, como a Traversal de Citation, neste repositório. No entanto, temos APIs e licenças para acessar trabalhos de pesquisa que não podemos compartilhar abertamente. Da mesma forma, nos resultados de nossos trabalhos de pesquisa, não começamos com os PDFs relevantes conhecidos. Nosso agente precisa identificá -los usando a pesquisa de palavras -chave em todos os papéis, em vez de apenas um subconjunto. Estamos gradualmente alinhando essas duas versões do PaperQA, mas até que haja uma maneira de código aberto de acessar livremente papéis (mesmo apenas documentos de código aberto), você precisará fornecer PDFs você mesmo.
Langchain e Llamaindex são estruturas para trabalhar com aplicativos LLM, com abstrações feitas para fluxos de trabalho agênticos e geração aumentada de recuperação.
Com o tempo, a equipe do PaperQA, ao longo do tempo, escolheu se tornar a estrutura-estrutura, em vez disso, terceirizando os drivers LLM para Litellm e nenhuma estrutura além do Pydantic para suas ferramentas. O PaperQA se concentra em artigos científicos e em seus metadados.
O PaperQA pode ser reimplementado usando Llandeindex ou Langchain. Por exemplo, nossa ferramenta GatherEvidence pode ser reimplementada como um retriever com um resumo contextual baseado em LLM. Há um trabalho semelhante com o método de resposta a árvores em Llamaindex.
A aula Docs pode ser em conserva e sem pular. Isso é útil se você deseja salvar as incorporações dos documentos e depois carregá -los posteriormente.
import pickle
# save
with open ( "my_docs.pkl" , "wb" ) as f :
pickle . dump ( docs , f )
# load
with open ( "my_docs.pkl" , "rb" ) as f :
docs = pickle . load ( f )Contido no docs/2024-10-16_litqa2-splits.json5 são os IDs da pergunta (correspondem aos IDs de perguntas do Labqa2 do laboratório) usados nas divisões de trem e avaliação, bem como o papel usado para construir os índices de divisão de trem e avaliação . A divisão de teste permanece mantida.
Leia e cite os seguintes papéis se você usar este software:
@article { skarlinski2024language ,
title = { Language agents achieve superhuman synthesis of scientific knowledge } ,
author = {
Michael D. Skarlinski and
Sam Cox and
Jon M. Laurent and
James D. Braza and
Michaela Hinks and
Michael J. Hammerling and
Manvitha Ponnapati and
Samuel G. Rodriques and
Andrew D. White } ,
year = { 2024 } ,
journal = { arXiv preprent arXiv:2409.13740 } ,
url = { https://doi.org/10.48550/arXiv.2409.13740 }
} @article { lala2023paperqa ,
title = { PaperQA: Retrieval-Augmented Generative Agent for Scientific Research } ,
author = {
Jakub Lála and
Odhran O'Donoghue and
Aleksandar Shtedritski and
Sam Cox and
Samuel G. Rodriques and
Andrew D. White } ,
journal = { arXiv preprint arXiv:2312.07559 } ,
year = { 2023 }
}
