#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import os
from typing import Any, Dict, List, Optional, Tuple, Type, Union, cast, TYPE_CHECKING
from pyspark import keyword_only, since, SparkContext
from pyspark.ml.base import Estimator, Model, Transformer
from pyspark.ml.param import Param, Params
from pyspark.ml.util import (
MLReadable,
MLWritable,
JavaMLWriter,
JavaMLReader,
DefaultParamsReader,
DefaultParamsWriter,
MLWriter,
MLReader,
JavaMLReadable,
JavaMLWritable,
)
from pyspark.ml.wrapper import JavaParams
from pyspark.ml.common import inherit_doc
from pyspark.sql.dataframe import DataFrame
if TYPE_CHECKING:
from pyspark.ml._typing import ParamMap, PipelineStage
from py4j.java_gateway import JavaObject
[docs]@inherit_doc
class Pipeline(Estimator["PipelineModel"], MLReadable["Pipeline"], MLWritable):
"""
A simple pipeline, which acts as an estimator. A Pipeline consists
of a sequence of stages, each of which is either an
:py:class:`Estimator` or a :py:class:`Transformer`. When
:py:meth:`Pipeline.fit` is called, the stages are executed in
order. If a stage is an :py:class:`Estimator`, its
:py:meth:`Estimator.fit` method will be called on the input
dataset to fit a model. Then the model, which is a transformer,
will be used to transform the dataset as the input to the next
stage. If a stage is a :py:class:`Transformer`, its
:py:meth:`Transformer.transform` method will be called to produce
the dataset for the next stage. The fitted model from a
:py:class:`Pipeline` is a :py:class:`PipelineModel`, which
consists of fitted models and transformers, corresponding to the
pipeline stages. If stages is an empty list, the pipeline acts as an
identity transformer.
.. versionadded:: 1.3.0
"""
stages: Param[List["PipelineStage"]] = Param(
Params._dummy(), "stages", "a list of pipeline stages"
)
_input_kwargs: Dict[str, Any]
@keyword_only
def __init__(self, *, stages: Optional[List["PipelineStage"]] = None):
"""
__init__(self, \\*, stages=None)
"""
super(Pipeline, self).__init__()
kwargs = self._input_kwargs
self.setParams(**kwargs)
[docs] def setStages(self, value: List["PipelineStage"]) -> "Pipeline":
"""
Set pipeline stages.
.. versionadded:: 1.3.0
Parameters
----------
value : list
of :py:class:`pyspark.ml.Transformer`
or :py:class:`pyspark.ml.Estimator`
Returns
-------
:py:class:`Pipeline`
the pipeline instance
"""
return self._set(stages=value)
[docs] @since("1.3.0")
def getStages(self) -> List["PipelineStage"]:
"""
Get pipeline stages.
"""
return self.getOrDefault(self.stages)
[docs] @keyword_only
@since("1.3.0")
def setParams(self, *, stages: Optional[List["PipelineStage"]] = None) -> "Pipeline":
"""
setParams(self, \\*, stages=None)
Sets params for Pipeline.
"""
kwargs = self._input_kwargs
return self._set(**kwargs)
def _fit(self, dataset: DataFrame) -> "PipelineModel":
stages = self.getStages()
for stage in stages:
if not (isinstance(stage, Estimator) or isinstance(stage, Transformer)):
raise TypeError("Cannot recognize a pipeline stage of type %s." % type(stage))
indexOfLastEstimator = -1
for i, stage in enumerate(stages):
if isinstance(stage, Estimator):
indexOfLastEstimator = i
transformers: List[Transformer] = []
for i, stage in enumerate(stages):
if i <= indexOfLastEstimator:
if isinstance(stage, Transformer):
transformers.append(stage)
dataset = stage.transform(dataset)
else: # must be an Estimator
model = stage.fit(dataset)
transformers.append(model)
if i < indexOfLastEstimator:
dataset = model.transform(dataset)
else:
transformers.append(cast(Transformer, stage))
return PipelineModel(transformers)
[docs] def copy(self, extra: Optional["ParamMap"] = None) -> "Pipeline":
"""
Creates a copy of this instance.
.. versionadded:: 1.4.0
Parameters
----------
extra : dict, optional
extra parameters
Returns
-------
:py:class:`Pipeline`
new instance
"""
if extra is None:
extra = dict()
that = Params.copy(self, extra)
stages = [stage.copy(extra) for stage in that.getStages()]
return that.setStages(stages)
[docs] @since("2.0.0")
def write(self) -> MLWriter:
"""Returns an MLWriter instance for this ML instance."""
allStagesAreJava = PipelineSharedReadWrite.checkStagesForJava(self.getStages())
if allStagesAreJava:
return JavaMLWriter(self) # type: ignore[arg-type]
return PipelineWriter(self)
[docs] @classmethod
@since("2.0.0")
def read(cls) -> "PipelineReader":
"""Returns an MLReader instance for this class."""
return PipelineReader(cls)
@classmethod
def _from_java(cls, java_stage: "JavaObject") -> "Pipeline":
"""
Given a Java Pipeline, create and return a Python wrapper of it.
Used for ML persistence.
"""
# Create a new instance of this stage.
py_stage = cls()
# Load information from java_stage to the instance.
py_stages: List["PipelineStage"] = [
JavaParams._from_java(s) for s in java_stage.getStages()
]
py_stage.setStages(py_stages)
py_stage._resetUid(java_stage.uid())
return py_stage
def _to_java(self) -> "JavaObject":
"""
Transfer this instance to a Java Pipeline. Used for ML persistence.
Returns
-------
py4j.java_gateway.JavaObject
Java object equivalent to this instance.
"""
gateway = SparkContext._gateway
assert gateway is not None and SparkContext._jvm is not None
cls = SparkContext._jvm.org.apache.spark.ml.PipelineStage
java_stages = gateway.new_array(cls, len(self.getStages()))
for idx, stage in enumerate(self.getStages()):
java_stages[idx] = cast(JavaParams, stage)._to_java()
_java_obj = JavaParams._new_java_obj("org.apache.spark.ml.Pipeline", self.uid)
_java_obj.setStages(java_stages)
return _java_obj
@inherit_doc
class PipelineWriter(MLWriter):
"""
(Private) Specialization of :py:class:`MLWriter` for :py:class:`Pipeline` types
"""
def __init__(self, instance: Pipeline):
super(PipelineWriter, self).__init__()
self.instance = instance
def saveImpl(self, path: str) -> None:
stages = self.instance.getStages()
PipelineSharedReadWrite.validateStages(stages)
PipelineSharedReadWrite.saveImpl(self.instance, stages, self.sc, path)
@inherit_doc
class PipelineReader(MLReader[Pipeline]):
"""
(Private) Specialization of :py:class:`MLReader` for :py:class:`Pipeline` types
"""
def __init__(self, cls: Type[Pipeline]):
super(PipelineReader, self).__init__()
self.cls = cls
def load(self, path: str) -> Pipeline:
metadata = DefaultParamsReader.loadMetadata(path, self.sc)
if "language" not in metadata["paramMap"] or metadata["paramMap"]["language"] != "Python":
return JavaMLReader(cast(Type["JavaMLReadable[Pipeline]"], self.cls)).load(path)
else:
uid, stages = PipelineSharedReadWrite.load(metadata, self.sc, path)
return Pipeline(stages=stages)._resetUid(uid)
@inherit_doc
class PipelineModelWriter(MLWriter):
"""
(Private) Specialization of :py:class:`MLWriter` for :py:class:`PipelineModel` types
"""
def __init__(self, instance: "PipelineModel"):
super(PipelineModelWriter, self).__init__()
self.instance = instance
def saveImpl(self, path: str) -> None:
stages = self.instance.stages
PipelineSharedReadWrite.validateStages(cast(List["PipelineStage"], stages))
PipelineSharedReadWrite.saveImpl(
self.instance, cast(List["PipelineStage"], stages), self.sc, path
)
@inherit_doc
class PipelineModelReader(MLReader["PipelineModel"]):
"""
(Private) Specialization of :py:class:`MLReader` for :py:class:`PipelineModel` types
"""
def __init__(self, cls: Type["PipelineModel"]):
super(PipelineModelReader, self).__init__()
self.cls = cls
def load(self, path: str) -> "PipelineModel":
metadata = DefaultParamsReader.loadMetadata(path, self.sc)
if "language" not in metadata["paramMap"] or metadata["paramMap"]["language"] != "Python":
return JavaMLReader(cast(Type["JavaMLReadable[PipelineModel]"], self.cls)).load(path)
else:
uid, stages = PipelineSharedReadWrite.load(metadata, self.sc, path)
return PipelineModel(stages=cast(List[Transformer], stages))._resetUid(uid)
[docs]@inherit_doc
class PipelineModel(Model, MLReadable["PipelineModel"], MLWritable):
"""
Represents a compiled pipeline with transformers and fitted models.
.. versionadded:: 1.3.0
"""
def __init__(self, stages: List[Transformer]):
super(PipelineModel, self).__init__()
self.stages = stages
def _transform(self, dataset: DataFrame) -> DataFrame:
for t in self.stages:
dataset = t.transform(dataset)
return dataset
[docs] def copy(self, extra: Optional["ParamMap"] = None) -> "PipelineModel":
"""
Creates a copy of this instance.
.. versionadded:: 1.4.0
:param extra: extra parameters
:returns: new instance
"""
if extra is None:
extra = dict()
stages = [stage.copy(extra) for stage in self.stages]
return PipelineModel(stages)
[docs] @since("2.0.0")
def write(self) -> MLWriter:
"""Returns an MLWriter instance for this ML instance."""
allStagesAreJava = PipelineSharedReadWrite.checkStagesForJava(
cast(List["PipelineStage"], self.stages)
)
if allStagesAreJava:
return JavaMLWriter(self) # type: ignore[arg-type]
return PipelineModelWriter(self)
[docs] @classmethod
@since("2.0.0")
def read(cls) -> PipelineModelReader:
"""Returns an MLReader instance for this class."""
return PipelineModelReader(cls)
@classmethod
def _from_java(cls, java_stage: "JavaObject") -> "PipelineModel":
"""
Given a Java PipelineModel, create and return a Python wrapper of it.
Used for ML persistence.
"""
# Load information from java_stage to the instance.
py_stages: List[Transformer] = [JavaParams._from_java(s) for s in java_stage.stages()]
# Create a new instance of this stage.
py_stage = cls(py_stages)
py_stage._resetUid(java_stage.uid())
return py_stage
def _to_java(self) -> "JavaObject":
"""
Transfer this instance to a Java PipelineModel. Used for ML persistence.
:return: Java object equivalent to this instance.
"""
gateway = SparkContext._gateway
assert gateway is not None and SparkContext._jvm is not None
cls = SparkContext._jvm.org.apache.spark.ml.Transformer
java_stages = gateway.new_array(cls, len(self.stages))
for idx, stage in enumerate(self.stages):
java_stages[idx] = cast(JavaParams, stage)._to_java()
_java_obj = JavaParams._new_java_obj(
"org.apache.spark.ml.PipelineModel", self.uid, java_stages
)
return _java_obj
@inherit_doc
class PipelineSharedReadWrite:
"""
Functions for :py:class:`MLReader` and :py:class:`MLWriter` shared between
:py:class:`Pipeline` and :py:class:`PipelineModel`
.. versionadded:: 2.3.0
"""
@staticmethod
def checkStagesForJava(stages: List["PipelineStage"]) -> bool:
return all(isinstance(stage, JavaMLWritable) for stage in stages)
@staticmethod
def validateStages(stages: List["PipelineStage"]) -> None:
"""
Check that all stages are Writable
"""
for stage in stages:
if not isinstance(stage, MLWritable):
raise ValueError(
"Pipeline write will fail on this pipeline "
+ "because stage %s of type %s is not MLWritable",
stage.uid,
type(stage),
)
@staticmethod
def saveImpl(
instance: Union[Pipeline, PipelineModel],
stages: List["PipelineStage"],
sc: SparkContext,
path: str,
) -> None:
"""
Save metadata and stages for a :py:class:`Pipeline` or :py:class:`PipelineModel`
- save metadata to path/metadata
- save stages to stages/IDX_UID
"""
stageUids = [stage.uid for stage in stages]
jsonParams = {"stageUids": stageUids, "language": "Python"}
DefaultParamsWriter.saveMetadata(instance, path, sc, paramMap=jsonParams)
stagesDir = os.path.join(path, "stages")
for index, stage in enumerate(stages):
cast(MLWritable, stage).write().save(
PipelineSharedReadWrite.getStagePath(stage.uid, index, len(stages), stagesDir)
)
@staticmethod
def load(
metadata: Dict[str, Any], sc: SparkContext, path: str
) -> Tuple[str, List["PipelineStage"]]:
"""
Load metadata and stages for a :py:class:`Pipeline` or :py:class:`PipelineModel`
Returns
-------
tuple
(UID, list of stages)
"""
stagesDir = os.path.join(path, "stages")
stageUids = metadata["paramMap"]["stageUids"]
stages = []
for index, stageUid in enumerate(stageUids):
stagePath = PipelineSharedReadWrite.getStagePath(
stageUid, index, len(stageUids), stagesDir
)
stage: "PipelineStage" = DefaultParamsReader.loadParamsInstance(stagePath, sc)
stages.append(stage)
return (metadata["uid"], stages)
@staticmethod
def getStagePath(stageUid: str, stageIdx: int, numStages: int, stagesDir: str) -> str:
"""
Get path for saving the given stage.
"""
stageIdxDigits = len(str(numStages))
stageDir = str(stageIdx).zfill(stageIdxDigits) + "_" + stageUid
stagePath = os.path.join(stagesDir, stageDir)
return stagePath