¿Cómo normalizar los datos al rango 0-1?

Estoy perdido en la normalización, ¿podría alguien guiarme por favor?

Tengo valores mínimos y máximos, digamos -23.89 y 7.54990767, respectivamente.

Si obtengo un valor de 5.6878, ¿cómo puedo escalar este valor en una escala de 0 a 1?

Si desea normalizar sus datos, puede hacerlo como sugiere y simplemente calcular lo siguiente:

donde y son ahora sus datos normalizados . Como prueba de concepto (aunque no lo solicitó) aquí hay un código y un gráfico adjunto para ilustrar este punto:$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 fórmula general de una línea para reescalar linealmente los valores de datos que han observado min y max en un nuevo rango arbitrario min ' a max' es

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

Aquí está mi implementación de PHP para la normalización:

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

Pero mientras construía mis propias redes neuronales artificiales, necesitaba transformar la salida normalizada de nuevo a los datos originales para obtener una buena salida legible para el gráfico.

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 desnormalización utiliza la siguiente fórmula:

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

División por cero

Una cosa a tener en cuenta es que max - minpodría ser igual a cero. En este caso, no querrás realizar esa división.

El caso en el que esto sucedería es cuando todos los valores de la lista que intenta normalizar sean iguales. Para normalizar dicha lista, cada elemento sería 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;
   });
}

Ejemplo:

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

la respuesta es correcta pero tengo una sugerencia, ¿qué pasa si sus datos de entrenamiento se enfrentan a algún número fuera de rango? podrías usar la técnica de aplastar. se garantizará que nunca saldrá del alcance. En vez de esto

recomiendo usar esto

con aplastamiento como este en min y max de rango

y el tamaño de la brecha esperada fuera del rango es directamente proporcional al grado de confianza de que habrá valores fuera del rango.

para obtener más información, puede buscar en google: aplastar los números fuera de rango y consultar el libro de preparación de datos de "dorian pyle"

Prueba esto. Es consistente con la escala de funciones

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)
}