pyspark官方文档中的pyspark.ml.feature函数中文简介

可以看成对pyspark.ml.feature中的方法的大致中文翻译吧，例子基本都是给予官方文档上的例子，目的就是为了对里面的函数有大致的了解，如果要是看具体的还是看官方文档好，待整理待更新 ，有点乱。
官方文档地址：
http://spark.apache.org/docs/latest/api/python/pyspark.ml.html

1、Binarizer(threshold=0.0,inpoutCol=None,outputCol=None)

将数据框中的某一列按照阈值划分为只包含0，1的列。
函数：transform()

2、Bucketizer(splits=None,inputCol=None,outputCol=None,handleInvalid=”error”)

将连续特征按照splits值进行分箱,参数handleInvalid表示处理无效值的方式：error,keep,skip
例如：

Bucketizer(splits=[-float("inf"),0.5,1.4,float("inf")],inputCol="values",outputCol="buckets")

使用函数为：
transform()

3、ChiSqSelector(numTopFeatures=50,featuresCol=”features”,outputCol=None,labelCol=”label”,selectorType=”numTopFeatures”,percentile=0.1,fpr=0.5,fdr=0.05,fwe=0.05)

pyspark中的特征选择函数，依据卡方检验，一般用于计算类别特征与分类标签的关联性。
该函数只有先训练才能知道挑选哪些特征值，所以要先fit,应用的时候再transform.
使用过程：
先fit(df) 然后再 transform()

from pyspark.ml.linalg import Vectors
df = spark.createDataFrame(
[(Vectors.dense([0.0, 0.0, 18.0, 1.0]), 1.0),
(Vectors.dense([0.0, 1.0, 12.0, 0.0]), 0.0),
(Vectors.dense([1.0, 0.0, 15.0, 0.1]), 0.0)],
["features", "label"])
selector = ChiSqSelector(numTopFeatures=1, outputCol="selectedFeatures")
model = selector.fit(df)
model.transform(df).head().selectedFeatures

此外如果你有多个参数映射可以使用 fitMultiple(dataset,paramMaps) 一次训练多个模型

4、ElementwiseProduct(scaling=None,inputCol=None,outputCol=None)

计算inputCol与scaling内积，即相应元素的乘积,这个函数用于给列特征乘以相应的数.
由于不需要训练 所以直接transform
例子：

from pyspark.ml.linalg import Vectors
df = spark.createDataFrame([(Vectors.dense([2.0, 1.0, 3.0]),)], ["values"])
ep = ElementwiseProduct(scalingVer=Vectors.dense([1.0,2.0,3.0]),inputCol="values",outputCol="eprod")

5、Imputer(strategy=”mean”,missingValue=nan,inputCols=None,outputCols=None)

缺失值填补，默认使用均值或中值(“median”)填补，缺失值的计算是忽略缺失值的，目前不支持类别变量，只支持double和float类型
要计算均值所以要先 fit(),然后再transfrom(). 因此也有fitMultiple(dataset, paramMaps) paramMaps是一个参数序列表
其中对于fit函数:
fit(dataset,params=None) 如果params是参数的列表或者元组映射则返回一个模型列表.

df = spark.createDataFrame([(1.0, float("nan")), (2.0, float("nan")), (float("nan"), 3.0),
                             (4.0, 4.0), (5.0, 5.0)], ["a", "b"])
imputer = Imputer(inputCols=["a", "b"], outputCols=["out_a", "out_b"])
model = imputer.fit(df)

对于参数列表可以补充一点：

df = spark.createDataFrame([(1.0, float("nan")), (2.0, float("nan")), (float("nan"), 3.0),
                             (4.0, 4.0), (5.0, 5.0)], ["a", "b"])
#比如你的params可以设置为：
para=[{'strategy': 'mean','missingValue': 1,'inputCols': ['a','b'],'outputCols': ['out_a','out_b']},
{'strategy': 'median','missingValue': 0,'inputCols': ['a','b'],'outputCols': ['out_a','out_b']}]
imputer = Imputer(inputCols=["a", "b"], outputCols=["out_a", "out_b"])
model = imputer.fit(df,params=para)

然后你运行一次就可以fit出来两个模型 哈哈哈 这两个模型以列表的形式存储。

6、 pyspark.ml.feature.MaxAbsScaler(inputCol=None, outputCol=None)

标准化函数，将列标准化到[0,1]之间，将每一列的每一个值都除以本列的绝对值最大的数

但是列的对象必须是 pyspark.ml.linalg 中的Vectors.dense模式
要存储最大值最小值，利用到了数据框中的最大和最小值，所以要先fit 然后 transform()

7、pyspark.ml.feature.MinMaxScaler(min=0.0, max=1.0, inputCol=None, outputCol=None)

标准化函数，inputCol的形式为Vectors.dense的格式
先fit 然后再 transform
fit完之后可以通过model.originalMin取出每列的最小值
通过model.originalMax取出每列的最大值，然后使用这个最大最小值取transform
例子：

from pyspark.ml.linalg import Vectors
>>> df = spark.createDataFrame([(Vectors.dense([0.0]),), (Vectors.dense([2.0]),)], ["a"])
>>> mmScaler = MinMaxScaler(inputCol="a", outputCol="scaled")
>>> model = mmScaler.fit(df)
>>> model.originalMin
DenseVector([0.0])
>>> model.originalMax
DenseVector([2.0])

8、pyspark.ml.feature.Normalizer(p=2.0, inputCol=None, outputCol=None)[source]

对列进行正则标准化，也是使用Vectors.dense格式
不需要fit 直接transform

9、pyspark.ml.feature.PCA(k=None, inputCol=None, outputCol=None)

对特征进行PCA降维，使用为Vectors.dense格式
一样的道理 先 fit 再 transform
例如：

data = [(Vectors.sparse(5, [(1, 1.0), (3, 7.0)]),),
        (Vectors.dense([2.0, 0.0, 3.0, 4.0, 5.0]),),
        (Vectors.dense([4.0, 0.0, 0.0, 6.0, 7.0]),)]
df = spark.createDataFrame(data,["features"])
df.show()
pca = ft.PCA(k=2, inputCol="features", outputCol="pca_features")
model = pca.fit(df)

10、pyspark.ml.feature.PolynomialExpansion(degree=2, inputCol=None, outputCol=None)

适用与Verctors.dense格式
做特征变换，将特征拓展比如[x,y],如果degree=2,则拓展成[x,x*y,y,x*x,y*y]
所以直接transform 即可

11、 pyspark.ml.feature.QuantileDiscretizer(numBuckets=2, inputCol=None, outputCol=None, relativeError=0.001, handleInvalid=’error’)

将连续列进行分箱操作，numBuckets 表示分箱数目
只需要普通的数据框即可。
例子：

values = [(0.1,), (0.4,), (1.2,), (1.5,), (float("nan"),), (float("nan"),)]
df = spark.createDataFrame(values, ["values"])
df.show()
qds = ft.QuantileDiscretizer(numBuckets=2,inputCol="values", outputCol="buckets", relativeError=0.01, handleInvalid="error")
bucketizer = qds.fit(df)
qds.setHandleInvalid("keep").fit(df).transform(df).show()
qds.setHandleInvalid("skip").fit(df).transform(df).show()

12、pyspark.ml.feature.SQLTransformer(statement=None)

使用SQL语句创建新的列，直接transform()
比如：

df = spark.createDataFrame([(0, 1.0, 3.0), (2, 2.0, 5.0)], ["id", "v1", "v2"])
sqlTrans = SQLTransformer(statement="SELECT *, (v1 + v2) AS v3, (v1 * v2) AS v4 FROM __THIS__")
sqlTrans.transform(df).head()

这样就会增加两个新列

13、pyspark.ml.feature.StandardScaler(withMean=False, withStd=True, inputCol=None, outputCol=None)

对列进行标准化。
使用Vetors.dense() 先fit 再transform

14、 pyspark.ml.feature.Tokenizer(inputCol=None, outputCol=None)

将字符串列转换成小写并按空格切分
例子见官方文档

15、pyspark.ml.feature.VectorAssembler(inputCols=None, outputCol=None)

将多列聚合成一个向量列，这个多列就会变成DenseVector形式
所以直接transform 即可
例子：

df = spark.createDataFrame([(1, 0, 3)], ["a", "b", "c"])
>>> vecAssembler = VectorAssembler(inputCols=["a", "b", "c"], outputCol="features")
>>> vecAssembler.transform(df).head().features
DenseVector([1.0, 0.0, 3.0])
>>> vecAssembler.setParams(outputCol="freqs").transform(df).head().freqs
DenseVector([1.0, 0.0, 3.0])
>>> params = {vecAssembler.inputCols: ["b", "a"], vecAssembler.outputCol: "vector"}
>>> vecAssembler.transform(df, params).head().vector
DenseVector([0.0, 1.0])

16、pyspark.ml.feature.VectorIndexer(maxCategories=20, inputCol=None, outputCol=None, handleInvalid=’error’)

将每列中唯一值个数小于maxCategories的列转换成从0开始编码的类别列
适用Vectors.dense格式 先fit 再 transform。

from pyspark.ml.linalg import Vectors
>>> df = spark.createDataFrame([(Vectors.dense([-1.0, 0.0]),),
...     (Vectors.dense([0.0, 1.0]),), (Vectors.dense([0.0, 2.0]),)], ["a"])
>>> indexer = VectorIndexer(maxCategories=2, inputCol="a", outputCol="indexed")
>>> model = indexer.fit(df)
>>> model.transform(df).head().indexed
DenseVector([1.0, 0.0])
>>> model.numFeatures
2
>>> model.categoryMaps
{0: {0.0: 0, -1.0: 1}}
>>> indexer.setParams(outputCol="test").fit(df).transform(df).collect()[1].test
DenseVector([0.0, 1.0])
>>> params = {indexer.maxCategories: 3, indexer.outputCol: "vector"}
>>> model2 = indexer.fit(df, params)
>>> model2.transform(df).head().vector
DenseVector([1.0, 0.0])

17、pyspark.ml.feature.VectorSizeHint(inputCol=None, size=None, handleInvalid=’error’)
A feature transformer that adds size information to the metadata of a vector column. VectorAssembler needs size information for its input columns and cannot be used on streaming dataframes without this metadata.

>>> from pyspark.ml.linalg import Vectors
>>> from pyspark.ml import Pipeline, PipelineModel
>>> data = [(Vectors.dense([1., 2., 3.]), 4.)]
>>> df = spark.createDataFrame(data, ["vector", "float"])
>>>
>>> sizeHint = VectorSizeHint(inputCol="vector", size=3, handleInvalid="skip")
>>> vecAssembler = VectorAssembler(inputCols=["vector", "float"], outputCol="assembled")
>>> pipeline = Pipeline(stages=[sizeHint, vecAssembler])
>>>
>>> pipelineModel = pipeline.fit(df)
>>> pipelineModel.transform(df).head().assembled

18、 pyspark.ml.feature.VectorSlicer(inputCol=None, outputCol=None, indices=None, names=None)

翻译过来就是向量切片，返回Vector.dense中的下标对应的向量。

所以直接transform

>>> from pyspark.ml.linalg import Vectors
>>> df = spark.createDataFrame([
...     (Vectors.dense([-2.0, 2.3, 0.0, 0.0, 1.0]),),
...     (Vectors.dense([0.0, 0.0, 0.0, 0.0, 0.0]),),
...     (Vectors.dense([0.6, -1.1, -3.0, 4.5, 3.3]),)], ["features"])
>>> vs = VectorSlicer(inputCol="features", outputCol="sliced", indices=[1, 4])
>>> vs.transform(df).head().sliced

19、pyspark.ml.feature.Word2Vec(vectorSize=100, minCount=5, numPartitions=1, stepSize=0.025, maxIter=1, seed=None, inputCol=None, outputCol=None, windowSize=5, maxSentenceLength=1000)

即word2vec算法 将words转换成一个vectorSize维的向量