devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【深度学习】数据归一化/标准化 Normalization/Standardization_深度学习 归一化计算

作者：凡人多烦事01 | 2024-06-04 07:26:19

赞

踩

深度学习 归一化计算

目录

一、实际问题

二、归一化 Normalization

三、归一化的类型

1. Min-max normalization (Rescaling)

2. Mean normalization

3.Z-score normalization (Standardization)

4.非线性归一化

4-1 对数归一化

4-2 反正切函数归一化

4-3 小数定标标准化（Demical Point Normalization）

四、如何选择归一化函数？

五、Java实现归一化工具类

一、实际问题

在数据分析、深度学习中，经常需要对数据进行处理，数据处理时，会发现一个问题：

不同维度的数据，数据范围偏差比较大，如

  • 距离地铁的距离——房价的关系
  • 海拔高度——氧气含量的关系

一个维度的数据范围大，一个小，导致以下问题：

【1】求解过程不平缓、函数收敛慢

【2】相关性展示不明显

如下图：

海拔越高、氧气含量越低，因为数据范围的原因，导致两者的相关性展示得不明显。

解决得方式就是归一化和标准化

二、归一化 Normalization

归一化，指将数据样本中的数据进行处理，使它们处于同一量级。

如 [0,1] 或者 [-1,1] 或者其它

归一化后，数据更具有可比性，如图

函数的求解过程也会比较平缓，更快求得最优解，如下图

左：未归一化的求解  右：归一化后的求解

三、归一化的类型

1. Min-max normalization (Rescaling)

最值归一化，公式如下：

\mathbf{​{x}'=\frac{x-min}{max-min}}

归一化后的数据范围为 [0, 1]，其中min max分别求样本数据的最小值和最大值。

2. Mean normalization

均值归一化，公式如下：

\mathbf{​{x}'=\frac{x-mean}{max-min}}

归一化后的数据范围为 [-1, 1]，其中mean、min、max为样本数据的平均值、最小值和最大值。

3.Z-score normalization (Standardization)

标准差归一化，也成为标准化（标准化其实就是归一化的一种），公式如下：

\boldsymbol{\mathbf{}\boldsymbol{\mathbf{}{x}'=\frac{x-mean}{\sigma}}}

归一化后的数据范围为实数集，其中mean、σ 分别为样本数据的均值和标准差。

4.非线性归一化

4-1 对数归一化

\boldsymbol{\mathbf{}{x}'=\frac{lg(x)}{lg(max)}}

4-2 反正切函数归一化

\boldsymbol{\mathbf{}{x}'=arctan(x)*\frac{2}{pi}}

归一化后的数据范围为 [-1, 1]

4-3 小数定标标准化（Demical Point Normalization）

\boldsymbol{\mathbf{}{x}'=\frac{x}{10^{j}}}

j为使

 \boldsymbol{\mathbf{}max(\left |{ x}' \right |)<1}

的最小整数，归一化后的数据范围为 [-1, 1]

四、如何选择归一化函数？

Min-Max归一化、Mean归一化适合：

【1】最大最小值明确不变：如图像处理中，RGB值为0~255，可以使用Min-Max来处理。

【2】对数据范围有明确要求：如需要数据范围为-1~1

不适合：

【1】最大最小值不明确：每次有新的值加入，之前的结果就会发生改变，导致不稳定。

【2】有过大或过小的异常值存在：效果会较差

Z-score归一化适合：

【1】存在异常值、最大最小值不固定

缺点是：

【1】改变了数据的状态分布，但不会改变分布的种类：经过处理的数据呈均值为0，标准差为1的分布

非线性归一化适合：

【1】数据分化程度较大的场景

五、Java实现归一化工具类

  1. package com.potato.commonpro.util.math;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. /**
  7.  * 数据样本归一化工具类
  8.  * 包含了多个归一化函数,提供了List/Array两种类型的输入输出，具体的归一化函数如下：
  9.  * 【1】min-max normalization（Rescaling）
  10.  * 【2】mean normalization
  11.  * 【3】Z-score normalization (Standardization)
  12.  * 【4】对数归一化
  13.  * 【5】反正切函数归一化
  14.  * 【6】小数定标标准化
  15.  * <p>
  16.  * Author:PotatoChan
  17.  * Date:2023-12-30
  18.  */
  19. public class PotatoNormalization {
  20.  
  21.  
  22.     /**
  23.      * min-max normalization（Rescaling）
  24.      * 归一化公式：x'=(x-min）/（max-min)
  25.      * 归一化后的数据范围为 [0, 1]，其中min 、max 分别求样本数据的最小值和最大值。
  26.      *
  27.      * @param data 数据样本
  28.      * @return 归一化后的数据样本
  29.      */
  30.     public static List<Double> normalizationForMinToMax(List<Double> data) {
  31.         List<Double> result = new ArrayList<>();
  32.         //求取样本数据中的最大值与最小值
  33.         double max = Double.MIN_VALUE;
  34.         double min = Double.MAX_VALUE;
  35.         for (Double item : data) {
  36.             if (item > max) max = item;
  37.             if (item < min) min = item;
  38.         }
  39.         //计算归一化后的数据
  40.         double dis = max - min;
  41.         for (Double item : data) {
  42.             double num = (item - min) / dis;
  43.             result.add(num);
  44.         }
  45.         return result;
  46.     }
  47.  
  48.     /**
  49.      * min-max normalization（Rescaling）
  50.      * 归一化公式：x'=(x-min）/（max-min)
  51.      * 归一化后的数据范围为 [0, 1]，其中min 、max 分别求样本数据的最小值和最大值。
  52.      *
  53.      * @param data 数据样本
  54.      * @return 归一化后的数据样本
  55.      */
  56.     public static double[] normalizationForMinToMax(double[] data) {
  57.         double[] result = new double[data.length];
  58.  
  59.         //求取样本数据中的最大值与最小值
  60.         double max = Double.MIN_VALUE;
  61.         double min = Double.MAX_VALUE;
  62.         for (Double item : data) {
  63.             if (item > max) max = item;
  64.             if (item < min) min = item;
  65.         }
  66.         //计算归一化后的数据
  67.         double dis = max - min;
  68.         for (int i = 0; i < data.length; i++) {
  69.             result[i] = (data[i] - min) / dis;
  70.         }
  71.  
  72.         return result;
  73.     }
  74.  
  75.     /**
  76.      * mean normalization
  77.      * 归一化公式：x'=(x-mean）/（max-min)
  78.      * 归一化后的数据范围为 [-1, 1]，其中mean为样本数据的平均值,min 、max 分别求样本数据的最小值和最大值
  79.      *
  80.      * @param data 数据样本
  81.      * @return 归一化后的数据样本
  82.      */
  83.     public static List<Double> normalizationForMean(List<Double> data) {
  84.         List<Double> result = new ArrayList<>();
  85.         //求取样本数据中的最大值与最小值、平均值
  86.         double max = Double.MIN_VALUE;
  87.         double min = Double.MAX_VALUE;
  88.         double mean = 0;
  89.         for (Double item : data) {
  90.             if (item > max) max = item;
  91.             if (item < min) min = item;
  92.             mean += item;
  93.         }
  94.         mean = mean / data.size();
  95.  
  96.         //计算归一化后的数据
  97.         double dis = max - min;
  98.         for (Double item : data) {
  99.             double num = (item - mean) / dis;
  100.             result.add(num);
  101.         }
  102.         return result;
  103.     }
  104.  
  105.     /**
  106.      * mean normalization
  107.      * 归一化公式：x'=(x-mean）/（max-min)
  108.      * 归一化后的数据范围为 [-1, 1]，其中mean为样本数据的平均值,min 、max 分别求样本数据的最小值和最大值
  109.      *
  110.      * @param data 数据样本
  111.      * @return 归一化后的数据样本
  112.      */
  113.     public static double[] normalizationForMean(double[] data) {
  114.         double[] result = new double[data.length];
  115.         //求取样本数据中的最大值与最小值、平均值
  116.         double max = Double.MIN_VALUE;
  117.         double min = Double.MAX_VALUE;
  118.         double mean = 0;
  119.         for (Double item : data) {
  120.             if (item > max) max = item;
  121.             if (item < min) min = item;
  122.             mean += item;
  123.         }
  124.         mean = mean / data.length;
  125.  
  126.         //计算归一化后的数据
  127.         double dis = max - min;
  128.         for (int i = 0; i < data.length; i++) {
  129.             result[i] = (data[i] - mean) / dis;
  130.         }
  131.         return result;
  132.     }
  133.  
  134.     /**
  135.      * Z-score normalization (Standardization)
  136.      * 归一化公式：x'=(x-mean）/σ
  137.      * 归一化后的数据范围为实数集，其中μ、σ 分别为样本数据的均值和标准差
  138.      *
  139.      * @param data 数据样本
  140.      * @return 归一化后的数据样本
  141.      */
  142.     public static List<Double> normalizationForZScore(List<Double> data) {
  143.         List<Double> result = new ArrayList<>();
  144.         //求取样本数据中的平均值
  145.         double mean = 0;
  146.         for (Double item : data) {
  147.             mean += item;
  148.         }
  149.         mean = mean / data.size();
  150.  
  151.         //计算方差
  152.         double variance = 0;
  153.         for (Double item : data) {
  154.             variance += (item - mean) * (item - mean);
  155.         }
  156.         variance = variance / data.size();
  157.         //计算标准差
  158.         double standardDeviation = Math.sqrt(variance);
  159.  
  160.         //计算归一化后的数据
  161.         for (Double item : data) {
  162.             double num = (item - mean) / standardDeviation;
  163.             result.add(num);
  164.         }
  165.         return result;
  166.     }
  167.  
  168.     /**
  169.      * Z-score normalization (Standardization)
  170.      * 归一化公式：x'=(x-mean）/σ
  171.      * 归一化后的数据范围为实数集，其中μ、σ 分别为样本数据的均值和标准差
  172.      *
  173.      * @param data 数据样本
  174.      * @return 归一化后的数据样本
  175.      */
  176.     public static double[] normalizationForZScore(double[] data) {
  177.         double[] result = new double[data.length];
  178.         //求取样本数据中的平均值
  179.         double mean = 0;
  180.         for (Double item : data) {
  181.             mean += item;
  182.         }
  183.         mean = mean / data.length;
  184.  
  185.         //计算方差
  186.         double variance = 0;
  187.         for (Double item : data) {
  188.             variance += (item - mean) * (item - mean);
  189.         }
  190.         variance = variance / data.length;
  191.         //计算标准差
  192.         double standardDeviation = Math.sqrt(variance);
  193.  
  194.         //计算归一化后的数据
  195.         for (int i = 0; i < data.length; i++) {
  196.             result[i] = (data[i] - mean) / standardDeviation;
  197.         }
  198.         return result;
  199.     }
  200.  
  201.     /**
  202.      * 对数归一化
  203.      * 归一化公式：x'=ln(x)/ln(max)
  204.      * 其中，max为数据样本的最大值
  205.      *
  206.      * @param data 数据样本
  207.      * @return 归一化后的数据样本
  208.      */
  209.     public static List<Double> normalizationForlg(List<Double> data) {
  210.         List<Double> result = new ArrayList<>();
  211.         //求取样本数据中的最大值
  212.         double max = Double.MIN_VALUE;
  213.         for (Double item : data) {
  214.             if (item > max) max = item;
  215.         }
  216.         //计算归一化后的数据
  217.         for (Double item : data) {
  218.             double num = Math.log10(item) / Math.log10(max);
  219.             result.add(num);
  220.         }
  221.         return result;
  222.     }
  223.  
  224.     /**
  225.      * 对数归一化
  226.      * 归一化公式：x'=ln(x)/ln(max)
  227.      * 其中，max为数据样本的最大值
  228.      *
  229.      * @param data 数据样本
  230.      * @return 归一化后的数据样本
  231.      */
  232.     public static double[] normalizationForlg(double[] data) {
  233.         double[] result = new double[data.length];
  234.         //求取样本数据中的最大值
  235.         double max = Double.MIN_VALUE;
  236.         for (Double item : data) {
  237.             if (item > max) max = item;
  238.         }
  239.         //计算归一化后的数据
  240.         for (int i = 0; i < data.length; i++) {
  241.             result[i] = Math.log10(data[i]) / Math.log10(max);
  242.  
  243.         }
  244.         return result;
  245.     }
  246.  
  247.     /**
  248.      * 反正切函数归一化
  249.      * 归一化公式：x'=arctan(x)*(2/PI)
  250.      * 归一化后的数据范围为 [-1, 1],PI表示圆周率Π
  251.      *
  252.      * @param data 数据样本
  253.      * @return 归一化后的数据样本
  254.      */
  255.     public static List<Double> normalizationForArctan(List<Double> data) {
  256.         List<Double> result = new ArrayList<>();
  257.         //计算归一化后的数据
  258.         for (Double item : data) {
  259.             double num = Math.atan(item) * (2 / Math.PI);
  260.             result.add(num);
  261.         }
  262.         return result;
  263.     }
  264.  
  265.  
  266.     /**
  267.      * 反正切函数归一化
  268.      * 归一化公式：x'=arctan(x)*(2/PI)
  269.      * 归一化后的数据范围为 [-1, 1],PI表示圆周率Π
  270.      *
  271.      * @param data 数据样本
  272.      * @return 归一化后的数据样本
  273.      */
  274.     public static double[] normalizationForArctan(double[] data) {
  275.         double[] result = new double[data.length];
  276.         //计算归一化后的数据
  277.         for (int i = 0; i < data.length; i++) {
  278.             result[i] = Math.atan(data[i]) * (2 / Math.PI);
  279.         }
  280.         return result;
  281.     }
  282.  
  283.  
  284. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/670909
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号