introduction

Bonjour, c'est de l'eau Sumiyama.

Suite de la session précédente. [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-

Si vous êtes ravi de vous rencontrer, jetez un œil depuis le début de la série. [Introduction à l'informatique n ° 0: Essayez l'apprentissage automatique] Implémentons la méthode k Average en Java

Cette fois, je parlerai de l'idée de "centre de l'ensemble de données".

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)

Chose que tu veux faire

Je parlerai de "Pourquoi avez-vous besoin d'une telle façon de penser?" Un peu plus tôt, mais je parlerai de ce que je veux pouvoir faire.

Il est plus rapide de voir la figure que de l'expliquer avec des mots, alors voyez ici.

S'il y a plusieurs données comme des points bleus comme celui-ci, où se trouve le centre de ce groupe? Je voudrais définir.

0th J'en ai aussi parlé, mais les humains peuvent juger qu'il s'agit "de ce domaine", mais il est calculé numériquement sur l'ordinateur. Je dois donner une définition pour pouvoir le faire.

Comment calculer le centre

Cela fait longtemps que je me suis confiée, mais j'utiliserai ici la ** moyenne arithmétique (moyenne supplémentaire) ** familière au quotidien. [^ 1]

C'est celui utilisé pour le "score moyen en mathématiques". C'est le total de tous les membres et divisé par le nombre de personnes.

Nom complet	Score en mathématiques
Monsieur A	70 points
Monsieur B	60 points
Monsieur C	90 points
M. D	50 points

Dans ce cas, le score moyen est

(70+60+90+50)/4 = 67.5

En d'autres termes, ce sera 67,5 points.

Nous appliquerons cette idée aux valeurs numériques des coordonnées. Cela ressemble à la figure lorsqu'on l'examine avec des données bidimensionnelles. La moyenne des nombres dans les directions horizontale et verticale est la "coordonnée centrale".

Je vais le mettre en œuvre

J'ai ajouté la méthode getCentroid aux classes que j'ai créées jusqu'à présent.

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 net.tan3sugarless.clusteringsample.exception.UnexpectedCentroidException;

import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

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

    private final List<List<Double>> points;
    private final int dimension;

    //
    //～～ Omis ～～
    //

    /**
     *Trouvez les coordonnées qui sont les points centraux de chaque point appartenant à l'instance
     * <p>
     *Le centre est la moyenne arithmétique
     *
     * <pre>
     *N ° i dans un espace à n dimensions,(x11+x21+....+xm1)/m,Soit xij le jème élément du point oculaire,*
     * [x11, x12,...,x1n],[x21, x22,...,x2n]
     *Et m points sont donnés, les coordonnées du point central sont
     *
     * [(x11+x21+....+xm1)/m,(x12+x22+....+xm2)/m,...,(x1n+x2n+....+xmn)/m]
     *Sera.
     *
     *Faites le calcul.
     * </pre>
     *
     * @retour coordonnées du point central
     * @jette UnexpectedCentroidException Fondamentalement impossible
     */
    public List<Double> getCentroid() {
        return IntStream
                .range(0, dimension)
                .boxed()
                .map(i -> points.stream().mapToDouble(point -> point.get(i)).average().orElseThrow(UnexpectedCentroidException::new))
                .collect(Collectors.toList());
    }
}

Et tester


    /**
     * points :0 dimension/2D x 3 éléments
     */
    static Stream<Arguments> testGetCentroidProvider() {
        return Stream.of(
                //@formatter:off
                Arguments.of(Collections.emptyList(), Collections.emptyList()),
                Arguments.of(asList(Collections.emptyList(), Collections.emptyList(), Collections.emptyList()), Collections.emptyList()),
                Arguments.of(asList(asList(2.0, -4.0), asList(1.0, 0.0), asList(6.0, 1.0)), asList(3.0, -1.0))
                //@formatter:on
        );
    }

    @ParameterizedTest
    @MethodSource("testGetCentroidProvider")
    @DisplayName("Test de calcul du centre")
    void testGetCentroid(List<List<Double>> points, List<Double> centroid) {
        EuclideanSpace space = new EuclideanSpace(points);

        Assertions.assertEquals(centroid, space.getCentroid());
    }

Continuer à la prochaine fois

C'est tout pour aujourd'hui. Maintenant que nous avons toutes les parties, la prochaine fois, nous expliquerons la logique principale de la méthode de k-moyennage.

J'ai laissé la version expliquée cette fois sur github avec tag, alors jetez un œil si vous le souhaitez. https://github.com/tan3nonsugar/clusteringsample/releases/tag/v0.0.3

[^ 1]: Il existe d'autres types tels que la valeur médiane dans la définition de «milieu», mais comme l'histoire est déroutante, l'histoire est fixée à la moyenne arithmétique.