AI 助理
备案控制台
开发者社区 大数据 文章 正文

SparkML机器学习之特征工程（二）特征转化（Binarizer、StandardScaler、MaxAbsScaler、Normalizer、N-gram、Tokenizer等）

2018-04-08 8861
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

特征转化

为什么要转化数据呢，就是要让它成为有效的特征，因为原始数据是很多脏数据无用数据的。常用的方法是标准化，归一化，特征的离散化等等。比如我输入的数据是句子，我得把它切分为一个个单词进行分析，这就是一种转化。

连续型数据处理之二值化：Binarizer

假设淘宝现在有个需求，我得根据年龄来进行物品推荐，把50以上的人分为老年，50以下分为非老年人，那么我们根据二值化可以很简单的把50以上的定为1，50以下的定为0。这样就方便我们后续的推荐了。Binarizer就是根据阈值进行二值化,大于阈值的为1.0,小于等于阈值的为0.0

package ml.test
import org.apache.spark.ml.feature.Binarizer
import org.apache.spark.sql.SparkSession
/**
  * Created by liuyanling on 2018/3/19   
  */
object BinarizerDemo {
  def main(args: Array[String]): Unit = {
    var spark = SparkSession.builder().appName("BinarizerDemo").master("local[2]").getOrCreate();
    val array = Array((1,34.0),(2,56.0),(3,58.0),(4,23.0))
    //将数组转为DataFrame
    val df = spark.createDataFrame(array).toDF("id","age")
    //初始化Binarizer对象并进行设定：setThreshold是设置我们的阈值，InputCol是设置需要进行二值化的输入列，setOutputCol设置输出列
    val binarizer = new Binarizer().setThreshold(50.0).setInputCol("age").setOutputCol("binarized_feature")
    //transform方法将DataFrame二值化。
    val binarizerdf = binarizer.transform(df)
    //show是用于展示结果
    binarizerdf.show
  }
}

输出结果:

+---+----+-----------------+
| id| age|binarized_feature|
+---+----+-----------------+
|  1|34.0|              0.0|
|  2|56.0|              1.0|
|  3|58.0|              1.0|
|  4|23.0|              0.0|
+---+----+-----------------+

连续型数据处理之给定边界离散化：Bucketizer

现在淘宝的需求变了，他们觉得把人分为50以上和50以下太不精准了，应该分为20岁以下，20-30岁，30-40岁，36-50岁，50以上，那么就得用到数值离散化的处理方法了。离散化就是把特征进行适当的离散处理，比如上面所说的年龄是个连续的特征，但是我把它分为不同的年龄阶段就是把它离散化了，这样更利于我们分析用户行为进行精准推荐。Bucketizer能方便的将一堆数据分成不同的区间。

object BucketizerDemo {
  def main(args: Array[String]): Unit = {
    var spark = SparkSession.builder().appName("BucketizerDemo").master("local[2]").getOrCreate();
    val array = Array((1,13.0),(2,16.0),(3,23.0),(4,35.0),(5,56.0),(6,44.0))
    //将数组转为DataFrame
    val df = spark.createDataFrame(array).toDF("id","age")
    // 设定边界，分为5个年龄组：[0,20),[20,30),[30,40),[40,50),[50,正无穷)
    // 注：人的年龄当然不可能正无穷，我只是为了给大家演示正无穷PositiveInfinity的用法，负无穷是NegativeInfinity。
    val splits = Array(0, 20, 30, 40, 50, Double.PositiveInfinity)
    //初始化Bucketizer对象并进行设定：setSplits是设置我们的划分依据
    val bucketizer = new Bucketizer().setSplits(splits).setInputCol("age").setOutputCol("bucketizer_feature")
    //transform方法将DataFrame二值化。
    val bucketizerdf = bucketizer.transform(df)
    //show是用于展示结果
    bucketizerdf.show
  }

}

输出结果:

+---+----+------------------+
| id| age|bucketizer_feature|
+---+----+------------------+
|  1|13.0|               0.0|
|  2|16.0|               0.0|
|  3|23.0|               1.0|
|  4|35.0|               2.0|
|  5|56.0|               4.0|
|  6|44.0|               3.0|
+---+----+------------------+

连续型数据处理之给定分位数离散化：QuantileDiscretizer

有时候我们不想给定分类标准，可以让spark自动给我们分箱。

object QuantileDiscretizerDemo {
  def main(args: Array[String]): Unit = {
    var spark = SparkSession.builder().appName("QuantileDiscretizerDemo").master("local[2]").getOrCreate();
    val array = Array((1,13.0),(2,14.0),(3,22.0),(4,35.0),(5,44.0),(6,56.0),(7,21.0))
    val df = spark.createDataFrame(array).toDF("id","age")
    //和Bucketizer类似：将连续数值特征转换离散化。但这里不再自己定义splits（分类标准），而是定义分几箱就可以了。
    val quantile = new QuantileDiscretizer().setNumBuckets(5).setInputCol("age").setOutputCol("quantile_feature")
    //因为事先不知道分桶依据，所以要先fit,相当于对数据进行扫描一遍，取出分位数来，再transform进行转化。
    val quantiledf = quantile.fit(df).transform(df)
    //show是用于展示结果
    quantiledf.show
  }
}

标准化

对于同一个特征，不同的样本中的取值可能会相差非常大，一些异常小或异常大的数据会误导模型的正确训练；另外，如果数据的分布很分散也会影响训练结果。以上两种方式都体现在方差会非常大。此时，我们可以将特征中的值进行标准差标准化，即转换为均值为0，方差为1的正态分布。如果特征非常稀疏，并且有大量的0（现实应用中很多特征都具有这个特点），Z-score 标准化的过程几乎就是一个除0的过程，结果不可预料。所以在训练模型之前，一定要对特征的数据分布进行探索，并考虑是否有必要将数据进行标准化。基于特征值的均值（mean）和标准差（standard deviation）进行数据的标准化。它的计算公式为：标准化数据=(原数据-均值)/标准差。标准化后的变量值围绕0上下波动，大于0说明高于平均水平，小于0说明低于平均水平。

StandardScaler

object StandardScalerDemo {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[2]").getOrCreate()
    val df = spark.read.format("libsvm").load("libsvm_data.txt")
    //setWithMean是否减均值。setWithStd是否将数据除以标准差。这里就是没有减均值但有除以标准差
    df.printSchema()
    val scaler =new StandardScaler().setInputCol("features").setOutputCol("scaledFeatures").setWithMean(false).setWithStd(true)
    // 计算均值方差等参数
    val scalermodel = scaler.fit(df)
    // 标准化
    scalermodel.transform(df).show()
  }
}
libsvm_data.txt
label 标签，就是属于哪一类，即你要分类的种类，通常是一些整数。
index 是有顺序的索引，通常是连续的整数。就是指特征编号，必须按照升序排列
value 就是特征值，训练，通常是一堆实数组成。
格式：标签 第一维特征编号：第一维特征值 第二维特征编号：第二维特征值 …例：
0 1:1 2:2
1 1:2 2:4

归一化

为什么数据需要归一化？以房价预测为案例，房价(y)通常与离市中心距离(x1)、面积(x2)、楼层(x3)有关，设y=ax1+bx2+cx3，那么abc就是我们需要重点解决的参数。但是有个问题，面积一般数值是比较大的，100平甚至更多，而距离一般都是几公里而已，b参数只要一点变化都能对房价产生巨大影响，而a的变化对房价的影响相对就小很多了。显然这会影响最终的准确性，毕竟距离可是个非常大的影响因素啊。 所以, 需要使用特征的归一化, 取值跨度大的特征数据, 我们浓缩一下, 跨度小的括展一下, 使得他们的跨度尽量统一。
归一化就是将所有特征值都等比地缩小到0-1或者-1到1之间的区间内。其目的是为了使特征都在相同的规模中。

绝对值最大标准化：MaxAbsScaler

import org.apache.spark.ml.feature.MaxAbsScaler
import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.sql.SparkSession
/**
  * Created by LYL on 2018/3/20.
  */
object MaxAbsScalerDemo {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().appName("MaxAbsScalerDemo").master("local[2]").getOrCreate()
    val dataFrame = spark.createDataFrame(Seq(
      (0, Vectors.dense(10.0, 0.1, -8.0)),
      (1, Vectors.dense(100.0, 1.0, -4.0)),
      (2, Vectors.dense(1000.0, 10.0, 8.0))
    )).toDF("id", "features")
    val maxabs = new MaxAbsScaler().setInputCol("features").setOutputCol("maxabs_features")
    // fit作用是把所有值都扫描一遍，计算出最大最小值，比如1000的话那么absMax=1000。最后返回MaxAbsScalerModel
    val scalerModel = maxabs.fit(dataFrame)
    // 使用每个特征的最大值的绝对值将输入向量的特征值都缩放到[-1,1]范围内
    val scalerdf = scalerModel.transform(dataFrame)
    scalerdf.show
  }
}

运行结果：

+---+-----------------+----------------+
| id|         features| maxabs_features|
+---+-----------------+----------------+
|  0|  [10.0,0.1,-8.0]|[0.01,0.01,-1.0]|
|  1| [100.0,1.0,-4.0]|  [0.1,0.1,-0.5]|
|  2|[1000.0,10.0,8.0]|   [1.0,1.0,1.0]|
+---+-----------------+----------------+

归一化之最小最大值标准化MinMaxScaler

import org.apache.spark.ml.feature.MinMaxScaler
import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.sql.SparkSession
/**
  * Created by LYL on 2018/3/20.
  */
object MinMaxScalerDemo {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().appName("MinMaxScalerDemo").master("local[2]").getOrCreate()
    val dataFrame = spark.createDataFrame(Seq(
      (0, Vectors.dense(2.0, 0.9, -2.0)),
      (1, Vectors.dense(3.0, -2.0, -3.0)),
      (2, Vectors.dense(4.0, -2.0, 2.0))
    )).toDF("id", "features")
    val maxabs = new MinMaxScaler().setInputCol("features").setOutputCol("minmax_features")
    val scalerModel = maxabs.fit(dataFrame)
    // 将所有值都缩放到[0,1]范围内
    val scalerdf = scalerModel.transform(dataFrame)
    scalerdf.show
  }
}

运行结果为：

+---+---------------+---------------+
| id|       features|minmax_features|
+---+---------------+---------------+
|  0| [2.0,0.9,-2.0]|  [0.0,1.0,0.2]|
|  1|[3.0,-2.0,-3.0]|  [0.5,0.0,0.0]|
|  2| [4.0,-2.0,2.0]|  [1.0,0.0,1.0]|
+---+---------------+---------------+

正则化Normalizer

为什么要有正则化？就是为了防止过拟合。来看一下正则化是怎么计算的：
未标题-2.jpg

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[2]").getOrCreate()
    val dataFrame = spark.createDataFrame(Seq(
      (0, Vectors.dense(1.0, 0.5, -1.0)),
      (1, Vectors.dense(2.0, 1.0, 1.0)),
      (2, Vectors.dense(4.0, 10.0, 2.0))
    )).toDF("id", "features")
    //setP是指L1正则化还是L2正则化，比如1.0就是上面说到的L1正则化，计算如下：1/(1+0.5+1)
    val normalizer = new Normalizer().setInputCol("features").setOutputCol("normalizer_features").setP(1.0)
    normalizer.transform(dataFrame).show(truncate = false)
  }

输出结果为：

+---+--------------+-------------------+
|id |features      |normalizer_features|
+---+--------------+-------------------+
|0  |[1.0,0.5,-1.0]|[0.4,0.2,-0.4]     |
|1  |[2.0,1.0,1.0] |[0.5,0.25,0.25]    |
|2  |[4.0,10.0,2.0]|[0.25,0.625,0.125] |
+---+--------------+-------------------+

N-gram

N-Gram认为语言中每个单词只与其前面长度 N-1 的上下文有关。主要分为bigram和trigram，bigram假设下一个词的出现依赖它前面的一个词，trigram假设下一个词的出现依赖它前面的两个词。在SparkML中用NGram类实现，setN(2)为bigram，setN(3)为trigram。

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[2]").getOrCreate()
    val wordDataFrame = spark.createDataFrame(Seq(
      (0, Array("Hi", "I", "heard", "about", "Spark")),
      (1, Array("I", "wish", "Java", "could", "use", "case", "classes")),
      (2, Array("Logistic", "regression", "models", "are", "neat"))
    )).toDF("id", "words")
    val ngram2 = new NGram().setN(2).setInputCol("words").setOutputCol("ngrams")
    val ngram3 = new NGram().setN(3).setInputCol("words").setOutputCol("ngrams")
    ngram2.transform(wordDataFrame).show(false)
    ngram3.transform(wordDataFrame).show(false)
  }

输出结果为：

+---+------------------------------------------+------------------------------------------------------------------+
|id |words                                     |ngrams                                                            |
+---+------------------------------------------+------------------------------------------------------------------+
|0  |[Hi, I, heard, about, Spark]              |[Hi I, I heard, heard about, about Spark]                         |
|1  |[I, wish, Java, could, use, case, classes]|[I wish, wish Java, Java could, could use, use case, case classes]|
|2  |[Logistic, regression, models, are, neat] |[Logistic regression, regression models, models are, are neat]    |
+---+------------------------------------------+------------------------------------------------------------------+

18/03/24 11:23:32 INFO CodeGenerator: Code generated in 14.198881 ms
+---+------------------------------------------+--------------------------------------------------------------------------------+
|id |words                                     |ngrams                                                                          |
+---+------------------------------------------+--------------------------------------------------------------------------------+
|0  |[Hi, I, heard, about, Spark]              |[Hi I heard, I heard about, heard about Spark]                                  |
|1  |[I, wish, Java, could, use, case, classes]|[I wish Java, wish Java could, Java could use, could use case, use case classes]|
|2  |[Logistic, regression, models, are, neat] |[Logistic regression models, regression models are, models are neat]            |
+---+------------------------------------------+--------------------------------------------------------------------------------+

多项式转化PolynomialExpansion

有时候要对特征值进行一些多项式的转化，比如平方啊，三次方啊等等，那就用到了PolynomialExpansion。

object PolynomialExpansionDemo {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[2]").getOrCreate()
    val dataFrame = spark.createDataFrame(Seq(
      (0, Vectors.dense(1.0, 5.0)),
      (1, Vectors.dense(2.0, 1.0)),
      (2, Vectors.dense(4.0, 8.0))
    )).toDF("id", "features")
    //setDegree表示多项式最高次幂 比如1.0,5.0可以是 三次：1.0^3 5.0^3 1.0+5.0^2 二次：1.0^2+5.0 1.0^2 5.0^2 1.0+5.0 一次：1.0 5.0
    val po = new PolynomialExpansion().setDegree(3).setInputCol("features").setOutputCol("Polynomial_features")
    po.transform(dataFrame).show(truncate = false)
  }
}

输出结果为：

+---+---------+-----------------------------------------------+
|id |features |Polynomial_features                            |
+---+---------+-----------------------------------------------+
|0  |[1.0,5.0]|[1.0,1.0,1.0,5.0,5.0,5.0,25.0,25.0,125.0]      |
|1  |[2.0,1.0]|[2.0,4.0,8.0,1.0,2.0,4.0,1.0,2.0,1.0]          |
|2  |[4.0,8.0]|[4.0,16.0,64.0,8.0,32.0,128.0,64.0,256.0,512.0]|
+---+---------+-----------------------------------------------+

Tokenizer分词器

当我们的输入数据为文本（句子）的时候，我们会想把他们切分为单词再进行数据处理，这时候就要用到Tokenizer类了。

object TokenizerDemo {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[2]").appName("TokenizerDemo").getOrCreate()
    val dataFrame = spark.createDataFrame(Seq((0, "Hello I am LYL"), (1, "I Love Bigdata"), (2, "1 2 3 4"))).toDF("id", "sentence")
    // Tokenization（分词器）是一个接受文本（通常是句子）输入，然后切分成单词。
    val tokenizer = new Tokenizer().setInputCol("sentence").setOutputCol("words")
    tokenizer.transform(dataFrame).show()
    // RegexTokenizer（正则化分词器）基于正则表达式匹配提供了更多高级的分词功能。将gaps参数设置为false,表明使用正则表达式匹配标记，而不是使用分隔符。
    // 此处\\d表示匹配数字。
    val regextokenizer = new RegexTokenizer().setInputCol("sentence").setOutputCol("words").setGaps(false).setPattern("\\d")
    regextokenizer.transform(dataFrame).show()
    //使用udf函数 统计单词个数
    val wordcount = udf { (word: Seq[String]) => word.length }
    tokenizer.transform(dataFrame).select("words").withColumn("wordcount", wordcount(col("words"))).show()

  }

输出结果为：

+---+--------------+-------------------+
| id|      sentence|              words|
+---+--------------+-------------------+
|  0|Hello I am LYL|[hello, i, am, lyl]|
|  1|I Love Bigdata| [i, love, bigdata]|
|  2|       1 2 3 4|       [1, 2, 3, 4]|
+---+--------------+-------------------+

+---+--------------+------------+
| id|      sentence|       words|
+---+--------------+------------+
|  0|Hello I am LYL|          []|
|  1|I Love Bigdata|          []|
|  2|       1 2 3 4|[1, 2, 3, 4]|
+---+--------------+------------+

+-------------------+---------+
|              words|wordcount|
+-------------------+---------+
|[hello, i, am, lyl]|        4|
| [i, love, bigdata]|        3|
|       [1, 2, 3, 4]|        4|
+-------------------+---------+

SQLTransformer

我们都很喜欢sql语句，简单好用又熟悉，那么Spark ML很人性化的为我们提供了SQLTransformer类，使得我们能用我们熟悉的SQL来做特征转化。它支持SparkSql中的所有select选择语句,sum(),count(),group by,order by等等都可以用！形如"SELECT ...FROM __THIS__"。'__THIS__'代表输入数据的基础表。

def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[2]").getOrCreate()
    val df = spark.createDataFrame(Seq((1, "lyl", 90), (2, "ddd", 88), (3, "ccc", 95)))
      .toDF("id", "name", "score")
    //__THIS__代表输入数据的基础表 在这里就是指df
    val sqltransformer1 = new SQLTransformer().setStatement("select id from __THIS__")
    val sqltransformer2 = new SQLTransformer().setStatement("select sum(score)/3 as average from __THIS__")
    sqltransformer1.transform(df).show()
    sqltransformer2.transform(df).show()
  }

输出结果为：

+---+
| id|
+---+
|  1|
|  2|
|  3|
+---+

|average|
+-------+
|   91.0|
+-------+
文章标签：
分布式计算
Spark
Apache
大数据
机器学习/深度学习
关键词：
人工智能平台 PAI特征
人工智能平台 PAI特征工程
人工智能平台 PAI特征工程特征
人工智能平台 PAI standardscaler
人工智能平台 PAI特征standardscaler
公众号胖滚猪学编程
目录
相关文章
Deephub
|
2月前
|
机器学习/深度学习 算法 数据可视化
机器学习模型中特征贡献度分析：预测贡献与错误贡献
本文将探讨特征重要性与特征有效性之间的关系，并引入两个关键概念：预测贡献度和错误贡献度。
Deephub
222 3
Deephub
|
24天前
|
机器学习/深度学习 数据采集 数据挖掘
特征工程在营销组合建模中的应用：基于因果推断的机器学习方法优化渠道效应估计
因果推断方法为特征工程提供了一个更深层次的框架，使我们能够区分真正的因果关系和简单的统计相关性。这种方法在需要理解干预效果的领域尤为重要，如经济学、医学和市场营销。
Deephub
50 1
特征工程在营销组合建模中的应用：基于因果推断的机器学习方法优化渠道效应估计
冷冻工厂
|
4月前
|
机器学习/深度学习 人工智能
8个特征工程技巧提升机器学习预测准确性
8个特征工程技巧提升机器学习预测准确性
冷冻工厂
98 6
8个特征工程技巧提升机器学习预测准确性
土木林森
|
3月前
|
机器学习/深度学习 SQL 数据采集
"解锁机器学习数据预处理新姿势！SQL，你的数据金矿挖掘神器，从清洗到转换，再到特征工程，一网打尽，让数据纯净如金，模型性能飙升！"
【8月更文挑战第31天】在机器学习项目中，数据质量至关重要，而SQL作为数据预处理的强大工具，助力数据科学家高效清洗、转换和分析数据。通过去除重复记录、处理缺失值和异常值，SQL确保数据纯净；利用数据类型转换和字符串操作，SQL重塑数据结构；通过复杂查询生成新特征，SQL提升模型性能。掌握SQL，就如同拥有了开启数据金矿的钥匙，为机器学习项目奠定坚实基础。
土木林森
37 0
Python大数据分析
|
3月前
|
机器学习/深度学习 数据采集 算法
如何使用机器学习神器sklearn做特征工程？
如何使用机器学习神器sklearn做特征工程？
Python大数据分析
39 0
三分钟热度的鱼
|
5月前
|
机器学习/深度学习 人工智能 JSON
人工智能平台PAI产品使用合集之创建特征视图时遇到报错，该如何排查
阿里云人工智能平台PAI是一个功能强大、易于使用的AI开发平台，旨在降低AI开发门槛，加速创新，助力企业和开发者高效构建、部署和管理人工智能应用。其中包含了一系列相互协同的产品与服务，共同构成一个完整的人工智能开发与应用生态系统。以下是对PAI产品使用合集的概述，涵盖数据处理、模型开发、训练加速、模型部署及管理等多个环节。
三分钟热度的鱼
107 4
三分钟热度的鱼
|
4月前
|
存储 机器学习/深度学习 人工智能
人工智能平台PAI使用问题之特征平台是否可以与Java进行对接
阿里云人工智能平台PAI是一个功能强大、易于使用的AI开发平台，旨在降低AI开发门槛，加速创新，助力企业和开发者高效构建、部署和管理人工智能应用。其中包含了一系列相互协同的产品与服务，共同构成一个完整的人工智能开发与应用生态系统。以下是对PAI产品使用合集的概述，涵盖数据处理、模型开发、训练加速、模型部署及管理等多个环节。
三分钟热度的鱼
33 0
三分钟热度的鱼
|
5月前
|
机器学习/深度学习 存储 人工智能
人工智能平台PAI产品使用合集之选择使用Hologres作为在线特征存储，响应延时大概在多久
阿里云人工智能平台PAI是一个功能强大、易于使用的AI开发平台，旨在降低AI开发门槛，加速创新，助力企业和开发者高效构建、部署和管理人工智能应用。其中包含了一系列相互协同的产品与服务，共同构成一个完整的人工智能开发与应用生态系统。以下是对PAI产品使用合集的概述，涵盖数据处理、模型开发、训练加速、模型部署及管理等多个环节。
三分钟热度的鱼
87 2
三分钟热度的鱼
|
5月前
|
机器学习/深度学习 数据采集 存储
人工智能平台PAI产品使用合集之FeatureStore是否支持推荐场景下的session特征
阿里云人工智能平台PAI是一个功能强大、易于使用的AI开发平台，旨在降低AI开发门槛，加速创新，助力企业和开发者高效构建、部署和管理人工智能应用。其中包含了一系列相互协同的产品与服务，共同构成一个完整的人工智能开发与应用生态系统。以下是对PAI产品使用合集的概述，涵盖数据处理、模型开发、训练加速、模型部署及管理等多个环节。
三分钟热度的鱼
96 2
小空门123-30335
|
4月前
|
机器学习/深度学习 数据采集 存储
在机器学习和数据科学中，数据预处理是一个至关重要的步骤。数据规范化（或称为特征缩放）是预处理的一种常见技术，它可以帮助我们改进模型的性能。`sklearn.preprocessing`模块提供了多种数据规范化的方法，其中`StandardScaler`和`MinMaxScaler`是最常用的两种。
在机器学习和数据科学中，数据预处理是一个至关重要的步骤。数据规范化（或称为特征缩放）是预处理的一种常见技术，它可以帮助我们改进模型的性能。`sklearn.preprocessing`模块提供了多种数据规范化的方法，其中`StandardScaler`和`MinMaxScaler`是最常用的两种。
小空门123-30335
88 0

热门文章

最新文章

  • 1
    机器学习三剑客之Numpy
  • 2
    写给人类的机器学习 翻译完成
  • 3
    【DSW Gallery】PAI-DSW开通及授权
  • 4
    [Spark][Python]Mapping Single Rows to Multiple Pairs
  • 5
    spark 3.1.x支持（兼容）hive 1.2.x以及hadoop cdh版本的尝试
  • 6
    [Spark][Python]Spark Python 索引页
  • 7
    Spark Job的提交与task本地化分析（源码阅读八）
  • 8
    Spark-spark streaming
  • 9
    Spark-构建基于Spark的推荐引擎
  • 10
    十二、Spark的安装与部署详情（Local模式，Standalone模式，Spank on YARN模式）
  • 1
    机器学习之sklearn基础教程
    104
  • 2
    Python深度学习基于Tensorflow（5）机器学习基础
    46
  • 3
    构建高效机器学习模型的策略与实践
    61
  • 4
    基于Java的人工智能与机器学习初探
    250
  • 5
    【机器学习】各大模型原理简介
    137
  • 6
    【人工智能】机器学习算法综述及常见算法详解
    332
  • 7
    深入浅出Python机器学习：从零开始的SVM教程/厾罗
    200
  • 8
    机器学习之sklearn基础教程
    70
  • 9
    数据分享|R语言机器学习预测案例合集：众筹平台、机票折扣、糖尿病患者、员工满意度
    123
  • 10
    【C 言专栏】C 语言与机器学习的应用
    100

    • 相关课程

    更多
  • PAI平台学习路线：机器学习入门到应用
  • 场景实践 - 机器学习PAI实现精细化营销
  • 场景实践 - 基于阿里云PAI机器学习平台使用时间序列分解模型预测商品销量
  • 场景实践 - 基于机器学习进行收入预测分析
  • 机器学习概览及常见算法
  • 机器学习入门-概念原理及常用算法

    • 相关电子书

    更多
  • 大规模机器学习在蚂蚁+阿里的应用
  • 阿里巴巴机器学习平台AI
  • 机器学习及人机交互实战

    • 相关实验场景

    更多
  • 基于函数计算实现AI推理
  • 推荐系统入门之使用ALS算法实现打分预测
  • 自然语言入门：NLP数据读取与数据分析
  • 基于Hologres+PAI+计算巢，5分钟搭建企业级AI问答知识库
  • 使用PAI-快速开始，低代码实现大语言模型微调和部署
    • 下一篇
    DataWorks智能数据建模全面公测开始啦！