# This section contains code examples

# install python3
brew install python3

# run the `curl` command to download `get-pip.py`
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py

# install pip3
python3 get-pip.py

# install `fiddler-client` from the command line
# (or go to this [link](https://pypi.org/project/fiddler-client/) to download):

pip3 install fiddler-client

import fiddler as fdl

# NOTE: typically the API url for your running instance of Fiddler will be
# "https://xxxxx.fiddler.ai" (or "http://localhost:4100" for onebox). However, use
# "http://host.docker.internal:4100" as our URL if Jupyter is running in a docker
# VM on the same macOS machine as onebox
url = 'http://host.docker.internal:4100'

# see <Fiddler URL>/settings/credentials to find, create, or change this token
auth_token = '<FIDDLER_API_TOKEN>'

# see <Fiddler URL>/settings/general to find this id (listed as "Organization ID")
org_id = '<FIDDLER_ORG_ID>'

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

client.list_projects()

[
    'project_a',
    'project_b',
    'project_c'
]

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

my_project = 'example_project'
client.create_project(project_id=my_project)

{
    'project_name': 'example_project'
}

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

my_project = 'example_project'
client.delete_project(project_id=my_project)

true

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

my_project="example_project"
client.list_datasets(project_id=my_project)

[
    'dataset_a',
    'dataset_b',
    'dataset_c'
]

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
dataset_id = 'example_dataset'

df_schema = fdl.DatasetInfo.from_dataframe(pandas_df, max_inferred_cardinality=1000)

fdl.upload_dataset(
              project_id=project_id,
              dataset={'train': df_train,
                        'test': df_test},
              dataset_id=dataset_id,
              info=df_schema)

{
  'row_count': 9134,
  'col_count': 24,
  'log': [
      'Importing dataset example_dataset',
      'Creating table for example_dataset',
      'Importing data file: train.csv',
      'Importing data file: test.csv'
  ]
}

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

my_project = 'example_project'
my_dataset = 'example_dataset'

client.delete_dataset(project_id=my_project, model_id=my_model)

'Dataset deleted example_dataset'

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
dataset_id = 'example_dataset'

df_schema = client.get_dataset_info(project_id=project_id, dataset_id=dataset_id)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
query_str = r"""select * from "bank_churn"."bank_churn" limit 10"""

df_schema = client.get_slice(project_id=project_id, query_str=query_str)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

my_project="example_project"
client.list_models(project_id=my_project)

[
    'model_a',
    'model_b',
    'model_c'
]

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
model_id = 'example_model'
target = 'e_target'
continuous_features = ['con_a', 'con_b']
categorical_features = ['cat_a', 'cat_b']

feature_columns = list(continuous_features + categorical_features)
metadata_cols = ['meta']
decision_cols = ['high_value']
outputs = ['predicted_output']

model_info = fdl.ModelInfo.from_dataset_info(
            dataset_info=client.get_dataset_info(dataset_id),
            target=target,
            features=feature_columns,
            metadata_cols=metadata_cols,
            decision_cols=decision_cols,
            outputs=outputs,
            input_type=fdl.ModelInputType.TABULAR,
            model_task=fdl.ModelTask.REGRESSION,
            display_name='My Model',
            description='this is a model for the example',
)

client.register_model(project_id=project_id, model_id=model_id, dataset_id=dataset_id, model_info=model_info)

'Model successfully registered on Fiddler. \n Visit http://your-org.fiddler.ai/projects/example_project'

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
model_id = 'example_model'
artifact_path = Path('/tmp/foo')

client.upload_model_package(artifact_path=artifact_path,  # expects a model.yaml, package.py, and model.pkl
                            project_id='credit_underwriting',
                            model_id='lending')

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
model_id = 'example_model'
model_dir = Path('/tmp/foo')

client.update_model(project_id, model_id, model_dir)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

my_project = 'example_project'
my_model = 'example_model'

client.delete_model(project_id=my_project, model_id=my_model)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

my_project = 'example_project'
my_model = 'example_model'

client.get_model_info(project_id=my_project, model_id=my_model)

import fiddler as fdl
import pandas as pd

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id='example_project'
dataset_id='example_dataset'
model_id='example_model'

event_sample_df = client.get_dataset(dataset_id, splits=['test'], max_rows=10000)
event_sample_df = event_sample_df.sample(n=500).reset_index(drop=True)

# get prediction result
result = client.run_model(project_id, model_id, event_sample_df, log_events=False)
result_df = pd.concat([event_sample_df, result], axis=1)
result_df.head()

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id='example_project'
dataset_id='example_dataset'
model_id='example_model'

event_sample_df = client.get_dataset(dataset_id, splits=['test'], max_rows=10000)
event_sample_df = event_sample_df.sample(n=500).reset_index(drop=True)

# get prediction result
result = client.run_model(project_id, model_id, event_sample_df, log_events=False)
result_df = pd.concat([event_sample_df, result], axis=1)
result_df.head()

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

# calling feature importance with kwargs parameters
result = client.run_feature_importance('lending',
                                    'logreg-all',
                                    'p2p_loans',
                                    dataset_splits=('test.csv',),
                                    n_iterations=100,
                                    n_references=100,
                                    impact_not_importance=True,
                                    ci_confidence_level=0.99
                                    )

# using slice query
query_str = r"""select * from "p2p_loans"."logreg-all" where sub_grade = 'A3' limit 100"""

result = client.run_feature_importance('lending',
                                    'logreg-all',
                                    'p2p_loans',
                                    slice_query=query_str)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
model_id = 'example_model'
dataset_id = 'example_dataset'

client.trigger_pre_computation(project_id=project_id, model_id=model_id, dataset_id=dataset_id)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
dataset_id = 'example_dataset'
features = ['f_a', 'f_b', 'f_c', 'f_d']

result = client.get_mutual_information(project_id=project_id, dataset_id=dataset_id, features=features)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'census_income'
model_id = 'model_census_income'
dataset_id = 'census_income_data'

client.run_fairness(project_id=project_id,
                model_id=model_id,
                dataset_id=dataset_id,
                protected_features=['Sex'],
                positive_outcome=' >50K',
                slice_query=None,
                score_threshold=0.5)

# using slice query
slice_query = r"""SELECT * FROM census_income_data.model_census_income WHERE __source_file='test.csv'"""
client.run_fairness(project_id=project_id,
                model_id=model_id,
                dataset_id=dataset_id,
                protected_features=['Race', 'Sex'],
                positive_outcome=' >50K',
                slice_query=slice_query,
                score_threshold=0.5)

import fiddler as fdl
import pandas as pd

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id='example_project'
model_id='example_model'

# sample config info
{
    'min_bin_value': 3600, # possible values 300, 3600, 7200, 43200, 86400, 604800 secs
    'time_ranges': ['Day', 'Week', 'Month', 'Quarter', 'Year'],
    'default_time_range': 7200,
    'tag': 'anything you want'
}

client.add_monitoring_config(config_info=config, project_id=project_id, model_id=model_id)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

# publish_event to log prediction
client.publish_event(project_id='bank_churn',
                    model_id='bank_churn',
                    event = {
                       "CreditScore": 650,      # data type: int
                       "Geography": "France",   # data type: category
                       "Gender": "Female",
                       "Age": 45,
                       "Tenure": 2,
                       "Balance": 10000.0,      # data type: float
                       "NumOfProducts": 1,
                       "HasCrCard": "Yes",
                       "isActiveMember": "Yes",
                       "EstimatedSalary": 120000,
                       "probability_churned": 0.105
                       },
                    event_id='some_unique_id',   #optional
                    update_event=False,          #optional
                    event_time_stamp=1609462800000, #optional
                    dry_run=False
                    )

# publish_event to log label
client.publish_event(project_id='bank_churn',
                    model_id='bank_churn',
                    event = {
                        "Churn Result": 'Churned',  # data type: category
                        "Discount": 'True'',  # data type: category
                        },
                    event_id='some_unique_id', #optional
                    update_event=True, #optional
                    event_time_stamp=1609462800000      #optional
                    )

import fiddler as fdl
import pandas as pd

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
model_id = 'example_model'

event_log = pd.read_csv('./event_log.csv')
event_df = event_log.sample(n=100)

aws_par_file = 's3://bucket/events.parquet'
gcp_avro_file = 'gs://bucket/events.avro'
local_csv_file = 'event_log.csv'

batch_sources = [
event_df,        # Dataframe
aws_par_file,    # Parquet file hosted on S3
aws_csv_file,    # Avro file hosted on GCP
local_csv_file,  # CSV file on local disk
]

for batch_source in batch_sources:
    client.publish_events_batch(
                    project_id=project_id,
                    model_id=model_id,
                    batch_source=batch_source,
                    timestamp_field='timestamp')

%%writefile package.py

import pickle
from pathlib import Path
import pandas as pd

PACKAGE_PATH = Path(__file__).parent

"""
Here, we create a ModelPackage object that contains all the necessary
    components for the model to run smoothly.
"""

class ModelPackage:

    def __init__(self):
        """
        Here we can load in the model and any other necessary
            serialized objects from the PACKAGE_PATH.
        """

    def transform_input(self, input_df):
        """
        The transform_input() function let's us apply any necessary
            preprocessing to our input before feeding it into our model.
        It should return the transformed version of input_df.
        """

    def predict(self, input_df):
        """
        The predict() function should return a DataFrame of predictions
            whose columns correspond to the outputs of your model.

        For regression models, this DataFrame typically has a single column
            that stores the continuous output of your model.

        For binary classification models, this DataFrame typically has a
            single column that stores the probability prediction for the
            positive class.

        For multiclass classification models, this DataFrame typically has
            the same number of columns as it does classes (one for each
            class probability prediction).
        """


def get_model():
    return ModelPackage()

# Example `transform_input` with no changes made to the `input_dt`
def transform_input(self, input_df):
    return input_df

# Using existing Fiddler dataset to generate a fdl.ModelInfo object
import fiddler as fdl

model_info = fdl.ModelInfo.from_dataset_info(
    dataset_id=# your Fiddler dataset ID,
    dataset_info=# your Fiddler DatasetInfo object,
    target=# the name of your target column,
    outputs=# the names of your model output columns
)

# Storing ModelInfo as a YAML
import yaml

with open('model.yaml', 'w') as yaml_file:
    yaml.dump({'model': model_info.to_dict()}, yaml_file)

from pathlib import Path
# with the `sklearn_wrapper.py` file dropped into the top-level org directory
from ...sklearn_wrapper import SimpleSklearnModel

PACKAGE_PATH = Path(__file__).parent
MODEL_FILE_NAME = 'model.pkl'
PRED_COLUMN_NAMES = ['setosa', 'versicolor', 'virginica']

def get_model():
    return SimpleSklearnModel(PACKAGE_PATH / MODEL_FILE_NAME,
                              PRED_COLUMN_NAMES, is_classifier=True,
                              is_multiclass=True)

import pathlib
import pickle as pk
import pandas as pd
import tensorflow as tf
from tensorflow.keras.models import load_model
from tensorflow.keras.preprocessing.sequence import pad_sequences

MODEL_DIR = pathlib.Path(__file__).parent

SAVED_MODEL_PATH = MODEL_DIR / 'spam_keras.h5'
TOKENIZER_PATH = MODEL_DIR / 'tokenizer.pkl'

TEXT_FIELD = 'text'
OUTPUT_COLUMNS = ['spam_probability']

MAX_SEQUENCE_LENGTH = 50

class MyModel:
  def __init__(self):
      # load the tokenizer from a pickle file
      with open(TOKENIZER_PATH, 'rb') as handle:
       self.tokenizer = pk.load(handle)

      # create persistent TensorFlow session
      self.sess = tf.Session()

      # load model into that session
      with self.sess.as_default():
          self.model = load_model(SAVED_MODEL_PATH)

  def transform_input(self, input_df):
      # tokenize the raw string
      input_tokens = [self.tokenizer.texts_to_sequences([x])[0]
        for x in input_df[TEXT_FIELD].values]

      # pad the token list to fixed length
      input_tokens = pad_sequences(input_tokens, MAX_SEQUENCE_LENGTH)

      return pd.DataFrame(input_tokens.tolist())

  def predict(self, input_df):
      # transform the raw input
      transformed_input_df = self.transform_input(input_df)
      # apply model to transformed input
      with self.sess.as_default():
          predictions = self.model.predict(transformed_input_df)

      return pd.DataFrame(data=predictions, columns=OUTPUT_COLUMNS)

def get_model():
  return MyModel()

import pathlib
import pickle
import fastai.text
import pandas as pd
import torch
import torch.nn.functional as F
PACKAGE_PATH = pathlib.Path(__file__).parent
PREPROCESSOR_PATH = PACKAGE_PATH / 'preprocessor.pkl'
MODEL_WEIGHTS_PATH = PACKAGE_PATH / 'model_weights.pth'
OUTPUT_NAME = 'sentiment'
class MyModel:
    def load_model(self):
        # set up preprocessing functions
        with PREPROCESSOR_PATH.open('rb') as f:
            self.preprocessor = pickle.load(f)

        # load the fast.ai pytorch model and set to eval mode
        model = fastai.text.learner.get_text_classifier(
            arch=fastai.text.models.awd_lstm.AWD_LSTM,
            vocab_sz=,
            n_class=2)
        loaded_state_dict = torch.load(MODEL_WEIGHTS_PATH, map_location='cpu')
        state_dict = dict(zip(model.state_dict().keys(),
                              loaded_state_dict['model'].values()))
        model.load_state_dict(state_dict)
        model.eval()
        self.model = model
    def transform_input(self, input_df):
        return self.preprocessor(input_df)
    def predict(self, input_tensor):
        with torch.no_grad():
            pre_softmax_pred, _, _ = self.model.forward(input_tensor)
            pred = F.softmax(pre_softmax_pred, dim=1)[:, 1].numpy()
        return pd.DataFrame({OUTPUT_NAME: pred})

def get_model():
    return MyModel()

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

# administrators can share any project with someone else.. even though they do not OWN it
# project OWNER can unshare their project with someone lese.
res = client.share_project(project_name='bank_churn', role='READ', user_name='user1@fiddler.ai')

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

# administrators can unshare any project with someone else, even though they do not OWN it
# project OWNER can unshare their project with someone lese.
res = client.unshare_project(project_name='quickstart', role='WRITE', user_name='user2@fiddler.ai')

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

org_roles = client.list_org_roles()
print(json.dumps(org_roles, indent=2))

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_roles = client.list_project_roles('bank_churn')
print('users and teams and their roles on project: bank_churn', json.dumps(project_roles, indent=2))

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

teams = client.list_teams()
print(json.dumps(teams, indent=2))

class fdl.DatasetInfo()

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

df_schema = fdl.DatasetInfo.from_dataframe(df=pandas_df, max_inferred_cardinality=1000)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

dataset_info_obj = fdl.DatasetInfo.from_dataframe(df=pandas_df, max_inferred_cardinality=1000)

dataset_info_dict = dataset_info_obj.to_dict()

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

dataset_info_obj = fdl.DatasetInfo.from_dict(desrialized_json=dataset_info_dict)

class fdl.ModelInfo()

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

project_id = 'example_project'
model_id = 'example_model'
target = 'e_target'
continuous_features = ['con_a', 'con_b']
categorical_features = ['cat_a', 'cat_b']

feature_columns = list(continuous_features + categorical_features)
metadata_cols = ['meta']
decision_cols = ['high_value']
outputs = ['predicted_output']

model_info = fdl.ModelInfo.from_dataset_info(
            dataset_info=client.get_dataset_info(dataset_id),
            target=target,
            features=feature_columns,
            metadata_cols=metadata_cols,
            decision_cols=decision_cols,
            outputs=outputs,
            input_type=fdl.ModelInputType.TABULAR,
            model_task=fdl.ModelTask.REGRESSION,
            display_name='My Model',
            description='this is a model for the example',
)

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

model_info_obj = fdl.ModelInfo.from_dataframe(df=pandas_df, max_inferred_cardinality=1000)

model_info_dict = model_info_obj.to_dict()

import fiddler as fdl

client = fdl.FiddlerApi(url=url, org_id=org_id, auth_token=auth_token)

model_info_obj = fdl.ModelInfo.from_dict(desrialized_json=model_info_dict)

@enum.unique
class fdl.ModelInputType(enum.Enum)

import fiddler as fdl

model_input_tab = fdl.ModelInputType.TABULAR
model_input_text = fdl.ModelInputType.TEXT

@enum.unique
class fdl.ModelTask(enum.Enum)

import fiddler as fdl

model_task_binary = fdl.ModelTask.BINARY_CLASSIFICATION
model_task_multi = fdl.ModelTask.MULTICLASS_CLASSIFICATION
model_task_regression = fdl.ModelTask.REGRESSION