[JAVA] Essayez d'utiliser GloVe avec Deeplearning4j

Je vais utiliser GloVe avec Deeplearning4j, une bibliothèque Java.

supposition

Corpus

Veuillez préparer à l'avance le corpus que vous souhaitez apprendre. Dans le cas d'un corpus japonais, notez-le. Il peut être préférable de corriger les verbes etc. à la forme de base (forme originale) lors de l'écriture dans la forme.

Apprentissage

Le fichier texte du corpus doit être ** input.txt **. Enregistrez le modèle créé sous ** model.txt **.

ModelBuild.java


import org.deeplearning4j.models.embeddings.loader.WordVectorSerializer;
import org.deeplearning4j.models.glove.Glove;
import org.deeplearning4j.text.sentenceiterator.BasicLineIterator;
import org.deeplearning4j.text.sentenceiterator.SentenceIterator;
import org.deeplearning4j.text.tokenization.tokenizer.preprocessor.CommonPreprocessor;
import org.deeplearning4j.text.tokenization.tokenizerfactory.DefaultTokenizerFactory;
import org.deeplearning4j.text.tokenization.tokenizerfactory.TokenizerFactory;

import java.io.*;

public class ModelBuild {
    public static void main( String[] args ) throws Exception{
    	
     	//Lire le fichier corpus
    	System.out.println("Chargement des données...");
        File inputFile = new File("input.txt");
    	
        //Lire comme classe de données texte
        SentenceIterator iter = new BasicLineIterator(inputFile);
        
        //Créer une classe tokenizer (word split)
        System.out.println("Créer un tokenizer...");
        TokenizerFactory t = new DefaultTokenizerFactory();
        t.setTokenPreProcessor(new CommonPreprocessor());
        
        //Créer un modèle
        System.out.println("Créer un modèle...");
        Glove glove = new Glove.Builder()
        		.iterate(iter) //Classe de données de phrase
        		.tokenizerFactory(t) //Classe de décomposition de mots
        		.alpha(0.75) //Paramètres dans l'exposant de la fonction de pondération
        		.learningRate(0.1) //Taux d'apprentissage initial
        		.epochs(25) //Nombre d'itérations sur le corpus de formation pendant la formation
        		.layerSize(300) //Nombre de dimensions du vecteur
        		.maxMemory(2) //Utilisation maximale de la mémoire
        		.xMax(100) //Coupure de la fonction de poids
        		.batchSize(1000) //Nombre de mots à apprendre dans un mini-lot
        		.windowSize(10) //La taille de la fenêtre
        		.shuffle(true)
        		.symmetric(true)
        		.build();
        
        //Apprentissage
        System.out.println("J'apprends...");
        glove.fit();
        
        //Enregistrer le modèle
        System.out.println("Sauvegarder le modèle...");
        WordVectorSerializer.writeWordVectors(glove, "model.txt");
        
        System.out.println("Le programme est terminé");
    }
}

Évaluation

Evaluation.java


import java.io.File;
import java.io.FileNotFoundException;
import java.io.UnsupportedEncodingException;
import java.util.Collection;

import org.deeplearning4j.models.embeddings.loader.WordVectorSerializer;
import org.deeplearning4j.models.embeddings.wordvectors.WordVectors;

public class Evaluation {

	public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
		//Charger le fichier de modèle
    	System.out.println("Chargement du fichier de modèle...");
    	File inputFile = new File(args[0]);
    	WordVectors vec = WordVectorSerializer.loadTxtVectors(inputFile);
    	
    	//Afficher les 10 principaux mots similaires pour le mot (par exemple, «météo»)
    	System.out.println("Top 10 des mots similaires...");
    	String  word        = "Météo";
        int     ranking     = 10;
        Collection<String>  similarTop10    = vec.wordsNearest( word , ranking );
        System.out.println( String.format( "Similar word to 「%s」 is %s" , word , similarTop10 ) );
        
        //Afficher la similitude cosinus (par exemple "ensoleillé" et "pluie")
        System.out.println( "Afficher la similitude cosinus..." );
        String  word1       = "Ensoleillé";
        String  word2       = "pluie";
        double  similarity  = vec.similarity( word1 , word2 );
        System.out.println( String.format( "The similarity between 「%s」 and 「%s」 is %f" , word1 , word2 , similarity ) );
	}
}

La page à laquelle j'ai fait référence au code

Recommended Posts

Essayez d'utiliser GloVe avec Deeplearning4j
Essayez d'utiliser Redis avec Java (jar)
Essayez d'utiliser libGDX
Essayez d'utiliser Maven
Essayez d'utiliser powermock-mockito2-2.0.2
Essayez d'utiliser GraalVM
Essayez d'utiliser jmockit 1.48
Essayez d'utiliser Spring Boot avec VS Code
Essayez d'utiliser SwiftLint
Essayez d'utiliser Log4j 2.0
Essayez d'utiliser la télécommande Wii en Java
Essayez d'utiliser le kit de récepteur GPS avec Raspberry Pi 3 (Ruby)
Essayez d'utiliser S3Proxy avec Microsoft Azure Blob Storage
Essayez d'utiliser un autre conteneur de servlet Jetty avec Docker
Essayez DI avec Micronaut
Essayez d'utiliser le Framework Axon
Essayez de créer avec Trailblazer
Essayez d'utiliser l'API REST de JobScheduler
Essayez d'utiliser la méthode java.lang.Math
Essayez d'utiliser la WhiteBox de PowerMock
Utiliser la paire avec OpenJDK
Essayez WebSocket avec jooby
Essayez d'utiliser Talend Part 2
Essayez d'utiliser Talend Part 1
Essayez d'utiliser la liste F #
Essayez d'utiliser la méthode each_with_index
Essayez d'utiliser Spring JDBC
Essayez d'utiliser un conteneur DI avec Laravel et Spring Boot
Essayez d'utiliser OpenID Connect avec Keycloak (application Spring Boot)
Essayez de travailler avec Keycloak en utilisant Spring Security SAML (Spring 5)
Essayez d'utiliser RocksDB avec Java
Essayez la connexion DB avec Java
Essayez de gratter en utilisant Java [Note]
Essayez d'utiliser Cocoa de Ruby
Essayez gRPC avec Java, Maven
Japaneseize en utilisant i18n avec Rails
Utilisation de Mapper avec Java (Spring)
Essayez d'utiliser IntelliJ IDEA car vous ne devez le faire qu'une seule fois
Essayez de lire XML avec JDOM
Essayez d'utiliser Spring Boot Security
[Rails] Essayez d'utiliser le middleware de Faraday
[Traitement] Essayez d'utiliser GT Force.
[Programmation complète] §2 Essayez d'utiliser Ruby
Utilisation de PlantUml avec Honkit [Docker]
Essayez de faire fonctionner la base de données de documents en utilisant X DevAPI avec MySQL Connector / J 8.0.15
Partie 1: Essayez d'utiliser la connexion OAuth 2.0 prise en charge par Spring Security 5 avec Spring Boot
Compression de dossier avec Scala. Utilisation de java.util.zip.ZipOutputStream.
Essayez Redmine sur le docker Mac
J'ai essayé d'utiliser JOOQ avec Gradle
Essayez d'exécuter cloudera manager avec docker
Essayez d'implémenter recaptcha avec Jetty intégré.
Essayez de manipuler les tableaux PostgreSQL avec JDBC