oracle-ads 2.13.9rc0__py3-none-any.whl → 2.13.10rc0__py3-none-any.whl

ads/dataset/label_encoder.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2020, 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import bisect
+import numpy as np
+
+from collections import defaultdict
+from sklearn.base import TransformerMixin
+from sklearn.preprocessing import LabelEncoder
+
+
+class DataFrameLabelEncoder(TransformerMixin):
+    """
+    Label encoder for `pandas.DataFrame` and `dask.dataframe.core.DataFrame`.
+
+    Attributes
+    ----------
+    label_encoders : defaultdict
+        Holds the label encoder for each column.
+
+    Examples
+    --------
+    >>> import pandas as pd
+    >>> from ads.dataset.label_encoder import DataFrameLabelEncoder
+
+    >>> df = pd.DataFrame(data={'col1': [1, 2], 'col2': [3, 4]})
+    >>> le = DataFrameLabelEncoder()
+    >>> le.fit_transform(X=df)
+
+    """
+
+    def __init__(self):
+        """Initialize an instance of DataFrameLabelEncoder."""
+        self.label_encoders = defaultdict(LabelEncoder)
+
+    def fit(self, X: "pandas.DataFrame"):
+        """
+        Fits a DataFrameLabelEncoder.
+
+        Parameters
+        ----------
+        X : pandas.DataFrame
+            Target values.
+
+        Returns
+        -------
+        self : returns an instance of self.
+            Fitted label encoder.
+
+        """
+        for column in X.columns:
+            if X[column].dtype.name in ["object", "category", "bool"]:
+                X[column] = X[column].astype(str)
+                self.label_encoders[column] = LabelEncoder()
+                self.label_encoders[column].fit(X[column])
+                label_encoder_classes_ = [
+                    str(class_)
+                    for class_ in self.label_encoders[column].classes_.tolist()
+                ]
+                bisect.insort_left(label_encoder_classes_, "unknown")
+                label_encoder_classes_ = np.asarray(label_encoder_classes_)
+                self.label_encoders[column].classes_ = label_encoder_classes_
+        return self
+
+    def transform(self, X: "pandas.DataFrame"):
+        """
+        Transforms a dataset using the DataFrameLabelEncoder.
+
+        Parameters
+        ----------
+        X : pandas.DataFrame
+            Target values.
+
+        Returns
+        -------
+        pandas.DataFrame
+            Labels as normalized encodings.
+
+        """
+        categorical_columns = list(self.label_encoders.keys())
+        if len(categorical_columns) == 0:
+            return X
+
+        def _label_encode_with_unknown(name, series):
+            return self.label_encoders[name].transform(
+                series.map(lambda x: str(x)).map(
+                    lambda x: x
+                    if x in self.label_encoders[name].classes_
+                    else "unknown"
+                )
+            )
+
+        X[categorical_columns] = X[categorical_columns].apply(
+            lambda series: _label_encode_with_unknown(series.name, series)
+        )
+        return X

ads/dataset/mixin/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*--
+
+# Copyright (c) 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/

ads/dataset/mixin/dataset_accessor.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*--
+
+# Copyright (c) 2023 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+from typing import Tuple
+import pandas as pd
+from ads.dataset import progress
+
+from ads.type_discovery.typed_feature import TypedFeature
+
+class ADSDatasetAccessMixin:
+
+    def dataset(
+        self,
+        sampled_df=None,
+        shape=None,
+        name="",
+        description=None,
+        type_discovery=True,
+        types={},
+        metadata=None,
+        progress=progress.DummyProgressBar(),
+        transformer_pipeline=None,
+        interactive=False,
+        **kwargs,
+    ):
+        """Converts pandas DataFrame into ADS Dataset.
+
+        Parameters
+        ----------
+        sampled_df: pandas.DataFrame, optional
+            The sampled pandas DataFrame. Defaults to None.
+        shape: Tuple, optional
+            The shape of pandas DataFrame. Defaults to None.
+        name: str, optional
+            The name of ADS Dataset. Defaults to "".
+        description: str, optional
+            Text describing the dataset. Defaults to "".
+        type_discovery: bool. optional
+            If false, the data types of the dataframe are used as such.
+            By default, the dataframe columns are associated with the best suited data types. Associating the features
+            with the disovered datatypes would impact visualizations and model prediction. Defaults to True.
+        types: dict, optional
+            Dictionary of <feature_name> : <data_type> to override the data type of features. Defaults to {}.
+        metadata: dict, optional
+            The metadata of ADS Dataset. Defaults to None.
+        progress: dataset.progress.ProgressBar, optional
+            The progress bar for ADS Dataset. Defaults to progress.DummyProgressBar()
+        transformer_pipeline: datasets.pipeline.TransformerPipeline, optional
+            A pipeline of transformations done outside the sdk and need to be applied at the time of scoring
+        kwargs: additional keyword arguments that would be passed to underlying dataframe read API
+            based on the format of the dataset
+
+        Returns
+        -------
+        ADSDataset: 
+            An instance of ADSDataset
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> df = pd.read_csv(<path_to_csv>)
+        >>> ds = df.ads.dataset()
+        """
+        from ads.dataset.dataset import ADSDataset
+
+        return ADSDataset.from_dataframe(
+            df=self._obj,
+            sampled_df=sampled_df,
+            shape=shape,
+            name=name,
+            description=description,
+            type_discovery=type_discovery,
+            types=types,
+            metadata=metadata,
+            progress=progress,
+            transformer_pipeline=transformer_pipeline,
+            interactive=interactive,
+            **kwargs
+        )
+
+    def dataset_with_target(
+        self, 
+        target: str,
+        sampled_df: pd.DataFrame = None,
+        shape: Tuple[int, int] = None,
+        target_type: TypedFeature = None,
+        positive_class=None,
+        **kwargs,
+    ):
+        """Converts pandas DataFrame into ADS Dataset with target.
+
+        Parameters
+        ----------
+        target: str, optional
+            Name of the target in dataset.
+            If set an ADSDatasetWithTarget object is returned, otherwise an ADSDataset object is returned which can be
+            used to understand the dataset through visualizations
+        sampled_df: pandas.DataFrame, optional
+            The sampled pandas DataFrame. Defaults to None.
+        shape: Tuple, optional 
+            The shape of pandas DataFrame. Defaults to None.
+        target_type: TypedFeature, optional
+            The target type of ADS Dataset. Defaults to None.
+        positive_class: Any, optional
+            Label in target for binary classification problems which should be identified as positive for modeling.
+            By default, the first unique value is considered as the positive label.
+        kwargs: additional keyword arguments that would be passed to underlying dataframe read API
+            based on the format of the dataset
+
+        Returns
+        -------
+        ADSDatasetWithTarget: 
+            An instance of ADSDatasetWithTarget
+
+        Examples
+        --------
+        >>> import pandas as pd
+        >>> df = pd.read_csv(<path_to_csv>)
+        >>> ds = df.ads.dataset_with_target(target="target")
+        """
+        from ads.dataset.dataset_with_target import ADSDatasetWithTarget
+
+        return ADSDatasetWithTarget.from_dataframe(
+            df=self._obj,
+            target=target,
+            sampled_df=sampled_df,
+            shape=shape,
+            target_type=target_type,
+            positive_class=positive_class,
+            **kwargs
+        )

ads/dataset/pipeline.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+# -*- coding: utf-8; -*-
+
+# Copyright (c) 2020, 2022 Oracle and/or its affiliates.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
+
+import uuid
+
+from sklearn.pipeline import Pipeline
+
+from ads.dataset import helper
+
+
+class TransformerPipeline(Pipeline):
+    def __init__(self, steps):
+        assert len(steps) > 0, "steps is empty"
+        self.step_names = set()
+        steps = [self._get_step(step) for step in steps]
+        super(TransformerPipeline, self).__init__(steps=steps)
+
+    def add(self, transformer):
+        """
+        Add transformer to data transformation pipeline
+
+        Parameters
+        ----------
+        transformer: Union[TransformerMixin, tuple(str, TransformerMixin)]
+               if tuple, (name, transformer implementing transform)
+
+        """
+        step = self._get_step(transformer)
+        self.steps.append(step)
+
+    def _get_step(self, step):
+        """
+        Generate unique step name and transformer to add in pipeline.
+
+        Parameters
+        ----------
+        step: transformer instance implementing fit and transform methods
+
+        Retuns
+        ------
+        (unique_step_name, transformer) : tuple
+        """
+        if isinstance(step, tuple):
+            name = step[0]
+            step = step[1]
+        else:
+            name = step.__class__.__name__
+            step = step
+        if name in self.step_names:
+            name = name + "/" + str(uuid.uuid4())
+        self.step_names.add(name)
+        return name, step
+
+    def visualize(self):
+        helper.visualize_transformation(self)