Comment normaliser les données dans la plage 0-1?

Je suis perdu dans la normalisation, quelqu'un pourrait-il me guider s'il vous plaît.

J'ai un minimum et des valeurs maximales, par exemple -23,89 et 7,54990767, respectivement.

Si j’obtiens une valeur de 5,6878, comment puis-je redimensionner cette valeur sur une échelle de 0 à 1?

Si vous souhaitez normaliser vos données, vous pouvez le faire comme vous le suggérez et calculer simplement ce qui suit:

où et sont maintenant vos données normalisées . Comme preuve de concept (bien que vous ne l'ayez pas demandé), voici un code et un graphique pour illustrer ce point:$x=(x_1,...,x_n)$$z_i$$i^{th}$R

# Example Data
x = sample(-100:100, 50)

#Normalized Data
normalized = (x-min(x))/(max(x)-min(x))

# Histogram of example data and normalized data
par(mfrow=c(1,2))
hist(x,          breaks=10, xlab="Data",            col="lightblue", main="")
hist(normalized, breaks=10, xlab="Normalized Data", col="lightblue", main="")

La formule générale à une ligne pour redimensionner linéairement les valeurs de données ayant observé min et max dans une nouvelle plage arbitraire min ' à max' est

  newvalue= (max'-min')/(max-min)*(value-max)+max'
  or
  newvalue= (max'-min')/(max-min)*(value-min)+min'.

Voici mon implémentation PHP pour la normalisation:

function normalize($value, $min, $max) {
	$normalized = ($value - $min) / ($max - $min);
	return $normalized;
}

Mais pendant que je construisais mes propres réseaux de neurones artificiels, je devais reconvertir la sortie normalisée en données d'origine pour obtenir une sortie lisible pour le graphique.

function denormalize($normalized, $min, $max) {
	$denormalized = ($normalized * ($max - $min) + $min);
	return $denormalized;
}

$int = 12;
$max = 20;
$min = 10;

$normalized = normalize($int, $min, $max); // 0.2
$denormalized = denormalize($normalized, $min, $max); //12

La dénormalisation utilise la formule suivante:

$x (\text{max} - \text{min}) + \text{min}$

Division par zéro

Une chose à garder à l'esprit est que cela max - minpourrait être égal à zéro. Dans ce cas, vous ne voudriez pas effectuer cette division.

Cela se produit lorsque toutes les valeurs de la liste que vous essayez de normaliser sont identiques. Pour normaliser une telle liste, chaque élément serait 1 / length.

// JavaScript
function normalize(list) {
   var minMax = list.reduce((acc, value) => {
      if (value < acc.min) {
         acc.min = value;
      }

      if (value > acc.max) {
         acc.max = value;
      }

      return acc;
   }, {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY});

   return list.map(value => {
      // Verify that you're not about to divide by zero
      if (minMax.max === minMax.min) {
         return 1 / list.length
      }

      var diff = minMax.max - minMax.min;
      return (value - minMax.min) / diff;
   });
}

Exemple:

normalize([3, 3, 3, 3]); // output => [0.25, 0.25, 0.25, 0.25]

la réponse est correcte, mais j’ai une suggestion à faire. Que se passe-t-il si vos données d’entraînement font face à un nombre en dehors des limites? vous pouvez utiliser la technique de compression. il sera garanti de ne jamais sortir de la plage. plutôt que cela

Je recommande d'utiliser ceci

avec écraser comme ça en min et max de gamme

et la taille de l'écart hors limite prévu est directement proportionnelle au degré de confiance qu'il y aura des valeurs hors limites.

Pour plus d'informations, vous pouvez utiliser Google: écrasez les numéros hors limites et reportez-vous au livre de préparation des données de "dorian pyle".

Essaye ça. Il est cohérent avec l' échelle de la fonction

normalize <- function(x) { 
  x <- as.matrix(x)
  minAttr=apply(x, 2, min)
  maxAttr=apply(x, 2, max)
  x <- sweep(x, 2, minAttr, FUN="-") 
  x=sweep(x, 2,  maxAttr-minAttr, "/") 
  attr(x, 'normalized:min') = minAttr
  attr(x, 'normalized:max') = maxAttr
  return (x)
}