Wie normalisiere ich Daten auf 0-1?

Ich bin in der Normalisierung verloren, könnte mich jemand bitte führen.

Ich habe einen minimalen und einen maximalen Wert, sagen wir -23,89 bzw. 7,54990767.

Wenn ich einen Wert von 5,6878 erhalte, wie kann ich diesen Wert auf einer Skala von 0 bis 1 skalieren?

Wenn Sie Ihre Daten normalisieren möchten, können Sie dies wie vorgeschlagen tun und einfach Folgendes berechnen:

Wobei und jetzt Ihre normalisierten Daten sind. Als Proof-of-Concept (obwohl Sie nicht danach gefragt haben) finden Sie hier einen Code und ein begleitendes Diagramm, um diesen Punkt zu veranschaulichen:$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="")

Die allgemeine einzeilige Formel zum linearen Skalieren von Datenwerten, die min und max beobachtet haben, in einen neuen willkürlichen Bereich von min ' bis max' ist

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

Hier ist meine PHP-Implementierung zur Normalisierung:

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

Aber während ich meine eigenen künstlichen neuronalen Netze aufbaute, musste ich die normalisierte Ausgabe wieder in die ursprünglichen Daten umwandeln, um eine gut lesbare Ausgabe für den Graphen zu erhalten.

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

Bei der Denormalisierung wird die folgende Formel verwendet:

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

Durch Null teilen

Eine Sache zu beachten ist, dass max - mingleich Null sein könnte. In diesem Fall möchten Sie diese Unterteilung nicht durchführen.

In diesem Fall stimmen alle Werte in der Liste, die Sie zu normalisieren versuchen, überein. Um eine solche Liste zu normalisieren, wäre jeder Punkt 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;
   });
}

Beispiel:

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

Die Antwort ist richtig, aber ich habe einen Vorschlag, was ist, wenn Ihre Trainingsdaten auf eine Zahl außerhalb des Bereichs treffen? Sie könnten Squashing-Technik verwenden. Es wird garantiert, dass es niemals aus der Reichweite kommt. lieber als das

Ich empfehle dies zu verwenden

mit Quetschen wie folgt in min und max Reichweite

und die Größe der erwarteten Lücke außerhalb des Bereichs ist direkt proportional zum Grad der Gewissheit, dass es Werte außerhalb des Bereichs geben wird.

Für weitere Informationen können Sie google: die außerhalb des Bereichs liegenden Zahlen quetschen und sich auf das Datenvorbereitungsbuch von "dorian pyle" beziehen.

Versuche dies. Er steht im Einklang mit der Funktion Skala

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