tikos 0.3.1

Tikos Platform Library

Tikos Reasoning Platform

Tikos Reasoning Platform harnesses the power of empirically established 2nd-generation AI and statistical toolsets to offer its users advanced 3rd-generation AI capabilities.

Copyright 2025 (C) Tikos Technologies Limited

How to access the platform

To get Alpha API keys, please register your request via https://tikos.tech/

Licence

Licensed 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.

Release Notes

1. v 0.0.7

   i. Added GetGraphStructure: Automatically extract graph Vertices and Edges that can be further refined by the user

   ii. Added GenerateGraph: Provide Tikos Reasoning Platform the refined graph Vertices and Edges to build the standard knowledge graph

   iii. Added GetGraph: Get the whole graph for an extraction request

   iv. Added GetGraphRelationships: Get relationships between two Vertexes

2. v 0.0.8

   i. Added GetGraphRetrieval: Retrieve query response along with the Graph relationships for the requested retrieve query

3. v 0.0.9

   i. Added GetGraphRetrievalWithDS: Retrieve query response along with the Graph relationships for the requested retrieve query with Graph Node data sets as JSON

4. v 0.1.0

   i. Added licence conditions

5. v 0.1.1

   i. Added ProcessExtractFile: Be able to extract data from a specific file and support JSON based extraction using jq based schemas

   ii. Modified ProcessExtract: Support JSON based extraction using jq based schemas

6. v0.1.1

   i. Added BuildSC: Generate the SequentialCollection knowledge structure for the associated graph Vertices from structured data sets

   ii. Added GetSimilarCase: Providing a Problem Space (PS) case, the Sequential collection will contact a basic binary (BIN, default) search or advanced binary (BINADV) search and return the most similar existing case. This does not perform any case adaptation

7. v0.1.4

   i. Added GetGraphStructurePerDoc: Accept a file names and generate NER JSON of the (submitted) file

   ii. Added GenerateGraphPerDoc: Accept a NER JSON object and create a graph of the (submitted) file

   iii. Added GenerateAutoGraph: Accept a list of file names, that will be used to generate the NER generation automatically and create a full graph

8. v0.1.6

   i. Amended GetGraphRetrieval: Accept optional file reference and base model reference

   ii. Amended GetGraphRetrievalWithDS: Accept optional file reference and base model reference

9. v0.1.7

   i. Added GetCustomerGraphRetrievalWithDS: Retrieve customer specific query with the Graph relationships for the requested retrieve query with Graph Node data sets as JSON

10. v0.1.8
    • Amended GenerateGraph, GenerateGraphPerDoc & GenerateAutoGraph: Accept graph generation Payload Configuration with the JSON format:

      {
        "overrideNER": "<True/False>",
        "filter": "<GRAPH CASE_TYPE ATTRIBUTE GENERATION CONFIG TEXT>"
      }
      

11. v0.1.9

    i. Amended GetGraphStructure, GetGraphStructurePerDoc, GenerateGraph, GenerateGraphPerDoc & GenerateAutoGraph: Accept the model-id configuration

12. v0.2.0

    i. Added GetReasoning: Generate Similarity Reasoning of a Solution for a given Sequential Collection Case

13. v0.2.1

    i. Added tikos.TikosClient, A generic client connector that orchestrates commonly used base functions. It has been developed to facilitate easy integration with other applications and supports multithreading.

    ii. Added addProcessFiles: Multithreading supported file processing function. Accepts: List of filenames and file paths as a tuple

    iii. Added addFileStreams: Multithreading supported file addition function. Accepts: List of filenames and file stream as a tuple

    iv. Added addProcessFileStreams: Multithreading supported combined file addition and processing function. Accepts: List of filenames and file stream as a tuple

    v. Added generateGraphStructures: Multithreading supported graph structure generation function. Accepts: List of filenames as contexes

    vi. Added createGraph: Multithreading supported graph creation function. Accepts: List of filenames as contexes

    vii. Added getGraph: Graph structure extraction function

    viii. Added getGraphRetrieval: Graph retrieval function, Accepts: Filenames as context and query

    ix. Added createSequentialCollection: Sequential Collection creation function. Accepts: Case-Type, Data File name as context and Weight Type

    x. Added generateReasoning: Sequential Collection reasoning function. Accepts: Case-Type, Data File name as context, problem space case as a JSON object string, Weight Type and Reasoning Type

14. v0.2.2

    i. Amended BuildSC: Accepts the Sequential Collection config (scConfig)

    ii. Amended tikos.TikosClient.createSequentialCollection: Accepts the Sequential Collection config (scConfig)

15. v0.2.3

    i. Added UploadModel: Upload trained Deep Neural Network model that need to embedded with TRP. PyTorch Based models are supported

    ii. Added UploadModelConfig: Upload of the configuration related to the Uploaded DNN model. Will accept the model param definition in JSON format as-well-as the model specification in YAML format

    iii. Added UploadModelCaseData: Upload of the selected Knowledge Cases (feature sets), that will build the initial Sequential Collection case base

    iv. Added ProcessModel: Process the upload DNN model with Synapses Logger embedding and dynamically creating the Sequential Collection case base

    v. Added tikos.TikosClient.uploadEmbeddingModel: Supports upload of the DNN model

    vi. Added tikos.TikosClient.uploadEmbeddingConfig: Supports upload of the DNN model configuration files

    vii. Added tikos.TikosClient.uploadModelCaseData: Upload of the selected Knowledge Cases (feature sets), that will build the initial Sequential Collection case base

    viii. Added tikos.TikosClient.processEmbeddedModel: Process the upload DNN model with Synapses Logger embedding and dynamically creating the Sequential Collection case base

16. v0.2.4

    i. Amended tikos.TikosClient.generateReasoning: Accepts base models' Neural Network Architecture types with param nType. Default is0.
    nType Types:
    0. Feedforward (deep) ANN
    1. Basic Transformer based ANN
    2. Modern Transformer based ANN

17. v0.3.0

    i. Added tikos.TikosClient.generateFMProfiling: Foundational Model Profiling function.
    
    We are pleased to announce the release of the generateFMProfiling function, a powerful new tool that enables evaluating and understanding the behavior of foundational models. This function provides a streamlined way to profile a models' responses to a given set of prompts.
    
    Overview
    The generateFMProfiling function enables developers to perform targeted deep analysis of a foundational models' decisioning process. By providing a list of prompts, you can quickly build the associated Sequential Collection cases and assess the models' performance, style, and content generation on specific topics. This is essential for pruning, fine-tuning, validation, and ensuring that the model aligns with your applications' controls and requirements.
    
    Functionality Details
    This functionality is designed for efficient and direct model interaction. It accepts a list of prompts (promptTextList) to a specified model (modelName) and captures its develop the Contextual Sequential Collection for future analysis. The inclusion of a keyword list allows for more granular assessment of the generated text.
    
    Key Parameters:
    * refCaseType: Specifies the case type for the profiling session, allowing for context-specific evaluations.
    * nType: Defines the network type to be used for the request.
    * modelName: The name of the foundational model to be profiled (e.g., meta-llama/Llama-3.2-1B).
    * promptTextList: A list of input strings to be sent to the model.
    * keyList: An optional list of keywords to check for within the model's responses, enabling targeted analysis.
    * tokenLen: Sets the maximum token length for the models' generated response.
    
    This functionality simplifies the process of gathering direct feedback from a model, making it an indispensable capability for any development lifecycle involving Foundational Models.
    
    
    ii. Added tikos.Tooling.generateFMProfileMatching: Foundational Model Profiling Matching tool.
    
    We are introducing the generateFMProfileMatching tooling function, an advanced tool designed to perform profile matching for foundational models. This function allows you to compare a model's output against reference profiles to evaluate similarity and alignment.
    
    Overview
    The generateFMProfileMatching tooling function is a sophisticated analysis tool that assesses how closely a foundational models' response traces align with a given context. By providing reference context and specifying reasoning types, you can systematically measure the models' ability to generate contextually relevant and consistent content. This is invaluable for tasks requiring high degrees of factual accuracy, style adherence, robustness, and safety compliance.
    
    Functionality Details
    This tooling function orchestrates a complex workflow where a foundational model is prompted, and its decisioning traces are matched against a reference profile. It uses contextual adaptation and similarity types to perform a deep, abductive analysis of the models' behavior.
    
    Key Parameters:
    * payloadId: A unique identifier for the matching task.
    * refdoc: The contextual document reference(s) to improve the contextual adaptation.
    * refCaseType: Specifies the case type for the profiling session, allowing for context-specific evaluations.
    * RType : Defines the reasoning types for the analysis (e.g., DEEPCAUSAL_PROFILE_PATTERN_ADV).
    * WType: Defines the processing work types for the analysis (e.g., PROFILING).
    * modelName: The name of the foundational model to be profiled (e.g., meta-llama/Llama-3.2-1B).
    * promptTextList: A list of input strings to be sent to the model.
    * tokenLen: Sets the maximum token length for the models' generated response.
    * nType : Defines the neural network type for the analysis (e.g., 2).
    * llmmodel / payloadconfig: Additional configuration options for specifying the LLM, and payload settings.
    
    By using generateFMProfileMatching, you can create robust, automated workflows for continuous model validation and performance monitoring.
    
    
    iii. Added tikos.Tooling.generateFMProfileGuardRailing: Foundational Model Profiling Guard Railing tool.
    
    We are excited to introduce the generateFMProfileGuardRailing tooling function, a new tool designed for advanced analysis and safety monitoring of foundational models. This function serves as a "guard rail" by systematically profiling a models' behavior against a given set of prompts and configurations.
    
    Overview
    The generateFMProfileGuardRailing function allows developers and researchers to assess how a specific foundational model, such as meta-llama/Llama-3.2-1B, responds to various inputs. By configuring different reasoning types, network settings, and other parameters, you can simulate diverse scenarios and analyse the models' performance, safety, and alignment in depth. This is a crucial step in ensuring model reliability and preventing unintended behavior before deployment. Moreover, this will allow business stakeholders to develop automation system controls.
    
    Functionality Details
    This tool accepts a list of prompts (promptTextList) to a specified model (modelName) and evaluates its responses based on a comprehensive configuration. It is designed to be highly flexible, accepting numerous parameters to tailor each profiling session to specific needs.
    
    Key Parameters:
    * payloadId: A unique identifier for the matching task.
    * refdoc: The contextual document reference(s) to improve the contextual adaptation.
    * refCaseType: Specifies the case type for the profiling session, allowing for context-specific evaluations.
    * RType : Defines the reasoning types for the analysis (e.g., DEEPCAUSAL_PROFILE_PATTERN_ADV).
    * WType: Defines the processing work types for the analysis (e.g., PROFILING).
    * modelName: The name of the foundational model to be profiled (e.g., meta-llama/Llama-3.2-1B).
    * promptTextList: A list of input strings to be sent to the model.
    * tokenLen: Sets the maximum token length for the models' generated response.
    * nType : Defines the neural network type for the analysis (e.g., 2).
    * llmmodel / payloadconfig: Additional configuration options for specifying the LLM, and payload settings.
    
    By leveraging generateFMProfileGuardRailing tooling, you can conduct targeted and repeatable experiments to build a robust profile of any foundational models' operational characteristics and deliver operational controls.
    
    
    

18. v0.3.1

    i. Added tikos.TikosClient.analyseModelRobustness: Deep learning model robustness analysis function.
    
    We are pleased to announce the release of the analyseModelRobustness function, a powerful new tool designed to provide a comprehensive robustness analysis for deep learning models. This function streamlines the process of evaluating model stability and performance under various conditions, furthermore this tool will provide analyse the model robustness including model and data drift probabilities.
    
    Overview
    The analyseModelRobustness function allows developers and data scientists to assess the reliability of their deep learning models by submitting them for a detailed analysis. By providing a simple JSON configuration, you can test one or more models against a specified dataset and receive a standardized report on their performance. This is a critical step for validating model quality and ensuring consistent behavior before deploying to production environments.
    
    Functionality Details
    This tool operates by accepting a single JSON string that contains all the necessary configuration for the analysis. It processes the specified models and returns a structured list of results, making it easy to compare and evaluate different models.
    
    Input
    The function accepts a single parameter, payloadJsonStr, which is a JSON formatted string. This string contains a list of models to be analysed.
    Example Input Payload:
    

      {
            "models": [
                {
                    "model_name": "Model 1",
                    "case_type": "iris flowers",
                    "target": "species",
                    "org_id": "tikos",
                    "input_features": [
                        "sepal_length",
                        "sepal_width",
                        "petal_length",
                        "petal_width"
                    ],
                    "session": {
                        "requestId": "tikos",
                        "authToken": "tikos"
                    },
                    "model_size": 0,
                    "test_data_filename": "file.csv"
                }
            ]
        }
    

    
    
    Output
    The function returns a list of dictionaries, with each dictionary containing the robustness report for one of the input models. The report includes an overall score and a breakdown of key performance metrics.
    Example Output:
    

      [
            {
                "NAME": "Model 1",
                "OVERALL SCORE": 0.8976,
                "METRICS": {
                    "ACCURACY": 0.9501,
                    "VARIANCE": 0.0234,
                    "EXECUTION TIME MINUTES": 1.52,
                    "SIZE KiB": 120.50
                }
            }
        ]
    

    
    
    
    This structured output allows for easy integration into automated testing pipelines and facilitates direct comparison between different models or versions. By leveraging `analyseModelRobustness`, you can build more reliable and predictable AI systems.
    
    
    
    
    
    ii. Added `tikos.TikosClient.analyseModelFeatureAssociation`: Deep Learning Model Feature Association Analysis.
    
    We are pleased to announce the release of the `analyseModelFeatureAssociation` function, a new tool designed to uncover and visualise the relationships between input features in your deep learning models.
    
    Overview
    The `analyseModelFeatureAssociation` function provides crucial insights into how different features behaves at the inference time of your models' predictions (not just input features correlate and interactions with each other). Understanding these algorithmic associations is vital for not just understanding the model's feature engineering, model interpretation, and identifying potential sources of bias; but also with these features now you can assess the Algorithmic Bias and Fairness of your model. By submitting a simple JSON configuration, you can generate a detailed analysis of these relationships for a given dataset.
    
    Functionality Details
    This tool is designed for ease of use, accepting a single JSON string that specifies the models' context, target variable, and dataset. It processes this information to perform a feature association analysis.
    
    Input
    The function accepts a single parameter, `payloadJsonStr`, which is a JSON formatted string containing the configuration for the analysis.
    Example Input Payload:
    

    {
        "visualizing_info": {
            "case_type": "cancer_type",
            "target": "net_survival",
            "org_id": "tikos",
            "input_features": [
                "cancer_type",
                "survival_type",
                "stage",
                "age_group",
                "sex",
                "survival_time_years",
                "number_of_patients"
            ],
            "session": {
                "requestId": "tikos",
                "authToken": "tikos"
            },
            "test_data_filename": "file.csv"
        }
    }
    

    
    
    By using `analyseModelFeatureAssociation`, process owners can assure the decioning models are not biased [at algorimic layer] & the decisions are fair; data scientists and developers can gain deeper insights into their model internals, leading to more robust and interpretable models.