Como normalizar os dados no intervalo 0-1?

Estou perdido na normalização, alguém poderia me guiar por favor.

Eu tenho um valor mínimo e máximo, digamos -23.89 e 7.54990767, respectivamente.

Se eu receber um valor de 5,6878, como posso escalar esse valor em uma escala de 0 a 1.

Se você deseja normalizar seus dados, faça o que sugere e simplesmente calcule o seguinte:

onde e agora são seus dados normalizados. Como prova de conceito (embora você não tenha solicitado), aqui estão alguns códigos e um gráfico anexo para ilustrar este ponto:$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="")

A fórmula geral de uma linha para redimensionar linearmente os valores dos dados que observaram min e max em um novo intervalo arbitrário min ' a max' é

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

Aqui está minha implementação do PHP para normalização:

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

Mas enquanto eu estava construindo minhas próprias redes neurais artificiais, precisei transformar a saída normalizada de volta nos dados originais para obter uma boa saída legível para o 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

A desnormalização usa a seguinte fórmula:

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

Divisão por zero

Uma coisa a ter em mente é que isso max - minpode ser igual a zero. Nesse caso, você não gostaria de executar essa divisão.

O caso em que isso aconteceria é quando todos os valores da lista que você está tentando normalizar são iguais. Para normalizar essa lista, cada item seria 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;
   });
}

Exemplo:

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

a resposta está certa, mas tenho uma sugestão, e se seus dados de treinamento enfrentarem algum número fora do intervalo? você pode usar a técnica de esmagamento. será garantido que nunca fique fora de alcance. ao invés disso

eu recomendo usar isso

com esmagamento como este em min e max de alcance

e o tamanho da lacuna esperada fora da faixa é diretamente proporcional ao grau de confiança de que haverá valores fora da faixa.

para obter mais informações, você pode pesquisar no Google: esmagar os números fora da faixa e consultar o livro de preparação de dados de "dorian pyle"

Tente isso. É consistente com a escala da função

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