Le modèle UIE par défaut utilisé pour l'étiquetage automatique dans doccano peut identifier certaines entités, mais il est insuffisant dans des domaines spécifiques ou lorsque les catégories d'entités ne sont pas clairement comprises. Pour répondre aux besoins d'étiquetage automatique (Auto Labeling), nous pouvons ajuster le modèle en utilisant les données annotées.

Prétraitement des données étiquetées dans doccano

Cette section explique comment convertir les données exportées de la plateforme doccano en ensembles d'entraînement, de validation et de test via un script doccano.py.

Déploiement local du modèle UIE

Téléchargez le package compressé du modèle :

PaddleNLP-model_zoo.zip - Lien direct depuis un service de stockage.

Conversion des données pour les tâches d'extraction

• Après avoir annoté les données, exportez un fichier au format JSONL(relation) depuis doccano et renommez-le en doccano_ext.json. Placez ce fichier dans le répertoire ./data.
• Utilisez le script doccano.py pour transformer les données afin de préparer l'entraînement du modèle.

python doccano.py \
    --doccano_file ./data/doccano_ext.json \
    --task_type "ext" \
    --save_dir ./data \
    --negative_ratio 5

Vous pouvez également sauvegarder cette commande dans un fichier shell comme tran.sh.

Entraînement du modèle UIE

Utilisez les données annotées pour entraîner un modèle avec des échanitllons limités. Les paramètres du modèle seront enregistrés dans le répertoire ./checkpoint/.

Conseils :

• Il est recommandé d'utiliser un enviornnement GPU pour éviter les débordements mémoire.
• Si vous utilisez un processeur CPU, envisagez de choisir un modèle plus léger tel que uie-tiny et ajustez le batch size en conséquence.

Pour augmenter la précision : ajustez l'option --num_epochs pour effectuer plus d'entraînements.

Paramètres configurables :

• model_name_or_path : Modèle pré-entraîné requis pour l'apprentissage Few-Shot. Options disponibles : "uie-base", "uie-medium", etc.
• multilingual : Indique si le modèle est multilingue. Définissez à True si vous utilisez "uie-m-base" ou "uie-m-large".
• output_dir : Répertoire où sauvegarder le modèle après l'entraînement.
• device : Appareil d'entraînement ("cpu", "gpu", "npu").
• per_device_train_batch_size et per_device_eval_batch_size : Taille du lot pour l'entraînement et l'évaluation.
• learning_rate : Taux d'apprentissage maximal recommandé à 1e-5.
• num_train_epochs : Nombre d'époques d'entraînement.
• seed : Graine aléatoire globale.
• do_train et do_eval : Activer ou désactiver l'entraînement et l'évaluation.

Commande d'ajustement :

export finetuned_model=./checkpoint/model_best

python finetune.py \
    --device gpu \
    --logging_steps 10 \
    --save_steps 100 \
    --eval_steps 100 \
    --seed 42 \
    --model_name_or_path uie-base \
    --output_dir $finetuned_model \
    --train_path ./data/train.txt \
    --dev_path ./data/dev.txt \
    --max_seq_length 512 \
    --per_device_eval_batch_size 16 \
    --per_device_train_batch_size 16 \
    --num_train_epochs 20 \
    --learning_rate 1e-5 \
    --label_names "start_positions" "end_positions" \
    --do_train \
    --do_eval \
    --do_export \
    --export_model_dir $finetuned_model \
    --overwrite_output_dir \
    --disable_tqdm True \
    --metric_for_best_model eval_f1 \
    --load_best_model_at_end True \
    --save_total_limit 1

Évaluation du modèle UIE

Exécutez la commande suivante pour évaluer le modèle :

python evaluate.py \
    --model_path ./checkpoint/model_best \
    --test_path ./data/dev.txt \
    --batch_size 16 \
    --max_seq_len 512

La précision obtenue sur les données annotées manuellement est de 88 %.

Déploiement du modèle UIE ajusté

Prédiction locale avec modèle personnalisé

Chargez le modèle personnalisé via paddlenlp.Taskflow en spécifiant le chemin vers les poids du modèle.

from pprint import pprint
from paddlenlp import Taskflow

schema = ['Départ', 'Arrivée', 'Coût', 'Heure']  # Adapter selon vos entités
my_ie = Taskflow("information_extraction", schema=schema, task_path='./checkpoint/model_best')
pprint(my_ie("Frais de transport urbain le 5 juillet montant 114 Guangzhou vers Foshan"))

Déploiement rapide du modèle

Pour intégrer le modèle ajusté dans une application Flask :

from flask import Flask, request, jsonify
from paddlenlp import Taskflow

app = Flask(__name__)

schema = ['Départ', 'Arrivée', 'Coût', 'Heure']

ie = Taskflow('information_extraction', schema=schema, device_id=0, task_path='./uie/checkpoint/model_best')

def convert(result):
    result = result[0]
    formatted_result = []
    for label, ents in result.items():
        for ent in ents:
            formatted_result.append(
                {
                    "label": label,
                    "start_offset": ent['start'],
                    "end_offset": ent['end']
                })
    return formatted_result

@app.route('/', methods=['POST'])
def get_result():
    text = request.json['text']
    result = ie(text)
    formatted_result = convert(result)
    return jsonify(formatted_result)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=88)