introduction

Bonjour, c'est de l'eau Sumiyama.

J'écrirai la suite de la précédente [Introduction à l'informatique n ° 0: Essayez l'apprentissage automatique] Implémentons la méthode k Average en Java.

Dans le dernier article, j'ai présenté ce que vous pouvez enfin faire avec le clustering.

Aujourd'hui dans la partie 1, je vais expliquer et implémenter le concept de "coordonnées" pour exprimer la position de ce point sous forme de données numériques [^ 1].

environnement

IntelliJ IDEA
Java12 + SpringBoot 2.1.6
JUnit5

J'ai écrit sur la préparation de cet environnement dans cet article. Notes lors du démarrage d'un nouveau développement avec IntelliJ + Gradle + SpringBoot + JUnit5 (jupiter)

Représentation numérique de la cible d'analyse

Comme je l'ai mentionné dans 0th, l'objectif du clustering est "le temps d'accès au site Web et le temps de séjour" ou "la date d'utilisation de la carte de crédit et le montant d'utilisation". Ce sont des données numériques qui existent dans la vie réelle telles que.

Cependant, lors de l'apprentissage de la technique du clustering, il est plus facile de comprendre le concept s'il est une fois abstrait et décidé d'être une position sur un plan ou un solide, donc je vais poursuivre la discussion avec "ce genre de chose".

Position des points sur le plan (2D)

Mis à part l'histoire difficile, veuillez voir la figure. Comme le montre la figure, un point placé 0,8 dans la direction horizontale et 0,9 dans la direction verticale est exprimé par [0,8, 0,9]. Cela s'appellera la position **.

Maintenant, ce point correctement placé peut être traité comme des données avec la valeur numérique [0.8,0.9].

Considérez la position sur le solide (3D) pour le moment

Devons-nous l'élargir un peu plus?

Comme le montre la figure, si vous placez des points de manière appropriée dans un solide tridimensionnel, on suppose que la position est 0,8 horizontale, 0,9 verticale et 1,2 haute. Ensuite, ce point peut être exprimé par [0,8, 0,9, 1,2].

Si vous en avez envie, vous pouvez l'exprimer numériquement comme [0.8, 0.9, 1.2, 1.7, 0.1] que ce soit 4 dimensions ou 10 dimensions, mais jusqu'à présent, il peut être dessiné avec une figure qui peut être comprise par l'œil humain. Puisque la 3ème dimension est au mieux, ne faites pas de chiffre ...

Implémentons

Je n'ai touché Java que récemment, donc je vais l'implémenter en Java.

Pour le moment, à chaque fois que l'axe passe en 2D, 3D, 4D

[0.8,0.9]
[0.8,0.9,1.2]
[0.8,0.9,1.2,1.7]

Étant donné que le type de données est "valeur numérique" et "plusieurs nombres sont détenus", je pense que la liste de type double est bonne pour la position d'un point.

Ainsi, comme je l'ai écrit dans 0th, plusieurs points sont finalement traités, il y a donc plusieurs doubles listes. alors,

    private final List<List<Double>> points;

Si vous créez une classe avec un tel champ, vous pouvez exprimer «données à analyser» dans la classe.

Après cela, rendons possible le stockage des données dans le constructeur.

Je me demande si les conditions de stockage des données seront comme ça

--Il est impossible d'avancer null, donc si null est inclus dans le type Double, Exception --La position ne peut pas être nulle, donc si List contient null, ce sera une exception.

Veuillez gérer à l'appelant si gluant se produit au moment du constructeur ――Parce que les points de dimensions différentes telles que le plan et le solide ne doivent pas coexister, si les données 2D et les données 3D sont mélangées, c'est-à-dire si des données de différentes tailles de List sont mélangées, Exception

Donc, si vous implémentez ceci

package net.tan3sugarless.clusteringsample.lib.data;

import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import lombok.Value;
import net.tan3sugarless.clusteringsample.exception.DimensionNotUnifiedException;
import net.tan3sugarless.clusteringsample.exception.NullCoordinateException;

import java.util.List;

/**
 *Coordonnées définies sur l'espace de distance euclidien
 */
@Getter
@ToString
@EqualsAndHashCode
@Value
public class EuclideanSpace {

    private final List<List<Double>> points;

    /**
     *Définir une liste de coordonnées à n dimensions
     *
     * DimensionNotUnifiedException
     *J'ai défini une liste où les dimensions des coordonnées ne sont pas unifiées
     *
     * NullCoordinateException
     *La valeur numérique de la coordonnée contenait null
     *
     * NullPointerException
     *Données nulles transmises ou données contenant des éléments nuls
     *
     * @param points :Liste des coordonnées à n dimensions
     */
    public EuclideanSpace(List<List<Double>> points){
        if(points.stream().mapToInt(List::size).distinct().count()>1){
            throw new DimensionNotUnifiedException();
        }
        if(points.stream().anyMatch(point -> point.stream().anyMatch(x -> x == null))){
            throw new NullCoordinateException();
        }

        this.points = points;
    }
}

J'ai défini l'exception par moi-même.

Soudain, le terme «euclidien» apparaît, mais si vous commencez à dire quelque chose comme l'espace, l'histoire déraillera, alors veuillez la lire.

Je vais donc également écrire un test pour le constructeur.

package net.tan3sugarless.clusteringsample.lib.data;

import net.tan3sugarless.clusteringsample.exception.DimensionNotUnifiedException;
import net.tan3sugarless.clusteringsample.exception.NullCoordinateException;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

public class EuclideanSpaceTest {

    //Nul entier,Ciel,1 élément,Éléments multiples
    //Chaque élément contient null,Y compris le ciel,Tout est vide(0 dimension),1 dimension,n dimensions
    //Inclut les coordonnées nulles dans chaque élément,Y compris 0,Ne contient pas de valeur nulle
    //Contrôle des dimensions Tous de la même dimension,Différentes dimensions
    static Stream<Arguments> testConstructorProvider(){
        return Stream.of(
            Arguments.of(null,new NullPointerException()),
            Arguments.of(Collections.emptyList(),null),
            Arguments.of(Arrays.asList(Arrays.asList(1.5,-2.1)),null),
            Arguments.of(Arrays.asList(Arrays.asList(1.2,0.1),Arrays.asList(0.0,1.5)),null),
            Arguments.of(Arrays.asList(null,Arrays.asList(0,1.5),Arrays.asList(-0.9,0.1)),new NullPointerException()),
            Arguments.of(Arrays.asList(Arrays.asList(-0.9,0.1),Arrays.asList(0.0,1.5),Collections.emptyList()),new DimensionNotUnifiedException()),
            Arguments.of(Arrays.asList(Collections.emptyList(),Collections.emptyList(),Collections.emptyList()),null),
            Arguments.of(Arrays.asList(Arrays.asList(1.5),Arrays.asList(0.0),Arrays.asList(-2.2)),null),
            Arguments.of(Arrays.asList(Arrays.asList(1.5,2.2,-1.9),Arrays.asList(0.0,0.0,0.0),Arrays.asList(0.9,5.0,2.2)),null),
            Arguments.of(Arrays.asList(Arrays.asList(1.5,null,-1.9),Arrays.asList(0.0,0.0,0.0),Arrays.asList(0.9,5.0,2.2)),new NullCoordinateException()),
            Arguments.of(Arrays.asList(Arrays.asList(1.5,2.1,-1.9),Arrays.asList(0.0,0.0),Arrays.asList(0.9,5.0,2.2)),new DimensionNotUnifiedException()),
            Arguments.of(Arrays.asList(Arrays.asList(2.1,-1.9),Arrays.asList(0,0,0),Arrays.asList(0.9,5.0,2.2)),new DimensionNotUnifiedException())

        );
    }

    @ParameterizedTest
    @MethodSource("testConstructorProvider")
    @DisplayName("Tester le constructeur")
    void testConstructor(List<List<Double>> points, RuntimeException e){
        if(e==null){
            Assertions.assertDoesNotThrow(()->new EuclideanSpace(points));
        }else{
            Assertions.assertThrows(e.getClass(),()->new EuclideanSpace(points));
        }
    }
}

Vous pouvez maintenant représenter "un ensemble de points dans n'importe quelle dimension" dans une classe Java.

Le code que j'ai écrit ici se trouve sur GitHub.

https://github.com/tan3nonsugar/clusteringsample/tree/v0.0.1

Peut-être que je vais jouer avec la classe après ça, alors je l'ai laissé dans Tag

La prochaine fois, j'expliquerai comment exprimer "jusqu'où sont les points" en Java.

La prochaine fois! Merci d'avoir lu jusqu'ici.

la prochaine fois [Introduction à l'informatique, partie 2: Essayons l'apprentissage automatique] Implémentons la méthode de calcul de la moyenne k dans Java-Distance entre les données-

[^ 1]: En fait, l'ordre est inversé (seules les données numériques sont exprimées dans un espace bidimensionnel pour qu'il soit facile à comprendre), mais veuillez pardonner qu'il manque de rigueur en raison de l'accent mis sur la clarté.