File size: 3,211 Bytes
0ffab8d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 |
# NER Customer Support Model
This project builds and utilizes a Named Entity Recognition (NER) model tailored for customer support interactions. The model uses BERT and focuses on identifying customer-specific entities such as complaints, product names, and appointment information.
## Introduction
The goal of this NER model is to improve customer support interactions by recognizing specific entities from customer queries. This enables automated systems to efficiently interpret and route customer queries based on recognized entities.
## Requirements
This project requires Python 3.7.4 and specific libraries listed in the `requirements.txt` file. Notable dependencies include:
- BERT (using the Transformers library)
- PyTorch for model training and inference
- seqeval for NER evaluation
- pandas and numpy for data handling
## Setup
1. **Clone the repository and install dependencies**:
```bash
pip install -r requirements.txt
```
2. **Download Pre-trained BERT model**:
Ensure you have a trained BERT model for token classification saved with configuration and weights. The model components should be available as separate files, such as `config.json`, `pytorch_model.bin`, and `vocab.txt`.
## Usage
1. **Load the Model and Tokenizer**:
Specify the paths to the configuration, model weights, and tokenizer files:
```python
from transformers import BertForTokenClassification, BertConfig, BertTokenizer
import torch
# Specify paths
config_path = "path/to/config.json"
model_weights_path = "path/to/pytorch_model.bin"
vocab_path = "path/to/vocab.txt"
# Load config and model
config = BertConfig.from_json_file(config_path)
model = BertForTokenClassification(config)
model.load_state_dict(torch.load(model_weights_path, map_location=torch.device('cpu')))
# Load tokenizer
tokenizer = BertTokenizer.from_pretrained(vocab_path)
# Set device
device = torch.device('cpu')
model.to(device)
```
2. **Tag a Sentence**:
After loading the model, pass a sentence to be tagged for entities:
```python
sentence = "Your sample customer query here."
# Tokenize and prepare inputs
inputs = tokenizer(sentence, return_tensors="pt", truncation=True, padding=True)
inputs = {key: val.to(device) for key, val in inputs.items()}
# Predict tags
with torch.no_grad():
outputs = model(**inputs)
logits = outputs.logits
# Convert predictions to tags
predictions = torch.argmax(logits, dim=-1).cpu().numpy()
tags = [config.id2label[label] for label in predictions[0]]
print("Tokens:", tokenizer.tokenize(sentence))
print("Tags:", tags)
```
## Results
The model will output tokens and their corresponding tags for the provided sentence, allowing you to see which entities were recognized.
## File Structure
- `NER_Customer_final.ipynb`: The main notebook containing data preprocessing, model training, and evaluation.
- `requirements.txt`: Lists required libraries.
- `README.md`: This file.
## Additional Notes
Ensure that GPU support is enabled if available to speed up processing. The code is set to use CPU by default:
```python
device = torch.device('cpu')
model.to(device)
```
|