Come normalizzare i dati nell'intervallo 0-1?

Mi sono perso nella normalizzazione, qualcuno potrebbe guidarmi per favore.

Ho un valore minimo e massimo, diciamo rispettivamente -23.89 e 7.54990767.

Se ottengo un valore di 5,6878 come posso ridimensionare questo valore su una scala da 0 a 1.

Se vuoi normalizzare i tuoi dati, puoi farlo come suggerisci e semplicemente calcolare quanto segue:

dove e sono ora tuoi dati normalizzati . Come prova del concetto (anche se non lo hai richiesto) ecco un po 'di codice e un grafico che accompagna per illustrare questo 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 formula generale a una riga per ridimensionare linearmente i valori dei dati dopo aver osservato min e max in un nuovo intervallo arbitrario min ' a max' è

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

Ecco la mia implementazione di PHP per la normalizzazione:

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

Ma mentre stavo costruendo le mie reti neurali artificiali, avevo bisogno di trasformare l'output normalizzato ai dati originali per ottenere un output leggibile per il grafico.

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 denormalizzazione utilizza la seguente formula:

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

Divisione per zero

Una cosa da tenere a mente è che max - minpotrebbe essere uguale a zero. In questo caso, non vorrai eseguire quella divisione.

Il caso in cui ciò accada è quando tutti i valori nell'elenco che stai tentando di normalizzare sono gli stessi. Per normalizzare tale elenco, ogni elemento sarebbe 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;
   });
}

Esempio:

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

la risposta è giusta ma ho un suggerimento, cosa succede se i tuoi dati di allenamento affrontano un numero fuori portata? potresti usare la tecnica di schiacciamento. sarà garantito per non andare mai fuori portata. piuttosto che questo

ti consiglio di usare questo

con schiacciamento come questo in min e max di portata

e la dimensione del gap fuori range atteso è direttamente proporzionale al grado di confidenza che ci saranno valori fuori range.

per maggiori informazioni puoi google: schiacciare i numeri fuori range e fare riferimento al libro di preparazione dei dati di "dorian pyle"

Prova questo. È coerente con la scala delle funzioni

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