pyspark.ml package

ML Pipeline APIs

基于DataFrame的机器学习API，使用户可以快速组装和配置实用的机器学习管道。

class pyspark.ml.Transformer

将一个数据集转换为另一个数据集的变换器抽象类。

copy(extra=None)
使用相同的uid和一些额外的参数创建此实例的副本。默认实现使用copy.copy（）创建一个浅拷贝，然后复制嵌入的和额外的参数并返回拷贝。如果默认方法不够，子类应该重写此方法。
Parameters: extra – 额外的参数复制到新的实例
Returns: 这个实例的副本
explainParam(param)
解释单个参数，并以字符串形式返回其参数的名称、文档和可选的默认值以及用户提供的值。
explainParams()
返回所有参数的文档及其可选的默认值和用户提供的值。
extractParamMap(extra=None)
提取嵌入的默认参数值和用户提供的值，然后将它们与来自输入的额外值合并到平坦参数映射中，其中在存在冲突时使用后者的值，即，在排序时使用：默认参数值<用户提供值<extra。
Parameters: extra – 额外的参数值
Returns: merged param map
getOrDefault(param)
获取参数的值从用户提供的参数映射或其默认值。如果没有设置，则会引发错误。
getParam(paramName)
通过名字得到一个参数。
hasDefault(param)
检查该参数是否有默认值。
hasParam(paramName)
试此实例是否包含具有给定（字符串）名称的参数。
isDefined(param)
检查参数是否由用户明确设置或具有默认值。
isSet(param)
检查参数是否由用户明确设置。
params
返回按名称排序的所有参数。默认实现使用dir（）来获取Param类型的所有属性。
transform(dataset, params=None)
使用可选参数来转换输入的数据集。
Parameters:

dataset – 输入数据集，它是pyspark.sql.DataFrame的一个实例
params – 一个可选的参数映射，覆盖嵌入参数。
Returns: 转换后的数据集

class pyspark.ml.Estimator

适合数据模型的估计器抽象类。

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
fit(dataset, params=None)
使用可选参数将模型拟合到输入数据集。
Parameters:

dataset – 输入数据集，它是pyspark.sql.DataFrame的一个实例
params – 一个可选的参数映射，覆盖嵌入参数。如果给出了参数映射的列表/元组，则调用每个参数映射上的拟合并返回模型列表。
Returns: 拟合模型

getOrDefault(param)
getParam(paramName)
hasDefault(param)
hasParam(paramName)
isDefined(param)
isSet(param)
params

class pyspark.ml.Model

用估计量拟合的模型抽象类。

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
getOrDefault(param)
getParam(paramName)
hasDefault(param)
hasParam(paramName)
isDefined(param)
isSet(param)
params
transform(dataset, params=None)

class pyspark.ml.Pipeline(self, stages=None)

一个简单的管道(pipeline)，作为一个估计器(estimator)。管道由一系列阶段(stage)组成，每个阶段是估算器(Estimator)或变换器(Transformer)。当调用Pipeline.fit（）时，阶段按顺序执行。如果一个阶段是估算器，那么将在输入数据集上调用Estimator.fit（）方法来拟合模型。然后，将使用作为变换器的模型将数据集转换为下一阶段的输入。如果一个阶段是一个Transformer，它的Transformer.transform（）方法将被调用来产生下一个阶段的数据集。 Pipeline拟合的模型是一个PipelineModel，它由拟合的模型和变换器组成，与管道阶段相对应。如果阶段是一个空列表，那么这个管道就像一个身份转换器。

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
fit(dataset, params=None)
getOrDefault(param)
getParam(paramName)
getStages()
获取pipeline的阶段(stages)。
hasDefault(param)
hasParam(paramName)
isDefined(param)
isSet(param)
classmethod load(path)
从输入路径读取ML实例，read().load(path)的快捷方式。
params
classmethod read()
返回此类的MLReader实例。
save(path)
将这个ML实例保存到给定的路径，write().save(path)的快捷方式。
setParams(self, stages=None)
设置管道的参数。
setStages(value)
设置管道的阶段。
stages = Param(parent='undefined', name='stages', doc='a list of pipeline stages')
write()
为这个ML实例返回一个MLWriter实例。

class pyspark.ml.PipelineModel(stages)

表示一个带有变形器和拟合模型的编译管道。

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
getOrDefault(param)
getParam(paramName)
hasDefault(param)
hasParam(paramName)
isDefined(param)
isSet(param)
classmethod load(path)
params
classmethod read()
save(path)
transform(dataset, params=None)
write()

pyspark.ml.param module

class pyspark.ml.param.Param(parent, name, doc, typeConverter=None)

具有自包含文档的参数。

class pyspark.ml.param.Params

需要参数的组件。还提供了一个内部参数映射来存储附加到实例的参数值。

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
getOrDefault(param)
getParam(paramName)
hasDefault(param)
hasParam(paramName)
isDefined(param)
isSet(param)
params

class pyspark.ml.param.TypeConverters

Note: DeveloperApi
Param.typeConverter常用类型转换函数的工厂方法。

static identity(value)
只是返回值的虚拟转换器。
static toBoolean(value)
如果可能，将值转换为布尔值。
static toFloat(value)
如果可能，将值转换为浮点数。
static toInt(value)
如果可能，将值转换为int。
static toList(value)
如果可能，将值转换为列表。
static toListFloat(value)
如果可能的话，将值转换为浮点型列表。
static toListInt(value)
如果可能，将值转换为整数列表。
static toListString(value)
如果可能，将值转换为字符串列表。
static toString(value)
如果可能，将值转换为字符串。
static toVector(value)
如果可能，将值转换为MLlib向量。

pyspark.ml.feature module

class pyspark.ml.feature.Binarizer(self, threshold=0.0, inputCol=None, outputCol=None)

对给定阈值的一列连续特征进行二值化。
Binarizer（ML提供的二元化方法）二元化涉及的参数有inputCol（输入）、outputCol（输出）以及threshold（阀值）。（输入的）特征值大于阀值将映射为1.0，特征值小于等于阀值将映射为0.0。（Binarizer）支持向量（Vector）和双精度（Double）类型的输出

>>> df = spark.createDataFrame([(0.5,)], ["values"])
>>> binarizer = Binarizer(threshold=1.0, inputCol="values", outputCol="features")
>>> binarizer.transform(df).head().features
0.0
>>> binarizer.setParams(outputCol="freqs").transform(df).head().freqs
0.0
>>> params = {binarizer.threshold: -0.5, binarizer.outputCol: "vector"}
>>> binarizer.transform(df, params).head().vector
1.0
>>> binarizerPath = "/user/root/binarizer"
>>> binarizer.save(binarizerPath)
>>> loadedBinarizer = Binarizer.load(binarizerPath)
>>> loadedBinarizer.getThreshold() == binarizer.getThreshold()
True

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
getInputCol()
获取inputCol的值或其默认值。
getOrDefault(param)
getOutputCol()
getParam(paramName)
getThreshold()
获取阈值或其默认值。
hasDefault(param)
hasParam(paramName)
inputCol = Param(parent='undefined', name='inputCol', doc='input column name.')
isDefined(param)
isSet(param)
classmethod load(path)
outputCol = Param(parent='undefined', name='outputCol', doc='output column name.')
params
classmethod read()
save(path)
setInputCol(value)
设置inputCol的值。
setOutputCol(value)
设置outputCol的值。
setParams(self, threshold=0.0, inputCol=None, outputCol=None)
设置这个Binarizer的参数。
setThreshold(value)
设置阈值的值。
threshold = Param(parent='undefined', name='threshold', doc='threshold in binary classification prediction, in range [0, 1]')
transform(dataset, params=None)
write()
返回此ML实例的MLWriter实例。

class pyspark.ml.feature.BucketedRandomProjectionLSH(self, inputCol=None, outputCol=None, seed=None, numHashTables=1, bucketLength=None)

Note Experimental
欧几里德距离度量的LSH类。输入是密集的(dense)或稀疏的(sparse)矢量，每个矢量表示欧几里德距离空间中的一个点。输出将是可配置维度的向量。相同维度中的哈希值由相同的哈希函数计算。
LSH(Locality Sensitive Hashing)翻译成中文，叫做“局部敏感哈希”，它是一种针对海量高维数据的快速最近邻查找算法。

>>> from pyspark.ml.linalg import Vectors
>>> from pyspark.sql.functions import col
>>> data = [(0, Vectors.dense([-1.0, -1.0 ]),),
...         (1, Vectors.dense([-1.0, 1.0 ]),),
...         (2, Vectors.dense([1.0, -1.0 ]),),
...         (3, Vectors.dense([1.0, 1.0]),)]
>>> df = spark.createDataFrame(data, ["id", "features"])
>>> brp = BucketedRandomProjectionLSH(inputCol="features", outputCol="hashes",
...                                   seed=12345, bucketLength=1.0)
>>> model = brp.fit(df)
>>> model.transform(df).head()
Row(id=0, features=DenseVector([-1.0, -1.0]), hashes=[DenseVector([-1.0])])
>>> data2 = [(4, Vectors.dense([2.0, 2.0 ]),),
...          (5, Vectors.dense([2.0, 3.0 ]),),
...          (6, Vectors.dense([3.0, 2.0 ]),),
...          (7, Vectors.dense([3.0, 3.0]),)]
>>> df2 = spark.createDataFrame(data2, ["id", "features"])
>>> model.approxNearestNeighbors(df2, Vectors.dense([1.0, 2.0]), 1).collect()
[Row(id=4, features=DenseVector([2.0, 2.0]), hashes=[DenseVector([1.0])], distCol=1.0)]
>>> model.approxSimilarityJoin(df, df2, 3.0, distCol="EuclideanDistance").select(
...     col("datasetA.id").alias("idA"),
...     col("datasetB.id").alias("idB"),
...     col("EuclideanDistance")).show()
+---+---+-----------------+
|idA|idB|EuclideanDistance|
+---+---+-----------------+
|  3|  6| 2.23606797749979|
+---+---+-----------------+
...
>>> brpPath = "/user/root/brp"
>>> brp.save(brpPath)
>>> brp2 = BucketedRandomProjectionLSH.load(brpPath)
>>> brp2.getBucketLength() == brp.getBucketLength()
True
>>> modelPath = "/user/root/brp-model"
>>> model.save(modelPath)
>>> model2 = BucketedRandomProjectionLSHModel.load(modelPath)
>>> model.transform(df).head().hashes == model2.transform(df).head().hashes
True

bucketLength = Param(parent='undefined', name='bucketLength', doc='每个哈希桶的长度，更大的桶降低了假阴性率。')

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
fit(dataset, params=None)
使用可选参数将模型拟合到输入数据集。
getBucketLength()
获取bucketLength的值或其默认值。
getInputCol()
getNumHashTables()
获取numHashTables的值或其默认值。
getOrDefault(param)
getOutputCol()
getParam(paramName)
getSeed()
获取种子的值或其默认值。
hasDefault(param)
hasParam(paramName)
inputCol = Param(parent='undefined', name='inputCol', doc='输入列名称')
isDefined(param)
isSet(param)
classmethod load(path)
numHashTables = Param(parent='undefined', name='numHashTables', doc='哈希表的数量，散列表数量的增加降低了错误的否定率，并且降低它提高了运行性能')
outputCol = Param(parent='undefined', name='outputCol', doc='输出列名称')
params
classmethod read()
save(path)
seed = Param(parent='undefined', name='seed', doc='随机种子')
setBucketLength(value)
设置bucketLength的值。
setInputCol(value)
设置inputCol的值。
setNumHashTables(value)
设置numHashTables的值。
setOutputCol(value)
setParams(self, inputCol=None, outputCol=None, seed=None, numHashTables=1, bucketLength=None)
为此BucketedRandomProjectionLSH设置参数。
setSeed(value)
设置种子值。
write()

class pyspark.ml.feature.BucketedRandomProjectionLSHModel(java_model=None)

Note Experimental
模型由BucketedRandomProjectionLSH拟合，其中存储多个随机向量。向量被归一化为单位向量，并且每个向量被用在hash函数中hi(x)=floor(ri⋅x/bucketLength), ri是第i个随机单位向量。桶的数量将是（输入向量的最大L2范数）/ bucketLength。

approxNearestNeighbors(dataset, key, numNearestNeighbors, distCol='distCol')
给定一个大的数据集和一个项，最多可以找到距离这个项最近的k个项。如果outputCol丢失，该方法将转换数据; 如果outputCol存在，它将使用它。这可以在必要时缓存转换后的数据。
Parameters:

dataset - 在数据集中来搜索key的最近邻居。
key - 表示要搜索的项的特征向量。
numNearestNeighbors - 最近邻居的最大数量。
distCol - 输出列用于存储每个结果行与键之间的距离。如果没有指定，使用“distCol”作为默认值。
Returns: 一个最多包含k个项目的数据集。添加一列“distCol”以显示每一行与键之间的距离。

approxSimilarityJoin(datasetA, datasetB, threshold, distCol='distCol')
连接两个数据集以近似查找距离小于阈值的所有行对。如果outputCol丢失，该方法将转换数据; 如果outputCol存在，它将使用它。这可以在必要时缓存转换后的数据。
Parameters:

datasetA - One of the datasets to join.
datasetB - Another dataset to join.
threshold - 行对距离的阈值。
distCol - 输出列用于存储每对行之间的距离。如果没有指定，使用“distCol”作为默认值。
Returns: 包含行对的连接数据集。原始行在“datasetA”和“datasetB”列中，添加一列“distCol”以显示每对之间的距离。

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
getOrDefault(param)
getParam(paramName)
hasDefault(param)
hasParam(paramName)
isDefined(param)
isSet(param)
classmethod load(path)
params
save(path)
transform(dataset, params=None)
write()

class pyspark.ml.feature.Bucketizer(self, splits=None, inputCol=None, outputCol=None, handleInvalid="error")

将一列连续特征映射到一列特征桶。
Bucketizer将一列连续的特征转换为特征区间，区间由用户指定。
splits：分裂数为n+1时，将产生n个区间。除了最后一个区间外，每个区间范围［x,y］由分裂的x，y决定。分裂必须是严格递增的。在分裂指定外的值将被归为错误。

>>> values = [(0.1,), (0.4,), (1.2,), (1.5,), (float("nan"),), (float("nan"),)]
>>> df = spark.createDataFrame(values, ["values"])
>>> bucketizer = Bucketizer(splits=[-float("inf"), 0.5, 1.4, float("inf")],
...     inputCol="values", outputCol="buckets")
>>> bucketed = bucketizer.setHandleInvalid("keep").transform(df).collect()
>>> len(bucketed)
6
>>> bucketed[0].buckets
0.0
>>> bucketed[1].buckets
0.0
>>> bucketed[2].buckets
1.0
>>> bucketed[3].buckets
2.0
>>> bucketizer.setParams(outputCol="b").transform(df).head().b
0.0
>>> bucketizerPath = "/user/root/bucketizer"
>>> bucketizer.save(bucketizerPath)
>>> loadedBucketizer = Bucketizer.load(bucketizerPath)
>>> loadedBucketizer.getSplits() == bucketizer.getSplits()
True
>>> bucketed = bucketizer.setHandleInvalid("skip").transform(df).collect()
>>> len(bucketed)
4

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
getHandleInvalid()
获取handleInvalid的值或其默认值。
getInputCol()
getOrDefault(param)
getOutputCol()
getParam(paramName)
getSplits()
获取阈值或其默认值。
handleInvalid = Param(parent='undefined', name='handleInvalid', doc="如何处理无效条目。选项是“skip”（过滤出具有无效值的行），“error”（抛出错误）或“keep”（将无效值保存在特殊的附加存储桶中）。")
hasDefault(param)
hasParam(paramName)
inputCol = Param(parent='undefined', name='inputCol', doc='输入列名称')
isDefined(param)
isSet(param)
classmethod load(path)
params
save(path)
setHandleInvalid(value)
设置handleInvalid的值。
setInputCol(value)
setOutputCol(value)
setParams(self, splits=None, inputCol=None, outputCol=None, handleInvalid="error")
setSplits(value)
设置分割的值。
splits = Param(parent='undefined', name='splits', doc='用于将连续特征映射到桶中的分割点。用n + 1分割，有n个桶。由分割x，y定义的存储区保存除最后一个存储分区（也包括y）之外的范围[x，y]中的值。分割的长度应该大于等于3，并严格增加。必须明确提供-inf，inf处的值以涵盖所有Double值; 否则，指定拆分之外的值将被视为错误。')
transform(dataset, params=None)
write()

class pyspark.ml.feature.ChiSqSelector(self, numTopFeatures=50, featuresCol="features", outputCol=None, labelCol="label", selectorType="numTopFeatures", percentile=0.1, fpr=0.05, fdr=0.05, fwe=0.05)

ChiSqSelector代表卡方特征选择。它适用于带有类别特征的标签数据。ChiSqSelector根据独立卡方检验，然后选取类别标签主要依赖的特征。它类似于选取最有预测能力的特征。

Note Experimental
卡方特征选择，选择用于预测分类标签的分类特征。选择器支持不同的选择方法：numTopFeatures，percentile，fpr，fdr，fwe。
numTopFeatures通过卡方检验选取最具有预测能力的Top(num)个特征。
percentile类似于上一种方法，但是选取一小部分特征而不是固定(num)个特征。
fpr选择P值低于门限值的特征，这样就可以控制false positive rate来进行特征选择。
fdr使用Benjamini-Hochberg过程来选择虚假发现率低于阈值的所有特征。
我们选择p值低于阈值的所有特征。阈值由1 / numFeatures缩放，从而控制选择的家庭错误率。
默认情况下，选择方法是numTopFeatures，默认顶级要素数设置为50。

>>> 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
DenseVector([18.0])
>>> model.selectedFeatures
[2]
>>> chiSqSelectorPath ="/user/root/chi-sq-selector"
>>> selector.save(chiSqSelectorPath)
>>> loadedSelector = ChiSqSelector.load(chiSqSelectorPath)
>>> loadedSelector.getNumTopFeatures() == selector.getNumTopFeatures()
True
>>> modelPath = temp_path + "/chi-sq-selector-model"
>>> model.save(modelPath)
>>> loadedModel = ChiSqSelectorModel.load(modelPath)
>>> loadedModel.selectedFeatures == model.selectedFeatures
True

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
fdr = Param(parent='undefined', name='fdr', doc='预期错误发现率的上限。')
featuresCol = Param（parent ='undefined'，name ='featuresCol'，doc ='功能列名称。'）
fit(dataset, params=None)
fpr = Param(parent='undefined', name='fpr', doc='要保留的功能的最高p值.')
fwe = Param(parent='undefined', name='fwe', doc='预期的家庭错误率的上限。')
getFdr()
getFeaturesCol()
getFpr()
getFwe()
getLabelCol()
getNumTopFeatures()
getOrDefault(param)
getOutputCol()
getParam(paramName)
getPercentile()
getSelectorType()
hasDefault(param)
hasParam(paramName)
isDefined(param)
isSet(param)
labelCol = Param(parent='undefined', name='labelCol', doc='标签列名称。')
classmethod load(path)
numTopFeatures = Param(parent='undefined', name='numTopFeatures', doc='选择器将选择的功能数量，按升序的p值排序。如果要素的数量<numTopFeatures，那么这将选择所有要素。')
outputCol = Param(parent='undefined', name='outputCol', doc='输出列名称。')
params
percentile = Param(parent='undefined', name='percentile', doc='选择器将选择的特征的百分位数，按升序p值排序。')
classmethod read()
save(path)
selectorType = Param(parent='undefined', name='selectorType', doc=ChisqSelector的选择器类型。支持的选项：numTopFeatures（默认），percentile和fpr。')
setFdr(value)
setFeaturesCol(value)
setFpr(value)
setFwe(value)
setLabelCol(value)
setNumTopFeatures(value)
setOutputCol(value)
setParams(self, numTopFeatures=50, featuresCol="features", outputCol=None, labelCol="labels", selectorType="numTopFeatures", percentile=0.1, fpr=0.05, fdr=0.05, fwe=0.05)
setPercentile(value)
setSelectorType(value)
write()

class pyspark.ml.feature.ChiSqSelectorModel(java_model=None)

由ChiSqSelector装配的模型。

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
getOrDefault(param)
getParam(paramName)
hasDefault(param)
hasParam(paramName)
isDefined(param)
isSet(param)
classmethod load(path)
params
classmethod read()
save(path)
selectedFeatures
transform(dataset, params=None)
write()

class pyspark.ml.feature.CountVectorizer(self, minTF=1.0, minDF=1.0, vocabSize=1 << 18, binary=False, inputCol=None, outputCol=None)

从文档集合中提取词汇表并生成CountVectorizerModel。
CountVectorizer算法是将文本向量转换成稀疏表示的数值向量（字符频率向量）。CountVectorizer将会把频率高的单词排在前面。

>>> df = spark.createDataFrame(
...    [(0, ["a", "b", "c"]), (1, ["a", "b", "b", "c", "a"])],
...    ["label", "raw"])
>>> cv = CountVectorizer(inputCol="raw", outputCol="vectors")
>>> model = cv.fit(df)
>>> model.transform(df).show(truncate=False)
+-----+---------------+-------------------------+
|label|raw            |vectors                  |
+-----+---------------+-------------------------+
|0    |[a, b, c]      |(3,[0,1,2],[1.0,1.0,1.0])|
|1    |[a, b, b, c, a]|(3,[0,1,2],[2.0,2.0,1.0])|
+-----+---------------+-------------------------+
...
>>> sorted(model.vocabulary) == ['a', 'b', 'c']
True
>>> countVectorizerPath = "/count-vectorizer"
>>> cv.save(countVectorizerPath)
>>> loadedCv = CountVectorizer.load(countVectorizerPath)
>>> loadedCv.getMinDF() == cv.getMinDF()
True
>>> loadedCv.getMinTF() == cv.getMinTF()
True
>>> loadedCv.getVocabSize() == cv.getVocabSize()
True
>>> modelPath = "/count-vectorizer-model"
>>> model.save(modelPath)
>>> loadedModel = CountVectorizerModel.load(modelPath)
>>> loadedModel.vocabulary == model.vocabulary
True

binary = Param(parent='undefined', name='binary', doc='二进制切换来控制输出矢量值。如果为真，则所有非零计数（应用minTF滤波器后）均设置为1.对于模拟二进制事件而非整数计数的离散概率模型非常有用。默认为False')

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
fit(dataset, params=None)
getBinary()
getInputCol()
getMinDF()
getMinTF()
getOrDefault(param)
getOutputCol()
getParam(paramName)
getVocabSize()
hasDefault(param)
hasParam(paramName)
inputCol = Param(parent='undefined', name='inputCol', doc='输入列名称')
isDefined(param)
isSet(param)
classmethod load(path)
minDF = Param(parent='undefined', name='minDF', doc='指定词汇必须出现在词汇表中的最小数量的不同文档。如果这是一个大于等于1的整数，则它指定该术语必须出现的文档数; 如果这是[0,1）中的双精度值，那么这指定了文档的分数。默认1.0')
minTF = Param(parent='undefined', name='minTF', doc="筛选以忽略文档中的罕见词语。对于每个文档，频率/计数小于给定阈值的项被忽略。如果这是一个大于等于1的整数，那么这指定了一个计数（该术语必须出现在文档中的次数）; 如果这是[0,1）中的双精度值，那么这指定了一个分数（超出文档的标记计数）。请注意，该参数仅用于CountVectorizerModel的转换，并不影响拟合。默认1.0")
outputCol = Param(parent='undefined', name='outputCol', doc='输出列名称.')
params
classmethod read()
save(path)
setBinary(value)
setInputCol(value)
setMinDF(value)
setMinTF(value)
setOutputCol(value)
setParams(self, minTF=1.0, minDF=1.0, vocabSize=1 << 18, binary=False, inputCol=None, outputCol=None)
setVocabSize(value)
vocabSize = Param(parent='undefined', name='vocabSize', doc='词汇量的最大值。默认1 << 18。')
write()

class pyspark.ml.feature.CountVectorizerModel(java_model=None)

由CountVectorizer装配的模型。

copy(extra=None)
explainParam(param)
explainParams()
extractParamMap(extra=None)
getOrDefault(param)
getParam(paramName)
hasDefault(param)
hasParam(paramName)
isDefined(param)
isSet(param)
classmethod load(path)
params
classmethod read()
save(path)
transform(dataset, params=None)
vocabulary
write()

class pyspark.ml.feature.DCT(self, inverse=False, inputCol=None, outputCol=None)\

特征变换器，采用一个实矢量的一维离散余弦变换。在输入矢量上不执行零填充。它返回一个表示DCT的相同长度的实矢量。对返回矢量进行缩放，使得变换矩阵是单位的（又名缩放DCT-II）。
持续更新中。。。

Spark Python API Docs(part four)