Essayez le détartreur standard

J'ai brièvement recherché sklearn.preprocessing.StandardScaler, donc je vais le laisser comme mémo.

StandardScaler fournit la fonction de standardisation de l'ensemble de données. En normalisant, le rapport des quantités de caractéristiques peut être rendu uniforme.

Par exemple, en prenant la valeur de l'écart comme exemple, s'il existe un test avec un score parfait de 100 et un test avec un score parfait de 50 Même si le rapport et l'unité de points sont différents, vous pouvez évaluer les points sans être affecté par la normalisation.

La normalisation peut être obtenue en soustrayant la moyenne de chaque donnée de l'ensemble et en divisant par l'écart type.

z_i = \large{\frac{x_i- \mu}{\sigma}}

«μ» est la moyenne, «σ» est l'écart type et «i» est n'importe quel nombre naturel.

La moyenne est calculée en divisant la somme des ensembles par le nombre.

\mu = \frac{1}{n}\sum ^n_{i}x_i

L'écart type est calculé en divisant la variance par la racine carrée.

\sigma = \sqrt{s^2}

La variance est calculée en soustrayant la moyenne de chaque donnée de l'ensemble, en additionnant les carrés et en divisant par le nombre.

s^2 = \dfrac 1n\sum ^n_{i}(x_i - \mu)^2

Tout d'abord, j'aimerais l'implémenter moi-même sans utiliser de bibliothèque d'apprentissage automatique. Utilisez l'ensemble de données ʻiris` comme cible pour la normalisation.

from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data
print(X[:1]) # array([[5.1, 3.5, 1.4, 0.2]])

import math

def standardize(x):
    """
    Parameters
    ----------
    x:Attendez-vous à un tableau standardisé, un vecteur unidimensionnel.

    Returns
    -------
    mean:moyenne
    var:Distribué
    std:écart-type
    z:Tableau standardisé
    """
    mean = None
    var = None
    std = None
    z = None

    #Calculer la moyenne, la somme des ensembles/Nombre de fonctionnalités
    mean = sum(x) / len(x)

    #Calculer la variance, faire la moyenne de l'ensemble-Divisez la somme des carrés des différences d'entités par le nombre
    var = sum([(mean - x_i) ** 2 for x_i in x]) / len(x)

    #Divisez la variance par la racine carrée
    std = math.sqrt(var)

    #Soustrayez la moyenne de chaque caractéristique et divisez-la par l'écart type
    z = [x_i / std for x_i in [x_i - mean for x_i in x]]
    
    return [mean, var, std, z]

#7 données depuis le début de la 1ère dimension de l'ensemble de données
sample_data = X[:, :1][:7] 
print(sample_data.tolist()) # [[5.1], [4.9], [4.7], [4.6], [5.0], [5.4], [4.6]]

mean, var, std, z = standardize(sample_data)

print(mean) # [4.9]
print(var)  # [0.07428571]
print(std)  # 0.2725540575476989
print(*z)   # [0.73379939] [3.25872389e-15] [-0.73379939] [-1.10069908] [0.36689969] [1.83449846] [-1.10069908]

Vous pouvez voir que la variable sample_data a été traitée et convertie en virgule flottante.

Ensuite, essayez d'utiliser sklearn.preprocessing.StandardScaler.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaler.fit(sample_data)

print(scaler.mean_) # [4.9]
print(scaler.var_)  # [0.07428571]
print(math.sqrt(scaler.var_)) # 0.2725540575476989
print(*scaler.transform(sample_data))  # [0.73379939] [3.25872389e-15] [-0.73379939] [-1.10069908] [0.36689969] [1.83449846] [-1.10069908]

#Les valeurs sont les mêmes
print(scaler.mean_ == mean) # [ True]
print(scaler.var_ == var)   # [ True]
print(math.sqrt(scaler.var_) == std) # True
print(*(scaler.transform(sample_data) == z)) # [ True] [ True] [ True] [ True] [ True] [ True] [ True] 

En utilisant "Standard Scaler" de cette manière, la standardisation peut être réalisée avec une petite quantité.

De plus, étant donné que les valeurs calculées lors de la normalisation telles que «mean_» et «var_» sont conservées, si «fit» est défini lors de l'entraînement du modèle d'apprentissage automatique, il sera utilisé comme données [^ 1] lors de l'inférence du modèle. D'un autre côté, processing_query = (np.array (query) --scaler.mean_) --np.sqrt (scaler.var_) peut être défini, ce qui est très pratique.

[^ 1]: en supposant que le vecteur donné lors de l'inférence du modèle appartient à l'ensemble des jeux de données utilisés lors de l'apprentissage.

Recommended Posts

Essayez le détartreur standard
Essayez Python
essayez pysdl2
Essayez PyOpenGL
Essayez l'algorithme d'apprentissage amélioré standard d'OpenAI PPO