nlprule

nlprule

Une bibliothèque de traitement du langage naturel et de correction des erreurs rapides et à faible ressource, écrite en rouille. NLPRULE implémente une approche basée sur la règle et la recherche de la PNL en utilisant des ressources de LanguageTool.

Utilisation python

Installer: pip install nlprule

Utiliser:

 from nlprule import Tokenizer , Rules

tokenizer = Tokenizer . load ( "en" )
rules = Rules . load ( "en" , tokenizer )

 rules . correct ( "He wants that you send him an email." )
# returns: 'He wants you to send him an email.'

rules . correct ( "I can due his homework." )
# returns: 'I can do his homework.'

for s in rules . suggest ( "She was not been here since Monday." ):
    print ( s . start , s . end , s . replacements , s . source , s . message )
# prints:
# 4 16 ['was not', 'has not been'] WAS_BEEN.1 Did you mean was not or has not been? 

 for sentence in tokenizer . pipe ( "A brief example is shown." ):
    for token in sentence :
        print (
            repr ( token . text ). ljust ( 10 ),
            repr ( token . span ). ljust ( 10 ),
            repr ( token . tags ). ljust ( 24 ),
            repr ( token . lemmas ). ljust ( 24 ),
            repr ( token . chunks ). ljust ( 24 ),
        )
# prints:
# 'A'        (0, 1)     ['DT']                   ['A', 'a']               ['B-NP-singular']       
# 'brief'    (2, 7)     ['JJ']                   ['brief']                ['I-NP-singular']       
# 'example'  (8, 15)    ['NN:UN']                ['example']              ['E-NP-singular']       
# 'is'       (16, 18)   ['VBZ']                  ['be', 'is']             ['B-VP']                
# 'shown'    (19, 24)   ['VBN']                  ['show', 'shown']        ['I-VP']                
# '.'        (24, 25)   ['.', 'PCT', 'SENT_END'] ['.']                    ['O']

Utilisation de la rouille

Configuration recommandée:

Cargo.toml

[ dependencies ]
nlprule = " <version> "

[ build-dependencies ]
nlprule-build = " <version> " # must be the same as the nlprule version!

build.rs

 fn main ( ) -> Result < ( ) , nlprule_build :: Error > {
    println ! ( "cargo:rerun-if-changed=build.rs" ) ;

    nlprule_build :: BinaryBuilder :: new (
        & [ "en" ] ,
        std :: env :: var ( "OUT_DIR" ) . expect ( "OUT_DIR is set when build.rs is running" ) ,
    )
    . build ( ) ?
    . validate ( )
}

src/main.rs

 use nlprule :: { Rules , Tokenizer , tokenizer_filename , rules_filename } ;

fn main ( ) {
    let mut tokenizer_bytes : & ' static [ u8 ] = include_bytes ! ( concat! (
        env! ( "OUT_DIR" ) ,
        "/" ,
        tokenizer_filename! ( "en" )
    ) ) ;
    let mut rules_bytes : & ' static [ u8 ] = include_bytes ! ( concat! (
        env! ( "OUT_DIR" ) ,
        "/" ,
        rules_filename! ( "en" )
    ) ) ;

    let tokenizer = Tokenizer :: from_reader ( & mut tokenizer_bytes ) . expect ( "tokenizer binary is valid" ) ;
    let rules = Rules :: from_reader ( & mut rules_bytes ) . expect ( "rules binary is valid" ) ;

    assert_eq ! (
        rules . correct ( "She was not been here since Monday." , & tokenizer ) ,
        String :: from ( "She was not here since Monday." )
    ) ;
}

Les versions nlprule et nlprule-build sont maintenues en synchronisation.

Caractéristiques principales

• Correction d'erreur grammaticale basée sur des règles à travers plusieurs mille règles.
• Un pipeline de traitement de texte faisant la segmentation des phrases, le marquage d'une partie du discours, la lemmatisation, le morceau et la désambiguïsation.
• Support pour l'anglais, l'allemand et l'espagnol.
• Vérification orthographique. ( en cours )

Objectifs

• Un seul endroit pour appliquer la correction d'erreur orthographique et grammaticale pour une tâche en aval.
• NLP rapide et à faible ressource adaptée à la course:
  1. En tant qu'étape de pré- / post-traitement pour des approches plus sophistiquées (c'est-à-dire ML).
  2. à l'arrière-plan d'une autre application avec des frais généraux faibles.
  3. côté client dans le navigateur via WebAssembly.
• 100% Code de rouille et dépendances.

Comparaison avec Languagetool

	| Règles de désambiguïsation |	| Règles de grammaire |	Version LT	temps nlprule	Temps de langage
Anglais	843 (100%)	3725 (~ 85%)	5.2	1	1.7 - 2.0
Allemand	486 (100%)	2970 (~ 90%)	5.2	1	2.4 - 2.8
Espagnol	Support expérimental. Pas encore complètement testé.

Voir le problème de référence pour plus de détails.

Projets utilisant NLPRULE

• PROSEMD: un serveur de langage de relecture et de libellur pour les fichiers de marque avec l'intégration VScode.
• Cargo-SpellCheck: Un outil pour vérifier toutes vos documents de rouille pour l'orthographe et les erreurs de grammaire.

Veuillez soumettre un RP pour ajouter votre projet!

Remerciements

Tout crédit pour les ressources utilisées dans NLPRULE va à Languagetool qui a fait un effort herculéen pour créer des ressources de haute qualité pour la correction d'erreur grammaticale et la PNL plus large.

Licence

NLPRULE est sous licence sous la licence MIT ou la licence Apache-2.0, à votre option.

Les binaires NLPRULE ( *.bin ) sont dérivés de Languagetool V5.2 et sous licence LGPLV2.1. NLPRULE est lié statiquement et dynamiquement à ces binaires. En vertu de LGPLV2.1 §6 (a), cela n'a aucune implication sur la licence de NLPRULE elle-même.