如何基于HuggingFace的Deeppavlov构建开放域问答（ODQA/KBQA）模型并搭建自定义模型

Alright, let’s walk through exactly how to build and customize open-domain QA (ODQA/KBQA) models using DeepPavlov—this guide covers both out-of-the-box usage and rolling your own custom setup with practical code snippets and config examples.

First, get your environment set up. Install DeepPavlov with:

pip install deeppavlov

DeepPavlov has pre-trained pipelines for ODQA (like SQuAD-based models) that you can use in minutes. For example, to load a BERT-based SQuAD model:

from deeppavlov import build_model, configs

# Download and load the pre-trained model
odqa_model = build_model(configs.squad.squad_bert, download=True)

# Test it with sample context and question
context = "DeepPavlov is an open-source conversational AI library built by the Neural Networks and Deep Learning Lab at MIPT."
question = "Which lab developed DeepPavlov?"
print(odqa_model([context], [question]))  # Output: ["Neural Networks and Deep Learning Lab at MIPT"]

This is an extractive ODQA model—it pulls the answer directly from the provided context, which is perfect for basic open-domain use cases.

If you need a model tailored to your specific domain or dataset, follow these steps:

2.1 Prepare Your Dataset #

DeepPavlov works best with SQuAD-formatted data. Here’s a minimal example of what your dataset JSON should look like:

{
  "data": [
    {
      "title": "My Custom Domain",
      "paragraphs": [
        {
          "context": "Your custom domain context goes here—e.g., \"Our company’s flagship product is XYZ, launched in 2023.\"",
          "qas": [
            {
              "question": "When was XYZ launched?",
              "id": "1",
              "answers": [{"text": "2023", "answer_start": 47}]
            }
          ]
        }
      ]
    }
  ]
}

Load the dataset using DeepPavlov’s DatasetReader:

from deeppavlov.core.data.dataset_reader import DatasetReader

reader = DatasetReader()
custom_dataset = reader.read("path/to/your/dataset.json", format="squad")

2.2 Define Your Model Configuration #

DeepPavlov uses YAML/JSON config files to define model pipelines. Here’s a custom config for a RoBERTa-based ODQA model:

dataset_reader:
  type: squad_reader
  data_path: "path/to/your/dataset.json"

dataset_iterator:
  type: squad_iterator
  batch_size: 8
  shuffle: true

chainer:
  - component:
      type: bert_preprocessor
      vocab_file: "roberta-base-vocab.json"
      do_lower_case: false
  - component:
      type: bert_squad
      pretrained_bert: "roberta-base"
      save_path: "models/custom_odqa/model"
      learning_rate: 3e-5

train:
  epochs: 3
  validation_every_n_epochs: 1
  log_every_n_steps: 10

This config sets up data loading, preprocessing, and the core QA model. Adjust batch_size, learning_rate, or pretrained_bert (e.g., use roberta-large for better performance) based on your needs.

2.3 Train and Evaluate #

Train the model via command line:

python -m deeppavlov train path/to/your/config.yaml

Or via Python code:

from deeppavlov import train_model

custom_model = train_model("path/to/your/config.yaml")

After training, evaluate on your test set to check Exact Match (EM) and F1 scores:

eval_results = custom_model.evaluate(custom_dataset["test"])
print(f"Exact Match: {eval_results['exact_match']:.2f} | F1 Score: {eval_results['f1']:.2f}")

KBQA answers questions using structured knowledge bases (like Wikidata, or your own custom KB). Here’s how to set it up:

3.1 Prepare Your Knowledge Base #

You can use a CSV, RDF, or pre-built KB. For a custom CSV KB, format it like this:

subject,predicate,object
DeepPavlov,developer,MIPT Neural Networks Lab
DeepPavlov,launch_year,2017
DeepPavlov,purpose,Conversational AI Development

Load it into DeepPavlov’s KnowledgeBase:

from deeppavlov.knowledge_base.kb import KnowledgeBase

kb = KnowledgeBase(load_path="path/to/your/kb.csv", format="csv")

3.2 Set Up the KBQA Pipeline #

A typical KBQA pipeline includes entity linking (finding entities in the question), relation extraction (identifying the relationship to query), and KB querying (retrieving the answer). Here’s a sample config:

chainer:
  - component:
      type: entity_linker
      kb: "path/to/your/kb.csv"
      pretrained_model: "bert-base-uncased"
  - component:
      type: relation_extractor
      pretrained_model: "bert-base-uncased"
      dataset_path: "path/to/relation_training_data.json"
  - component:
      type: kb_qa_solver
      kb: "path/to/your/kb.csv"

Load and test the model:

from deeppavlov import build_model

kbqa_model = build_model("path/to/kbqa_config.yaml", download=True)
print(kbqa_model(["When was DeepPavlov launched?"]))  # Output: ["2017"]

• Fine-tune for domain specificity: If your data is niche (e.g., medical, legal), start with a domain-specific pre-trained model (like biobert-base for healthcare) instead of generic BERT/RoBERTa.
• Optimize performance: Enable GPU acceleration by ensuring PyTorch is set up with CUDA—DeepPavlov will auto-use GPU if available.
• Multi-turn ODQA: For conversational QA, add a dialogue state tracker component to your pipeline to maintain context across questions.
• Error analysis: Use DeepPavlov’s logging tools to inspect misclassified examples and adjust your dataset or model hyperparameters accordingly.

内容的提问来源于stack exchange，提问作者Sayak Ghanta