Dingo MCP Server

Änderungsprotokoll

27.12.2024: Projektinitialisierung

Einführung

Dingo ist ein Tool zur Datenqualitätsbewertung, mit dem Sie Qualitätsprobleme in Ihren Datensätzen automatisch erkennen können. Dingo bietet eine Vielzahl integrierter Regeln und Modellbewertungsmethoden und unterstützt auch benutzerdefinierte Bewertungsmethoden. Dingo unterstützt häufig verwendete Textdatensätze und multimodale Datensätze, darunter Vortrainingsdatensätze, Feinabstimmungsdatensätze und Bewertungsdatensätze. Darüber hinaus unterstützt Dingo verschiedene Verwendungsmethoden, darunter lokale CLI und SDK, und erleichtert so die Integration in verschiedene Bewertungsplattformen wie OpenCompass .

Architekturdiagramm

Schnellstart

Installation

pip install dingo-python

Beispiel-Anwendungsfälle

1. Lokale Textdatei (Klartext) auswerten

from dingo.io import InputArgs
from dingo.exec import Executor

# Evaluate a plaintext file
input_data = {
    "eval_group": "sft",          # Rule set for SFT data
    "input_path": "data.txt",      # Path to local text file
    "dataset": "local",
    "data_format": "plaintext",    # Format: plaintext
    "save_data": True              # Save evaluation results
}

input_args = InputArgs(**input_data)
executor = Executor.exec_map["local"](input_args)
result = executor.execute()
print(result)

2. Bewerten Sie den Hugging Face-Datensatz

from dingo.io import InputArgs
from dingo.exec import Executor

# Evaluate a dataset from Hugging Face
input_data = {
    "eval_group": "sft",           # Rule set for SFT data
    "input_path": "tatsu-lab/alpaca", # Dataset from Hugging Face
    "data_format": "plaintext",    # Format: plaintext
    "save_data": True              # Save evaluation results
}

input_args = InputArgs(**input_data)
executor = Executor.exec_map["local"](input_args)
result = executor.execute()
print(result)

3. JSON/JSONL-Format auswerten

from dingo.io import InputArgs
from dingo.exec import Executor

# Evaluate a JSON file
input_data = {
    "eval_group": "default",       # Default rule set
    "input_path": "data.json",     # Path to local JSON file
    "dataset": "local",
    "data_format": "json",         # Format: json
    "column_content": "text",      # Column containing the text to evaluate
    "save_data": True              # Save evaluation results
}

input_args = InputArgs(**input_data)
executor = Executor.exec_map["local"](input_args)
result = executor.execute()
print(result)

4. LLM zur Auswertung verwenden

from dingo.io import InputArgs
from dingo.exec import Executor

# Evaluate using GPT model
input_data = {
    "input_path": "data.jsonl",    # Path to local JSONL file
    "dataset": "local",
    "data_format": "jsonl",
    "column_content": "content",
    "custom_config": {
        "prompt_list": ["PromptRepeat"],  # Prompt to use
        "llm_config": {
            "detect_text_quality": {
                "model": "gpt-4o",
                "key": "YOUR_API_KEY",
                "api_url": "https://api.openai.com/v1/chat/completions"
            }
        }
    }
}

input_args = InputArgs(**input_data)
executor = Executor.exec_map["local"](input_args)
result = executor.execute()
print(result)

Befehlszeilenschnittstelle

Auswerten mit Regelsätzen

python -m dingo.run.cli --input_path data.txt --dataset local -e sft --data_format plaintext --save_data True

Evaluieren mit LLM (zB GPT-4o)

python -m dingo.run.cli --input_path data.json --dataset local -e openai --data_format json --column_content text --custom_config config_gpt.json --save_data True

Beispiel config_gpt.json :

{
  "llm_config": {
    "openai": {
      "model": "gpt-4o",
      "key": "YOUR_API_KEY",
      "api_url": "https://api.openai.com/v1/chat/completions"
    }
  }
}

GUI-Visualisierung

Nach der Auswertung (mit save_data=True ) wird automatisch eine Frontend-Seite generiert. So starten Sie das Frontend manuell:

python -m dingo.run.vsl --input output_directory

Dabei enthält output_directory die Auswertungsergebnisse mit einer Datei summary.json .

Online-Demo

Probieren Sie Dingo in unserer Online-Demo aus: (Umarmungsgesicht)🤗

Datenqualitätsmetriken

Dingo klassifiziert Datenqualitätsprobleme in sieben Dimensionen von Qualitätsmetriken. Jede Dimension kann sowohl mit regelbasierten Methoden als auch mit LLM-basierten Eingabeaufforderungen ausgewertet werden:

Qualitätsmetrik	Beschreibung	Regelbeispiele	Beispiele für LLM-Eingabeaufforderungen
VOLLSTÄNDIGKEIT	Überprüft, ob Daten unvollständig sind oder fehlen	`RuleColonEnd` , `RuleContentNull`	Prüft, ob der Text abrupt mit einem Doppelpunkt oder Auslassungspunkten endet, ob Klammern nicht übereinstimmen oder ob wichtige Komponenten fehlen
WIRKSAMKEIT	Überprüft, ob die Daten aussagekräftig und richtig formatiert sind	`RuleAbnormalChar` , `RuleHtmlEntity` , `RuleSpecialCharacter`	Erkennt unleserlichen Text, Wörter, die ohne Leerzeichen aneinandergereiht sind, und Text ohne korrekte Zeichensetzung
FLÜSSIGKEIT	Überprüft, ob der Text grammatikalisch korrekt ist und sich natürlich liest	`RuleAbnormalNumber` , `RuleNoPunc` , `RuleWordStuck`	Identifiziert übermäßig lange Wörter, Textfragmente ohne Zeichensetzung oder Inhalte mit chaotischer Lesereihenfolge
RELEVANZ	Erkennt irrelevante Inhalte in den Daten	`RuleHeadWord` -Varianten für verschiedene Sprachen	Untersucht irrelevante Informationen wie Zitatdetails, Kopf-/Fußzeilen, Entitätsmarkierungen, HTML-Tags
SICHERHEIT	Identifiziert vertrauliche Informationen oder Wertekonflikte	`RuleIDCard` , `RuleUnsafeWords`	Überprüfung auf persönliche Informationen und Inhalte im Zusammenhang mit Glücksspiel, Pornografie und politischen Themen
ÄHNLICHKEIT	Erkennt sich wiederholende oder sehr ähnliche Inhalte	`RuleDocRepeat`	Prüft Text auf aufeinanderfolgende Wiederholungen oder mehrfaches Vorkommen von Sonderzeichen
VERSTÄNDLICHKEIT	Bewertet, wie einfach Daten interpretiert werden können	`RuleCapitalWords`	Stellt sicher, dass LaTeX-Formeln und Markdown korrekt formatiert sind, mit richtiger Segmentierung und Zeilenumbrüchen

LLM-Qualitätsbewertung

Dingo bietet verschiedene LLM-basierte Bewertungsmethoden, die durch Eingabeaufforderungen im Verzeichnis dingo/model/prompt definiert sind. Diese Eingabeaufforderungen werden mit dem Dekorator prompt_register registriert und können zur Qualitätsbewertung mit LLM-Modellen kombiniert werden:

Eingabeaufforderungen zur Bewertung der Textqualität

Eingabeaufforderungstyp	Metrisch	Beschreibung
`TEXT_QUALITY_V2` , `TEXT_QUALITY_V3`	Verschiedene Qualitätsdimensionen	Umfassende Bewertung der Textqualität hinsichtlich Effektivität, Relevanz, Vollständigkeit, Verständlichkeit, Ähnlichkeit, Flüssigkeit und Sicherheit
`QUALITY_BAD_EFFECTIVENESS`	Wirksamkeit	Erkennt verstümmelten Text und Anti-Crawling-Inhalte
`QUALITY_BAD_SIMILARITY`	Ähnlichkeit	Identifiziert Probleme mit Textwiederholungen
`WORD_STICK`	Flüssigkeit	Prüft auf Wörter, die ohne den richtigen Abstand aneinander kleben
`CODE_LIST_ISSUE`	Vollständigkeit	Bewertet Codeblöcke und listet Formatierungsprobleme auf
`UNREAD_ISSUE`	Wirksamkeit	Erkennt unlesbare Zeichen aufgrund von Kodierungsproblemen

3H-Beurteilungsaufforderungen (ehrlich, hilfreich, harmlos)

Eingabeaufforderungstyp	Metrisch	Beschreibung
`QUALITY_HONEST`	Ehrlichkeit	Bewertet, ob die Antworten genaue Informationen ohne Fälschung oder Täuschung liefern
`QUALITY_HELPFUL`	Hilfsbereitschaft	Bewertet, ob die Antworten direkt auf die Fragen eingehen und die Anweisungen angemessen befolgen
`QUALITY_HARMLESS`	Harmlosigkeit	Überprüft, ob Antworten schädliche Inhalte, diskriminierende Sprache und gefährliche Hilfe vermeiden

Domänenspezifische Bewertungsaufforderungen

Eingabeaufforderungstyp	Metrisch	Beschreibung
`TEXT_QUALITY_KAOTI`	Qualität der Prüfungsfragen	Spezialisiertes Assessment zur Beurteilung der Qualität von Prüfungsfragen mit Fokus auf Formeldarstellung, Tabellenformatierung, Absatzstruktur und Antwortformatierung
`Html_Abstract`	HTML-Extraktionsqualität	Vergleicht verschiedene Methoden zum Extrahieren von Markdown aus HTML und bewertet Vollständigkeit, Formatierungsgenauigkeit und semantische Kohärenz

Klassifizierungsaufforderungen

Eingabeaufforderungstyp	Metrisch	Beschreibung
`CLASSIFY_TOPIC`	Themenkategorisierung	Klassifiziert Text in Kategorien wie Sprachverarbeitung, Schreiben, Code, Mathematik, Rollenspiel oder Wissensfragen und -antworten
`CLASSIFY_QR`	Bildklassifizierung	Identifiziert Bilder als CAPTCHA, QR-Code oder normale Bilder

Eingabeaufforderungen zur Bildbewertung

Eingabeaufforderungstyp	Metrisch	Beschreibung
`IMAGE_RELEVANCE`	Bildrelevanz	Bewertet, ob ein Bild hinsichtlich der Anzahl der Gesichter, der Merkmalsdetails und der visuellen Elemente mit dem Referenzbild übereinstimmt

Verwendung der LLM-Bewertung bei der Bewertung

Um diese Bewertungsaufforderungen in Ihren Auswertungen zu verwenden, geben Sie sie in Ihrer Konfiguration an:

input_data = {
    # Other parameters...
    "custom_config": {
        "prompt_list": ["QUALITY_BAD_SIMILARITY"],  # Specific prompt to use
        "llm_config": {
            "detect_text_quality": {  # LLM model to use
                "model": "gpt-4o",
                "key": "YOUR_API_KEY",
                "api_url": "https://api.openai.com/v1/chat/completions"
            }
        }
    }
}

Sie können diese Eingabeaufforderungen individuell anpassen, um bestimmte Qualitätsdimensionen zu fokussieren oder an spezifische Domänenanforderungen anzupassen. In Kombination mit geeigneten LLM-Modellen ermöglichen diese Eingabeaufforderungen eine umfassende Bewertung der Datenqualität über mehrere Dimensionen hinweg.

Regelgruppen

Dingo bietet vorkonfigurierte Regelgruppen für verschiedene Arten von Datensätzen:

Gruppe	Anwendungsfall	Beispielregeln
`default`	Allgemeine Textqualität	`RuleColonEnd` , `RuleContentNull` , `RuleDocRepeat` usw.
`sft`	Feinabstimmung von Datensätzen	Regeln aus `default` plus `RuleLineStartWithBulletpoint`
`pretrain`	Vorabtraining von Datensätzen	Umfassender Satz mit über 20 Regeln, darunter `RuleAlphaWords` , `RuleCapitalWords` “ usw.

So verwenden Sie eine bestimmte Regelgruppe:

input_data = {
    "eval_group": "sft",  # Use "default", "sft", or "pretrain"
    # other parameters...
}

Funktionshighlights

Datenquellen : Lokale Dateien, Hugging Face-Datensätze, S3-Speicher
Datentypen : Datensätze für Vortraining, Feinabstimmung und Auswertung
Datenmodalitäten : Text und Bild

Regelbasierte und modellbasierte Auswertung

Integrierte Regeln : Über 20 allgemeine heuristische Bewertungsregeln
LLM-Integration : OpenAI, Kimi und lokale Modelle (z. B. Llama3)
Benutzerdefinierte Regeln : Einfache Erweiterung mit Ihren eigenen Regeln und Modellen
Sicherheitsbewertung : Perspective API-Integration

Flexible Nutzung

Schnittstellen : CLI- und SDK-Optionen
Integration : Einfache Integration mit anderen Plattformen
Ausführungs-Engines : Lokal und Spark

Umfassende Berichterstattung

Qualitätsmetriken : 7-dimensionale Qualitätsbewertung
Rückverfolgbarkeit : Detaillierte Berichte zur Anomalieverfolgung

Benutzerhandbuch

Benutzerdefinierte Regeln, Eingabeaufforderungen und Modelle

Wenn die integrierten Regeln Ihren Anforderungen nicht entsprechen, können Sie benutzerdefinierte Regeln erstellen:

Beispiel für eine benutzerdefinierte Regel

from dingo.model import Model
from dingo.model.rule.base import BaseRule
from dingo.config.config import DynamicRuleConfig
from dingo.io import MetaData
from dingo.model.modelres import ModelRes

@Model.rule_register('QUALITY_BAD_RELEVANCE', ['default'])
class MyCustomRule(BaseRule):
    """Check for custom pattern in text"""

    dynamic_config = DynamicRuleConfig(pattern=r'your_pattern_here')

    @classmethod
    def eval(cls, input_data: MetaData) -> ModelRes:
        res = ModelRes()
        # Your rule implementation here
        return res

Benutzerdefinierte LLM-Integration

from dingo.model import Model
from dingo.model.llm.base_openai import BaseOpenAI

@Model.llm_register('my_custom_model')
class MyCustomModel(BaseOpenAI):
    # Custom implementation here
    pass

Weitere Beispiele finden Sie in:

Ausführungs-Engines

Lokale Ausführung

from dingo.io import InputArgs
from dingo.exec import Executor

input_args = InputArgs(**input_data)
executor = Executor.exec_map["local"](input_args)
result = executor.execute()

# Get results
summary = executor.get_summary()        # Overall evaluation summary
bad_data = executor.get_bad_info_list() # List of problematic data
good_data = executor.get_good_info_list() # List of high-quality data

Spark-Ausführung

from dingo.io import InputArgs
from dingo.exec import Executor
from pyspark.sql import SparkSession

# Initialize Spark
spark = SparkSession.builder.appName("Dingo").getOrCreate()
spark_rdd = spark.sparkContext.parallelize([...])  # Your data as MetaData objects

input_args = InputArgs(eval_group="default", save_data=True)
executor = Executor.exec_map["spark"](input_args, spark_session=spark, spark_rdd=spark_rdd)
result = executor.execute()

Evaluierungsberichte

Nach der Auswertung generiert Dingo:

Zusammenfassender Bericht ( summary.json ): Gesamtmetriken und Bewertungen
Detaillierte Berichte : Spezifische Probleme für jeden Regelverstoß

Beispielzusammenfassung:

{
    "task_id": "d6c922ec-981c-11ef-b723-7c10c9512fac",
    "task_name": "dingo",
    "eval_group": "default",
    "input_path": "test/data/test_local_jsonl.jsonl",
    "output_path": "outputs/d6c921ac-981c-11ef-b723-7c10c9512fac",
    "create_time": "20241101_144510",
    "score": 50.0,
    "num_good": 1,
    "num_bad": 1,
    "total": 2,
    "type_ratio": {
        "QUALITY_BAD_COMPLETENESS": 0.5,
        "QUALITY_BAD_RELEVANCE": 0.5
    },
    "name_ratio": {
        "QUALITY_BAD_COMPLETENESS-RuleColonEnd": 0.5,
        "QUALITY_BAD_RELEVANCE-RuleSpecialCharacter": 0.5
    }
}

Zukunftspläne

[ ] Umfangreichere grafische und textuelle Bewertungsindikatoren
[ ] Auswertung der Audio- und Videodatenmodalität
[ ] Kleine Modellbewertung (Fasttext, Qurating)
[ ] Bewertung der Datenvielfalt

Einschränkungen

Die aktuell integrierten Erkennungsregeln und Modellmethoden konzentrieren sich auf häufige Datenqualitätsprobleme. Für spezielle Auswertungsanforderungen empfehlen wir die Anpassung der Erkennungsregeln.

Danksagung

Beitrag

Wir danken allen Mitwirkenden für ihre Bemühungen, Dingo zu verbessern und zu erweitern. Weitere Informationen zur Mitarbeit am Projekt finden Sie im Beitragsleitfaden .

Lizenz

Dieses Projekt verwendet die Apache 2.0 Open Source-Lizenz .

Zitat

Wenn Sie dieses Projekt nützlich finden, denken Sie bitte darüber nach, unser Tool zu zitieren:

@misc{dingo,
  title={Dingo: A Comprehensive Data Quality Evaluation Tool for Large Models},
  author={Dingo Contributors},
  howpublished={\url{https://github.com/DataEval/dingo}},
  year={2024}
}

Integrations