oracle-ads 2.11.19__py3-none-any.whl → 2.12.1__py3-none-any.whl

ads/llm/requirements.txt

@@ -1,3 +1,3 @@
-langchain>=0.0.295
-pydantic>=1.10.13,<3
+langchain>=0.3
+pydantic>=2,<3
 typing-extensions>=4.2.0

ads/llm/serialize.py

@@ -12,7 +12,6 @@ from typing import Any, Dict, List, Optional
 import fsspec
 import yaml
 from langchain import llms
-from langchain.chains import RetrievalQA
 from langchain.chains.loading import load_chain_from_config
 from langchain.llms import loading
 from langchain.load.load import Reviver
@@ -21,7 +20,7 @@ from langchain.schema.runnable import RunnableParallel
 
 from ads.common.auth import default_signer
 from ads.common.object_storage_details import ObjectStorageDetails
-from ads.llm import GenerativeAI, ModelDeploymentTGI, ModelDeploymentVLLM
+from ads.llm import OCIModelDeploymentVLLM, OCIModelDeploymentTGI
 from ads.llm.chain import GuardrailSequence
 from ads.llm.guardrails.base import CustomGuardrailBase
 from ads.llm.serializers.runnable_parallel import RunnableParallelSerializer
@@ -29,9 +28,8 @@ from ads.llm.serializers.retrieval_qa import RetrievalQASerializer
 
 # This is a temp solution for supporting custom LLM in legacy load_chain
 __lc_llm_dict = llms.get_type_to_cls_dict()
-__lc_llm_dict[GenerativeAI.__name__] = lambda: GenerativeAI
-__lc_llm_dict[ModelDeploymentTGI.__name__] = lambda: ModelDeploymentTGI
-__lc_llm_dict[ModelDeploymentVLLM.__name__] = lambda: ModelDeploymentVLLM
+__lc_llm_dict[OCIModelDeploymentTGI.__name__] = lambda: OCIModelDeploymentTGI
+__lc_llm_dict[OCIModelDeploymentVLLM.__name__] = lambda: OCIModelDeploymentVLLM
 
 
 def __new_type_to_cls_dict():
@@ -47,7 +45,6 @@ custom_serialization = {
     GuardrailSequence: GuardrailSequence.save,
     CustomGuardrailBase: CustomGuardrailBase.save,
     RunnableParallel: RunnableParallelSerializer.save,
-    RetrievalQA: RetrievalQASerializer.save,
 }
 
 # Mapping _type to custom deserialization functions

ads/llm/templates/tool_chat_template_hermes.jinja

@@ -0,0 +1,130 @@
+{%- macro json_to_python_type(json_spec) %}
+    {%- set basic_type_map = {
+    "string": "str",
+    "number": "float",
+    "integer": "int",
+    "boolean": "bool"
+} %}
+
+    {%- if basic_type_map[json_spec.type] is defined %}
+        {{- basic_type_map[json_spec.type] }}
+    {%- elif json_spec.type == "array" %}
+        {{- "list[" +  json_to_python_type(json_spec|items) + "]" }}
+    {%- elif json_spec.type == "object" %}
+        {%- if json_spec.additionalProperties is defined %}
+            {{- "dict[str, " + json_to_python_type(json_spec.additionalProperties) + ']' }}
+        {%- else %}
+            {{- "dict" }}
+        {%- endif %}
+    {%- elif json_spec.type is iterable %}
+        {{- "Union[" }}
+        {%- for t in json_spec.type %}
+            {{- json_to_python_type({"type": t}) }}
+            {%- if not loop.last %}
+                {{- "," }}
+            {%- endif %}
+        {%- endfor %}
+        {{- "]" }}
+    {%- else %}
+        {{- "Any" }}
+    {%- endif %}
+{%- endmacro %}
+
+
+{{- bos_token }}
+{{- "<|im_start|>system\nYou are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> " }}
+{%- if tools is iterable and tools | length > 0 %}
+    {%- for tool in tools %}
+        {%- if tool.function is defined %}
+            {%- set tool = tool.function %}
+        {%- endif %}
+        {{- '{"type": "function", "function": ' }}
+        {{- '{"name": "' + tool.name + '", ' }}
+        {{- '"description": "' + tool.name + '(' }}
+        {%- for param_name, param_fields in tool.parameters.properties|items %}
+            {{- param_name + ": " + json_to_python_type(param_fields) }}
+            {%- if not loop.last %}
+                {{- ", " }}
+            {%- endif %}
+        {%- endfor %}
+        {{- ")" }}
+        {%- if tool.return is defined %}
+            {{- " -> " + json_to_python_type(tool.return) }}
+        {%- endif %}
+        {{- " - " + tool.description + "\n\n" }}
+        {%- for param_name, param_fields in tool.parameters.properties|items %}
+            {%- if loop.first %}
+                {{- "    Args:\n" }}
+            {%- endif %}
+            {{- "        " + param_name + "(" + json_to_python_type(param_fields) + "): " + param_fields.description|trim }}
+        {%- endfor %}
+        {%- if tool.return is defined and tool.return.description is defined %}
+            {{- "\n    Returns:\n        " + tool.return.description }}
+        {%- endif %}
+        {{- '"' }}
+        {{- ', "parameters": ' }}
+        {%- if tool.parameters.properties | length == 0 %}
+            {{- "{}" }}
+        {%- else %}
+            {{- tool.parameters|tojson }}
+        {%- endif %}
+        {{- "}" }}
+        {%- if not loop.last %}
+            {{- "\n" }}
+        {%- endif %}
+    {%- endfor %}
+{%- endif %}
+{{- " </tools>" }}
+{{- 'Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}}
+' }}
+{{- "For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
+" }}
+{{- "<tool_call>
+" }}
+{{- '{"name": <function-name>, "arguments": <args-dict>}
+' }}
+{{- '</tool_call><|im_end|>' }}
+{%- for message in messages %}
+    {%- if message.role == "user" or message.role == "system" or (message.role == "assistant" and message.tool_calls is not defined) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" and message.tool_calls is defined %}
+        {{- '<|im_start|>' + message.role }}
+        {%- for tool_call in message.tool_calls %}
+            {{- '\n<tool_call>\n' }}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '{' }}
+            {{- '"name": "' }}
+            {{- tool_call.name }}
+            {{- '"' }}
+            {%- if tool_call.arguments is defined %}
+                {{- ', ' }}
+                {{- '"arguments": ' }}
+                {{- tool_call.arguments|tojson }}
+            {%- endif %}
+            {{- '}' }}
+            {{- '\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>tool\n' }}
+        {%- endif %}
+        {{- '<tool_response>\n' }}
+        {{- message.content }}
+        {%- if not loop.last %}
+            {{- '\n</tool_response>\n' }}
+        {%- else %}
+            {{- '\n</tool_response>' }}
+        {%- endif %}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

ads/llm/templates/tool_chat_template_mistral_parallel.jinja

@@ -0,0 +1,94 @@
+{%- if messages[0]["role"] == "system" %}
+    {%- set system_message = messages[0]["content"] %}
+    {%- set loop_messages = messages[1:] %}
+{%- else %}
+    {%- set loop_messages = messages %}
+{%- endif %}
+{%- if not tools is defined %}
+    {%- set tools = none %}
+{%- endif %}
+{%- if tools is defined %}
+    {%- set parallel_tool_prompt = "You are a helpful assistant that can call tools. If you call one or more tools, format them in a single JSON array or objects, where each object is a tool call, not as separate objects outside of an array or multiple arrays. Use the format [{\"name\": tool call name, \"arguments\": tool call arguments}, additional tool calls] if you call more than one tool. If you call tools, do not attempt to interpret them or otherwise provide a response until you receive a tool call result that you can interpret for the user." %}
+    {%- if system_message is defined %}
+        {%- set system_message = parallel_tool_prompt + "\n\n" + system_message %}
+    {%- else %}
+        {%- set system_message = parallel_tool_prompt %}
+    {%- endif %}
+{%- endif %}
+{%- set user_messages = loop_messages | selectattr("role", "equalto", "user") | list %}
+
+{%- for message in loop_messages | rejectattr("role", "equalto", "tool") | rejectattr("role", "equalto", "tool_results") | selectattr("tool_calls", "undefined") %}
+    {%- if (message["role"] == "user") != (loop.index0 % 2 == 0) %}
+        {{- raise_exception("After the optional system message, conversation roles must alternate user/assistant/user/assistant/...") }}
+    {%- endif %}
+{%- endfor %}
+
+{{- bos_token }}
+{%- for message in loop_messages %}
+    {%- if message["role"] == "user" %}
+        {%- if tools is not none and (message == user_messages[-1]) %}
+            {{- "[AVAILABLE_TOOLS] [" }}
+            {%- for tool in tools %}
+                {%- set tool = tool.function %}
+                {{- '{"type": "function", "function": {' }}
+                {%- for key, val in tool.items() if key != "return" %}
+                    {%- if val is string %}
+                        {{- '"' + key + '": "' + val + '"' }}
+                    {%- else %}
+                        {{- '"' + key + '": ' + val|tojson }}
+                    {%- endif %}
+                    {%- if not loop.last %}
+                        {{- ", " }}
+                    {%- endif %}
+                {%- endfor %}
+                {{- "}}" }}
+                {%- if not loop.last %}
+                    {{- ", " }}
+                {%- else %}
+                    {{- "]" }}
+                {%- endif %}
+            {%- endfor %}
+            {{- "[/AVAILABLE_TOOLS]" }}
+        {%- endif %}
+        {%- if loop.last and system_message is defined %}
+            {{- "[INST] " + system_message + "\n\n" + message["content"] + "[/INST]" }}
+        {%- else %}
+            {{- "[INST] " + message["content"] + "[/INST]" }}
+        {%- endif %}
+    {%- elif message["role"] == "tool_calls" or message.tool_calls is defined %}
+        {%- if message.tool_calls is defined %}
+            {%- set tool_calls = message.tool_calls %}
+        {%- else %}
+            {%- set tool_calls = message.content %}
+        {%- endif %}
+        {{- "[TOOL_CALLS] [" }}
+        {%- for tool_call in tool_calls %}
+            {%- set out = tool_call.function|tojson %}
+            {{- out[:-1] }}
+            {%- if not tool_call.id is defined or tool_call.id|length < 9 %}
+                {{- raise_exception("Tool call IDs should be alphanumeric strings with length >= 9! (1)" + tool_call.id) }}
+            {%- endif %}
+            {{- ', "id": "' + tool_call.id[-9:] + '"}' }}
+            {%- if not loop.last %}
+                {{- ", " }}
+            {%- else %}
+                {{- "]" + eos_token }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif message["role"] == "assistant" %}
+        {{- " " + message["content"] + eos_token }}
+    {%- elif message["role"] == "tool_results" or message["role"] == "tool" %}
+        {%- if message.content is defined and message.content.content is defined %}
+            {%- set content = message.content.content %}
+        {%- else %}
+            {%- set content = message.content %}
+        {%- endif %}
+        {{- '[TOOL_RESULTS] {"content": ' + content|string + ", " }}
+        {%- if not message.tool_call_id is defined or message.tool_call_id|length < 9 %}
+            {{- raise_exception("Tool call IDs should be alphanumeric strings with length >= 9! (2)" + message.tool_call_id) }}
+        {%- endif %}
+        {{- '"call_id": "' + message.tool_call_id[-9:] + '"}[/TOOL_RESULTS]' }}
+    {%- else %}
+        {{- raise_exception("Only user and assistant roles are supported, with the exception of an initial optional system message!") }}
+    {%- endif %}
+{%- endfor %}

ads/opctl/operator/lowcode/anomaly/const.py

@@ -11,10 +11,15 @@ from ads.opctl.operator.lowcode.common.const import DataColumns
 class SupportedModels(str, metaclass=ExtendedEnumMeta):
     """Supported anomaly models."""
 
-    AutoMLX = "automlx"
     AutoTS = "autots"
     Auto = "auto"
-    # TODS = "tods"
+    IQR = "iqr"
+    LOF = "lof"
+    ZSCORE = "zscore"
+    ROLLING_ZSCORE = "rolling_zscore"
+    MAD = "mad"
+    EE = "ee"
+    ISOLATIONFOREST = "isolationforest"
 
 class NonTimeADSupportedModels(str, metaclass=ExtendedEnumMeta):
     """Supported non time-based anomaly detection models."""

ads/opctl/operator/lowcode/anomaly/model/autots.py

@@ -4,50 +4,51 @@
 # Copyright (c) 2023, 2024 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
-import pandas as pd
-
 from ads.common.decorator.runtime_dependency import runtime_dependency
-
-from .base_model import AnomalyOperatorBaseModel
-from .anomaly_dataset import AnomalyOutput
 from ads.opctl.operator.lowcode.anomaly.const import OutputColumns
+from .anomaly_dataset import AnomalyOutput
+from .base_model import AnomalyOperatorBaseModel
+from ..const import SupportedModels
+from ads.opctl import logger
 
 
 class AutoTSOperatorModel(AnomalyOperatorBaseModel):
     """Class representing AutoTS Anomaly Detection operator model."""
+    model_mapping = {
+        "isolationforest": "IsolationForest",
+        "lof": "LOF",
+        "ee": "EE",
+        "zscore": "zscore",
+        "rolling_zscore": "rolling_zscore",
+        "mad": "mad",
+        "minmax": "minmax",
+        "iqr": "IQR"
+    }
 
     @runtime_dependency(
         module="autots",
         err_msg=(
-            "Please run `pip3 install autots` to "
-            "install the required dependencies for AutoTS."
+                "Please run `pip3 install autots` to "
+                "install the required dependencies for AutoTS."
         ),
     )
     def _build_model(self) -> AnomalyOutput:
         from autots.evaluator.anomaly_detector import AnomalyDetector
 
-        method = self.spec.model_kwargs.get("method")
-        transform_dict = self.spec.model_kwargs.get("transform_dict", {})
-
-        if method == "random" or method == "deep" or method == "fast":
-            new_params = AnomalyDetector.get_new_params(method=method)
-            transform_dict = new_params.pop("transform_dict")
-
-            for key, value in new_params.items():
-                self.spec.model_kwargs[key] = value
-
-        if self.spec.model_kwargs.get("output") is None:
-            self.spec.model_kwargs["output"] = "univariate"
-
-        if "transform_dict" not in self.spec.model_kwargs:
-            self.spec.model_kwargs["transform_dict"] = transform_dict
-
-        if self.spec.contamination != 0.1:  # TODO: remove hard-coding
-            self.spec.model_kwargs.get("method_params", {})[
-                "contamination"
-            ] = self.spec.contamination
-
-        model = AnomalyDetector(**self.spec.model_kwargs)
+        method = SupportedModels.ISOLATIONFOREST if self.spec.model == SupportedModels.AutoTS else self.spec.model
+        model_params = {"method": self.model_mapping[method],
+                        "transform_dict": self.spec.model_kwargs.get("transform_dict", {}),
+                        "output": self.spec.model_kwargs.get("output", "univariate"), "method_params": {}}
+        # Supported methods with contamination param
+        if method in [SupportedModels.ISOLATIONFOREST, SupportedModels.LOF, SupportedModels.EE]:
+            model_params["method_params"][
+                "contamination"] = self.spec.contamination if self.spec.contamination else 0.01
+        else:
+            if self.spec.contamination:
+                raise ValueError(f"The contamination parameter is not supported for the selected model \"{method}\"")
+        logger.info(f"model params: {model_params}")
+
+        model = AnomalyDetector(**model_params)
 
         date_column = self.spec.datetime_column.name
 
@@ -55,9 +56,7 @@ class AutoTSOperatorModel(AnomalyOperatorBaseModel):
 
         for target, df in self.datasets.full_data_dict.items():
             data = df.set_index(date_column)
-
             (anomaly, score) = model.detect(data)
-
             if len(anomaly.columns) == 1:
                 score.rename(
                     columns={score.columns.values[0]: OutputColumns.SCORE_COL},
@@ -65,19 +64,15 @@ class AutoTSOperatorModel(AnomalyOperatorBaseModel):
                 )
                 score = 1 - score
                 score = score.reset_index(drop=False)
-
                 col = anomaly.columns.values[0]
                 anomaly[col] = anomaly[col].replace({1: 0, -1: 1})
                 anomaly.rename(columns={col: OutputColumns.ANOMALY_COL}, inplace=True)
                 anomaly = anomaly.reset_index(drop=False)
-
                 anomaly_output.add_output(target, anomaly, score)
-
             else:
                 raise NotImplementedError(
                     "Multi-Output Anomaly Detection is not yet supported in autots"
                 )
-
         return anomaly_output
 
     def _generate_report(self):

ads/opctl/operator/lowcode/anomaly/model/factory.py

@@ -4,18 +4,14 @@
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 from ads.opctl.operator.lowcode.anomaly.utils import select_auto_model
-
-from ..const import NonTimeADSupportedModels, SupportedModels
-from ..operator_config import AnomalyOperatorConfig
 from .anomaly_dataset import AnomalyDatasets
-from .automlx import AutoMLXOperatorModel
 from .autots import AutoTSOperatorModel
-
-# from .tods import TODSOperatorModel
 from .base_model import AnomalyOperatorBaseModel
 from .isolationforest import IsolationForestOperatorModel
 from .oneclasssvm import OneClassSVMOperatorModel
 from .randomcutforest import RandomCutForestOperatorModel
+from ..const import NonTimeADSupportedModels, SupportedModels
+from ..operator_config import AnomalyOperatorConfig
 
 
 class UnSupportedModelError(Exception):
@@ -45,9 +41,14 @@ class AnomalyOperatorModelFactory:
     """
 
     _MAP = {
-        SupportedModels.AutoMLX: AutoMLXOperatorModel,
-        # SupportedModels.TODS: TODSOperatorModel,
         SupportedModels.AutoTS: AutoTSOperatorModel,
+        SupportedModels.IQR: AutoTSOperatorModel,
+        SupportedModels.LOF: AutoTSOperatorModel,
+        SupportedModels.ISOLATIONFOREST: AutoTSOperatorModel,
+        SupportedModels.ZSCORE: AutoTSOperatorModel,
+        SupportedModels.ROLLING_ZSCORE: AutoTSOperatorModel,
+        SupportedModels.EE: AutoTSOperatorModel,
+        SupportedModels.MAD: AutoTSOperatorModel
     }
 
     _NonTime_MAP = {

ads/opctl/operator/lowcode/anomaly/schema.yaml

@@ -364,15 +364,21 @@ spec:
         - oneclasssvm
         - isolationforest
         - randomcutforest
+        - iqr
+        - lof
+        - zscore
+        - rolling_zscore
+        - mad
+        - ee
       meta:
         description: "The model to be used for anomaly detection"
 
     contamination:
       required: false
-      default: 0.1
+      default: 0.01
       type: float
       meta:
-        description: "Fraction of training dataset corresponding to anomalies (between 0.0 and 0.5)"
+        description: "The proportion of outliers in the data set. The contamination should be in the range (0, 0.5]"
 
     model_kwargs:
       type: dict

ads/opctl/operator/lowcode/forecast/MLoperator

@@ -2,12 +2,12 @@ type: forecast
 version: v1
 name: Forecasting Operator
 conda_type: service
-conda: forecast_p38_cpu_v1
+conda: forecast_p310_cpu_x86_64_v4
 gpu: no
 jobs_default_params:
   shape_name: VM.Standard.E4.Flex
-  ocpus: 32
-  memory_in_gbs: 512
+  ocpus: 16
+  memory_in_gbs: 256
   block_storage_size_in_GBs: 512
 keywords:
   - Prophet

ads/opctl/operator/lowcode/forecast/model/automlx.py

@@ -49,7 +49,7 @@ class AutoMLXOperatorModel(ForecastOperatorBaseModel):
         time_budget = model_kwargs_cleaned.pop("time_budget", -1)
         model_kwargs_cleaned[
             "preprocessing"
-        ] = self.spec.preprocessing or model_kwargs_cleaned.get("preprocessing", True)
+        ] = self.spec.preprocessing.enabled or model_kwargs_cleaned.get("preprocessing", True)
         return model_kwargs_cleaned, time_budget
 
     def preprocess(self, data, series_id=None):  # TODO: re-use self.le for explanations

ads/opctl/operator/lowcode/forecast/model/forecast_datasets.py

@@ -68,7 +68,7 @@ class AdditionalData(AbstractData):
             add_dates.sort()
             if historical_data.get_max_time() > add_dates[-spec.horizon]:
                 raise DataMismatchError(
-                    f"The Historical Data ends on {historical_data.get_max_time()}. The additional data horizon starts on {add_dates[-spec.horizon]}. The horizon should have exactly {spec.horizon} dates after the Hisotrical at a frequency of {historical_data.freq}"
+                    f"The Historical Data ends on {historical_data.get_max_time()}. The additional data horizon starts on {add_dates[-spec.horizon]}. The horizon should have exactly {spec.horizon} dates after the Historical at a frequency of {historical_data.freq}"
                 )
             elif historical_data.get_max_time() != add_dates[-(spec.horizon + 1)]:
                 raise DataMismatchError(

{oracle_ads-2.11.19.dist-info → oracle_ads-2.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: oracle_ads
-Version: 2.11.19
+Version: 2.12.1
 Summary: Oracle Accelerated Data Science SDK
 Keywords: Oracle Cloud Infrastructure,OCI,Machine Learning,ML,Artificial Intelligence,AI,Data Science,Cloud,Oracle
 Author: Oracle Data Science
@@ -82,8 +82,10 @@ Requires-Dist: fiona<=1.9.6 ; extra == "geo"
 Requires-Dist: oracle_ads[viz] ; extra == "geo"
 Requires-Dist: transformers ; extra == "huggingface"
 Requires-Dist: tf-keras ; extra == "huggingface"
-Requires-Dist: langchain-community<0.0.32 ; extra == "llm"
-Requires-Dist: langchain>=0.1.10,<0.1.14 ; extra == "llm"
+Requires-Dist: langchain>=0.2 ; extra == "llm"
+Requires-Dist: langchain-community ; extra == "llm"
+Requires-Dist: langchain_openai ; extra == "llm"
+Requires-Dist: pydantic>=2,<3 ; extra == "llm"
 Requires-Dist: evaluate>=0.4.0 ; extra == "llm"
 Requires-Dist: ipython>=7.23.1, <8.0 ; extra == "notebook"
 Requires-Dist: ipywidgets~=7.6.3 ; extra == "notebook"
@@ -145,7 +147,7 @@ Requires-Dist: statsmodels>=0.14.1 ; extra == "testsuite" and ( python_version>=
 Requires-Dist: tables ; extra == "testsuite"
 Requires-Dist: tables>3.9.0 ; extra == "testsuite" and ( python_version>='3.9')
 Requires-Dist: xlrd>=1.2.0 ; extra == "testsuite"
-Requires-Dist: spacy>=3.4.2 ; extra == "text"
+Requires-Dist: spacy>=3.4.2,<3.8 ; extra == "text"
 Requires-Dist: wordcloud>=1.8.1 ; extra == "text"
 Requires-Dist: oracle_ads[viz] ; extra == "torch"
 Requires-Dist: torch ; extra == "torch"