ddi-fw 0.0.93__tar.gz → 0.0.95__tar.gz

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ddi_fw
-Version: 0.0.93
+Version: 0.0.95
 Summary: Do not use :)
 Author-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>
 Maintainer-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ddi_fw"
-version = "0.0.93"
+version = "0.0.95"
 description = "Do not use :)"
 readme = "README.md"
 authors = [

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/src/ddi_fw/ml/__init__.py

@@ -1,4 +1,5 @@
 from .ml_helper import MultiModalRunner
 from .model_wrapper import ModelWrapper,Result
 from .tensorflow_wrapper import TFModelWrapper
-from .pytorch_wrapper import PTModelWrapper
+from .pytorch_wrapper import PTModelWrapper
+from .evaluation_helper import evaluate

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/src/ddi_fw/ml/ml_helper.py

@@ -16,7 +16,7 @@ from mlflow.utils.autologging_utils import batch_metrics_logger
 import time
 
 from mlflow.models import infer_signature
-from ddi_fw.experiments.evaluation_helper import Metrics, evaluate
+from ddi_fw.ml.evaluation_helper import Metrics, evaluate
 
 # import tf2onnx
 # import onnx
@@ -24,9 +24,9 @@ from ddi_fw.experiments.evaluation_helper import Metrics, evaluate
 import itertools
 import ddi_fw.utils as utils
 
-tf.random.set_seed(1)
-np.random.seed(2)
-np.set_printoptions(precision=4)
+# tf.random.set_seed(1)
+# np.random.seed(2)
+# np.set_printoptions(precision=4)
 
 class MultiModalRunner:
     # todo model related parameters to config

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/src/ddi_fw/ml/model_wrapper.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Tuple
 
-from ddi_fw.experiments.evaluation_helper import Metrics
+from ddi_fw.ml.evaluation_helper import Metrics
 
 class Result:
     def __init__(self) -> None:

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/src/ddi_fw/ml/pytorch_wrapper.py

@@ -1,6 +1,6 @@
 import mlflow
 import torch
-from ddi_fw.experiments.evaluation_helper import evaluate
+from ddi_fw.ml.evaluation_helper import evaluate
 from ddi_fw.ml.model_wrapper import ModelWrapper
 
 

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/src/ddi_fw/ml/tensorflow_wrapper.py

@@ -1,24 +1,19 @@
-from matplotlib import pyplot as plt
 from ddi_fw.ml.model_wrapper import ModelWrapper
 import tensorflow as tf
 from tensorflow import keras
-from keras.models import Model, Sequential
-from keras.layers import Dense, Dropout, Input, Activation, BatchNormalization
-from keras.callbacks import EarlyStopping
+from keras.callbacks import EarlyStopping,ModelCheckpoint
 from sklearn.model_selection import train_test_split, KFold, StratifiedKFold
 import numpy as np
 
 import mlflow
 from mlflow.utils.autologging_utils import batch_metrics_logger
-import time
 
 from mlflow.models import infer_signature
-from ddi_fw.experiments.evaluation_helper import Metrics, evaluate
+from ddi_fw.ml.evaluation_helper import Metrics, evaluate
 
 # import tf2onnx
 # import onnx
 
-import itertools
 import ddi_fw.utils as utils
 
 
@@ -44,6 +39,15 @@ class TFModelWrapper(ModelWrapper):
                     X_valid_cv = self.train_data[val_idx]
                     y_valid_cv = self.train_label[val_idx]
 
+                    checkpoint = ModelCheckpoint(
+                        filepath=f'{self.descriptor}_validation_{i}.weights.h5',
+                        monitor='val_loss',
+                        save_best_only=True,
+                        save_weights_only=True,
+                        verbose=1,
+                        mode='min'
+                    )
+
                     early_stopping = EarlyStopping(
                         monitor='val_loss', patience=10, verbose=0, mode='auto')
                     custom_callback = CustomCallback()
@@ -52,15 +56,21 @@ class TFModelWrapper(ModelWrapper):
                                         epochs=self.epochs,
                                         validation_data=(
                                             X_valid_cv, y_valid_cv),
-                                        callbacks=[early_stopping, custom_callback])
+                                        callbacks=[early_stopping, checkpoint, custom_callback])
                     # histories[f'validation_{i}'] = history
-                    models_val_acc[f'validation_{i}'] = history.history['val_accuracy'][-1]
+                    # models_val_acc[f'validation_{i}'] = history.history['val_accuracy'][-1]
+                    models_val_acc[f'{self.descriptor}_validation_{i}'] = checkpoint.best
+                    models[f'{self.descriptor}_validation_{i}'] = checkpoint.model
+                    import os
+                    if os.path.exists(f'{self.descriptor}_validation_{i}.weights.h5'):
+                        os.remove(f'{self.descriptor}_validation_{i}.weights.h5')
                     # Saving each CV model
 
             best_model_key = max(models_val_acc, key=models_val_acc.get)
             best_model = models[best_model_key]
-            best_model.evaluate(self.test_data, self.test_label,
-                                callbacks=[custom_callback])
+            # mlflow.tensorflow.log_model(best_model, "model")
+            # best_model.evaluate(self.test_data, self.test_label,
+            #                     callbacks=[custom_callback])
             pred = best_model.predict(self.test_data)
 
             logs, metrics = evaluate(
@@ -68,17 +78,17 @@ class TFModelWrapper(ModelWrapper):
             metrics.format_float()
             mlflow.log_metrics(logs)
             mlflow.log_param('best_cv', best_model_key)
-            signature = infer_signature(
-                self.train_data,
-                # generate_signature_output(model,X_valid_cv)
-                # params=params,
-            )
-
-            mlflow.keras.save_model(
-                best_model,
-                path=run.info.artifact_uri + '/model',
-                signature=signature,
-            )
+            # signature = infer_signature(
+            #     self.train_data,
+            #     # generate_signature_output(model,X_valid_cv)
+            #     # params=params,
+            # )
+            
+            # mlflow.keras.save_model(
+            #     best_model,
+            #     path=run.info.artifact_uri + '/model',
+            #     signature=signature,
+            # )
             print(run.info.artifact_uri)
             # todo tf2onnx not compatible with keras > 2.15
             # onnx_model, _ = tf2onnx.convert.from_keras(

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/src/ddi_fw/pipeline/multi_pipeline.py

@@ -63,6 +63,7 @@ class MultiPipeline():
         columns = config.get("columns")
         ner_data_file = config.get("ner_data_file")
         ner_threshold = config.get("ner_threshold")
+        column_embedding_configs = config.get("column_embedding_configs")
         vector_db_persist_directory = config.get("vector_db_persist_directory")
         vector_db_collection_name = config.get("vector_db_collection_name")
         embedding_pooling_strategy = get_import(
@@ -93,6 +94,7 @@ class MultiPipeline():
                 tracking_uri=tracking_uri,
                 dataset_type=dataset_type,
                 columns=columns,
+                column_embedding_configs=column_embedding_configs,
                 vector_db_persist_directory=vector_db_persist_directory,
                 vector_db_collection_name=vector_db_collection_name,
                 embedding_pooling_strategy_type=embedding_pooling_strategy,
@@ -126,6 +128,7 @@ class MultiPipeline():
         for config in self.experiments_config['experiments']:
             item = self.__create_pipeline(config)
             self.items.append(item)
+        return self
 
     def run(self):
         for item in self.items:
@@ -134,9 +137,11 @@ class MultiPipeline():
             model_type = item['model_type']
             batch_size = item['batch_size']
             epochs = item['epochs']
+            # It can be moved to build function
             pipeline.build()
             result = pipeline.run(model_type, epochs=epochs, batch_size=batch_size)
             self.pipeline_resuts[item['name']] = result
+        return self
 
     def results(self):
         return self.pipeline_resuts

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/src/ddi_fw/pipeline/pipeline.py

@@ -21,6 +21,7 @@ class Pipeline:
                  dataset_type: BaseDataset = None,
                  columns=None,
                  embedding_dict=None,
+                 column_embedding_configs=None,
                  vector_db_persist_directory=None,
                  vector_db_collection_name=None,
                  embedding_pooling_strategy_type: PoolingStrategy = None,
@@ -37,6 +38,7 @@ class Pipeline:
         self.dataset_type = dataset_type
         self.columns = columns
         self.embedding_dict = embedding_dict
+        self.column_embedding_configs = column_embedding_configs
         self.vector_db_persist_directory = vector_db_persist_directory
         self.vector_db_collection_name = vector_db_collection_name
         self.embedding_pooling_strategy_type = embedding_pooling_strategy_type
@@ -45,6 +47,39 @@ class Pipeline:
         self.combinations = combinations
         self.model = model
 
+    def __create_or_update_embeddings__(embedding_dict, vector_db_persist_directory, vector_db_collection_name, column):
+        """
+        Fetch embeddings and metadata from a persistent Chroma vector database and update the provided embedding_dict.
+
+        Args:
+        - vector_db_persist_directory (str): The path to the directory where the Chroma vector database is stored.
+        - vector_db_collection_name (str): The name of the collection to query.
+        - embedding_dict (dict): The existing dictionary to update with embeddings.
+
+        Returns:
+        - embedding_dict (dict): The updated dictionary where embeddings are grouped by 'type' and 'id'.
+        """
+        if vector_db_persist_directory:
+            # Initialize the Chroma client and get the collection
+            vector_db = chromadb.PersistentClient(
+                path=vector_db_persist_directory)
+            collection = vector_db.get_collection(vector_db_collection_name)
+
+            # Fetch the embeddings and metadata
+            if column == None:
+                dictionary = collection.get(include=['embeddings', 'metadatas'])
+            else:
+                dictionary = collection.get(include=['embeddings', 'metadatas'], where= {"type": {"$eq": f"{column}"}})
+            # Populate the embedding dictionary with embeddings from the vector database
+            for metadata, embedding in zip(dictionary['metadatas'], dictionary['embeddings']):
+                embedding_dict[metadata["type"]
+                               ][metadata["id"]].append(embedding)
+
+            # return dictionary['embeddings'].shape[1]
+        else:
+            raise ValueError(
+                "Persistent directory for the vector DB is not specified.")
+        
     def build(self):
         # 'enzyme','target','pathway','smile','all_text','indication', 'description','mechanism_of_action','pharmacodynamics', 'tui', 'cui', 'entities'
         kwargs = {"columns": self.columns}
@@ -52,27 +87,42 @@ class Pipeline:
             for k, v in self.ner_threshold.items():
                 kwargs[k] = v
         if self.embedding_dict == None:
+            embedding_dict = defaultdict(lambda: defaultdict(list))
             if self.vector_db_persist_directory:
-                self.vector_db = chromadb.PersistentClient(
-                    path=self.vector_db_persist_directory)
-                self.collection = self.vector_db.get_collection(
-                    self.vector_db_collection_name)
-                dictionary = self.collection.get(
-                    include=['embeddings', 'metadatas'])
-
-                embedding_dict = defaultdict(lambda: defaultdict(list))
-
-                for metadata, embedding in zip(dictionary['metadatas'], dictionary['embeddings']):
-                    embedding_dict[metadata["type"]
-                                   ][metadata["id"]].append(embedding)
-
-                embedding_size = dictionary['embeddings'].shape[1]
+                self.__create_or_update_embeddings__(
+                    embedding_dict, self.vector_db_persist_directory, self.vector_db_collection_name)
+                
+            if self.column_embedding_configs:
+                for item in self.column_embedding_configs:
+                    col = item["column"]
+                    col_db_dir = item["vector_db_persist_directory"]
+                    col_db_collection = item["vector_db_collection_name"]
+                    self.__create_or_update_embeddings__(embedding_dict, col_db_dir, col_db_collection, col)
+                    print(f"Embedings of {col} is calculated from {col_db_collection}")
+
+        # if self.embedding_dict == None:
+        #     if self.vector_db_persist_directory:
+        #         self.vector_db = chromadb.PersistentClient(
+        #             path=self.vector_db_persist_directory)
+        #         self.collection = self.vector_db.get_collection(
+        #             self.vector_db_collection_name)
+        #         dictionary = self.collection.get(
+        #             include=['embeddings', 'metadatas'])
+
+        #         embedding_dict = defaultdict(lambda: defaultdict(list))
+
+        #         for metadata, embedding in zip(dictionary['metadatas'], dictionary['embeddings']):
+        #             embedding_dict[metadata["type"]
+        #                            ][metadata["id"]].append(embedding)
+
+        #         embedding_size = dictionary['embeddings'].shape[1]
         else:
             embedding_dict = self.embedding_dict
-            #TODO make generic
-            embedding_size = list(embedding_dict['all_text'].values())[
-                0][0].shape
-
+            # TODO make generic
+            # embedding_size = list(embedding_dict['all_text'].values())[
+            #     0][0].shape
+        key, value = next(iter(embedding_dict.items()))
+        embedding_size = value[next(iter(value))][0].shape[0]
         pooling_strategy = self.embedding_pooling_strategy_type()
 
         self.ner_df = CTakesNER().load(

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/src/ddi_fw.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ddi_fw
-Version: 0.0.93
+Version: 0.0.95
 Summary: Do not use :)
 Author-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>
 Maintainer-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>

{ddi_fw-0.0.93 → ddi_fw-0.0.95}/src/ddi_fw.egg-info/SOURCES.txt

@@ -62,18 +62,12 @@ src/ddi_fw/drugbank/drugbank_parser.py
 src/ddi_fw/drugbank/drugbank_processor.py
 src/ddi_fw/drugbank/drugbank_processor_org.py
 src/ddi_fw/drugbank/event_extractor.py
-src/ddi_fw/experiments/__init__.py
-src/ddi_fw/experiments/custom_torch_model.py
-src/ddi_fw/experiments/evaluation_helper.py
-src/ddi_fw/experiments/pipeline.py
-src/ddi_fw/experiments/pipeline_ner.py
-src/ddi_fw/experiments/tensorflow_helper.py
-src/ddi_fw/experiments/test.py
 src/ddi_fw/langchain/__init__.py
 src/ddi_fw/langchain/embeddings.py
 src/ddi_fw/langchain/sentence_splitter.py
 src/ddi_fw/langchain/storage.py
 src/ddi_fw/ml/__init__.py
+src/ddi_fw/ml/evaluation_helper.py
 src/ddi_fw/ml/ml_helper.py
 src/ddi_fw/ml/model_wrapper.py
 src/ddi_fw/ml/pytorch_wrapper.py

ddi_fw-0.0.93/src/ddi_fw/experiments/__init__.py

@@ -1,4 +0,0 @@
-from .tensorflow_helper import TFMultiModal, TFSingleModal,Result
-from .evaluation_helper import evaluate, Metrics
-from .pipeline import Experiment
-from .pipeline_ner import NerParameterSearch

ddi_fw-0.0.93/src/ddi_fw/experiments/custom_torch_model.py

@@ -1,66 +0,0 @@
-import torch
-
-class ExtendedTorchModule(torch.nn.Module):
-  def __init__(self,model):
-    super().__init__()
-    self.model = model
-
-  def train(self,dataloader_train, criterion, optimizer, epoch_count = 10):
-    for epoch in range(epoch_count):  # loop over the dataset multiple times
-
-      running_loss = 0.0
-      for i, data in enumerate(dataloader_train, 0):
-          # get the inputs; data is a list of [inputs, labels]
-          inputs, labels = data
-          
-          # zero the parameter gradients
-          optimizer.zero_grad()
-
-          # forward + backward + optimize
-          outputs = self(inputs)
-          loss = criterion(outputs, labels)
-          loss.backward()
-          optimizer.step()
-
-          # print statistics
-          running_loss += loss.item()
-          if i % 5000 == 4999:    # print every 2000 mini-batches
-              print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 5000:.3f}')
-              running_loss = 0.0
-    print('Finished Training')
-    
-  def forward(self, x):
-    x = x.to(torch.float32)
-    # for f in self.module_list:
-    #     x = f(x)
-    # return x
-    return self.model(x)
-    
-  def compute_outputs(self, dataloader_test):
-    output_arr = []
-    with torch.no_grad():
-      for data in dataloader_test:
-          inputs, labels = data
-          # calculate outputs by running inputs through the network
-          outputs = self(inputs)
-          output_arr.append(outputs.numpy())
-
-    # <ipython-input-44-114ac3037693>:54: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:245.)
-    t = torch.tensor(output_arr) 
-    return torch.squeeze(t) 
-
-  # def compute_accuracy(self, dataloader_test):
-  #   correct = 0
-  #   total = 0
-  #   # since we're not training, we don't need to calculate the gradients for our outputs
-  #   with torch.no_grad():
-  #       for data in dataloader_test:
-  #           inputs, labels = data
-  #           # calculate outputs by running inputs through the network
-  #           outputs = self(inputs)
-  #           # the class with the highest energy is what we choose as prediction
-  #           _, predicted = torch.max(outputs.data, 1)
-  #           total += labels.size(0)
-  #           correct += (predicted == labels).sum().item()
-
-  #   print(f'Accuracy of the network: {100 * correct // total} %')

ddi_fw-0.0.93/src/ddi_fw/experiments/pipeline.py

@@ -1,132 +0,0 @@
-import sqlite3
-from sklearn.model_selection import train_test_split, KFold, StratifiedKFold
-from keras.models import Model, Sequential
-from keras.callbacks import EarlyStopping
-from keras.layers import Dense, Dropout, Input, Activation, BatchNormalization
-from tensorflow import keras
-from ddi_fw.experiments import TFSingleModal, TFMultiModal
-from ddi_fw.experiments import evaluate
-from sklearn.preprocessing import LabelBinarizer
-import numpy as np
-import pandas as pd
-from ddi_fw.utils import ZipHelper, Py7ZipHelper
-import os
-import chromadb
-from collections import defaultdict
-from langchain_community.vectorstores import Chroma
-from ddi_fw.ner.ner import CTakesNER
-from ddi_fw.langchain.embeddings import PoolingStrategy
-
-from ddi_fw.datasets import BaseDataset, DDIMDLDataset
-
-from ddi_fw.langchain.embeddings import SumPoolingStrategy
-from keras import metrics
-from ddi_fw.experiments.evaluation_helper import evaluate
-
-import mlflow
-
-
-class Experiment:
-    def __init__(self, 
-                 experiment_name=None, 
-                 experiment_description=None, 
-                 experiment_tags=None, 
-                 tracking_uri=None, 
-                 dataset_type:BaseDataset=None, 
-                 columns=None,
-                 embedding_dict = None, 
-                 vector_db_persist_directory=None, 
-                 vector_db_collection_name=None, 
-                 embedding_pooling_strategy_type:PoolingStrategy=None, 
-                 ner_data_file=None, 
-                 ner_threshold=None, 
-                 combinations=None, 
-                 model=None):
-        
-        self.experiment_name = experiment_name
-        self.experiment_description = experiment_description
-        self.experiment_tags = experiment_tags
-        self.tracking_uri = tracking_uri
-        self.dataset_type = dataset_type
-        self.columns = columns
-        self.embedding_dict = embedding_dict
-        self.vector_db_persist_directory = vector_db_persist_directory
-        self.vector_db_collection_name = vector_db_collection_name
-        self.embedding_pooling_strategy_type = embedding_pooling_strategy_type
-        self.ner_data_file = ner_data_file
-        self.ner_threshold = ner_threshold
-        self.combinations = combinations
-        self.model = model
-
-    def build(self):
-        # 'enzyme','target','pathway','smile','all_text','indication', 'description','mechanism_of_action','pharmacodynamics', 'tui', 'cui', 'entities'
-        kwargs = {"columns": self.columns}
-        for k, v in self.ner_threshold.items():
-            kwargs[k] = v
-        if self.embedding_dict == None:
-            if self.vector_db_persist_directory:
-                self.vector_db = chromadb.PersistentClient(
-                    path=self.vector_db_persist_directory)
-                self.collection = self.vector_db.get_collection(
-                    self.vector_db_collection_name)
-                dictionary = self.collection.get(include=['embeddings', 'metadatas'])
-
-                embedding_dict = defaultdict(lambda: defaultdict(list))
-
-                for metadata, embedding in zip(dictionary['metadatas'], dictionary['embeddings']):
-                    embedding_dict[metadata["type"]][metadata["id"]].append(embedding)
-
-                embedding_size = dictionary['embeddings'].shape[1]
-        else:
-            embedding_dict = self.embedding_dict
-            embedding_size = list(embedding_dict['all_text'].values())[0][0].shape
-
-        pooling_strategy = self.embedding_pooling_strategy_type()
-
-        self.ner_df = CTakesNER().load(filename=self.ner_data_file)  if self.ner_data_file else None
-
-        self.dataset = self.dataset_type(
-            embedding_dict=embedding_dict,
-            embedding_size=embedding_size,
-            embeddings_pooling_strategy=pooling_strategy,
-            ner_df=self.ner_df, **kwargs)
-
-        X_train, X_test, y_train, y_test, X_train.index, X_test.index, train_idx_arr, val_idx_arr = self.dataset.load()
-
-        self.dataframe = self.dataset.dataframe
-        # dataframe.dropna()
-        self.X_train = self.dataset.X_train
-        self.X_test = self.dataset.X_test
-        self.y_train = self.dataset.y_train
-        self.y_test = self.dataset.y_test
-        self.train_idx_arr = self.dataset.train_idx_arr
-        self.val_idx_arr = self.dataset.val_idx_arr
-        # Logic to set up the experiment
-        self.items = self.dataset.produce_inputs()
-
-        unique_classes = pd.unique(self.dataframe['event_category'])
-        event_num = len(unique_classes)
-        # droprate = 0.3
-        vector_size = self.dataset.drugs_df.shape[0]
-
-        print("Building the experiment with the following settings:")
-        print(
-            f"Name: {self.experiment_name}, Dataset: {self.dataset}, Model: {self.model}")
-        # Implement additional build logic as needed
-        return self
-
-    def run(self, model_func, batch_size=128, epochs=100):
-        mlflow.set_tracking_uri(self.tracking_uri)
-
-        if mlflow.get_experiment_by_name(self.experiment_name) == None:
-            mlflow.create_experiment(self.experiment_name)
-            mlflow.set_experiment_tags(self.experiment_tags)
-        mlflow.set_experiment(self.experiment_name)
-
-        y_test_label = self.items[0][4]
-        multi_modal = TFMultiModal(
-            model_func=model_func, batch_size=batch_size,  epochs=epochs)  # 100
-        multi_modal.set_data(
-            self.items, self.train_idx_arr, self.val_idx_arr, y_test_label)
-        result = multi_modal.predict(self.combinations)
-        return result

ddi_fw-0.0.93/src/ddi_fw/experiments/pipeline_ner.py

@@ -1,116 +0,0 @@
-from collections import defaultdict
-from enum import Enum
-import numpy as np
-import pandas as pd
-from ddi_fw.datasets.core import BaseDataset
-from ddi_fw.experiments.tensorflow_helper import TFMultiModal
-from ddi_fw.experiments.pipeline import Experiment
-from typing import Dict, List
-from itertools import product
-
-from ddi_fw.utils.enums import DrugBankTextDataTypes, UMLSCodeTypes
-import mlflow
-from ddi_fw.ner.ner import CTakesNER
-
-def stack(df_column):
-    return np.stack(df_column.values)
-
-
-class NerParameterSearch:
-    def __init__(self,
-                 experiment_name,
-                 experiment_description,
-                 experiment_tags,
-                 tracking_uri,
-                 dataset_type: BaseDataset,
-                 ner_data_file,
-                 columns:list,
-                 umls_code_types: List[UMLSCodeTypes],
-                 text_types=List[DrugBankTextDataTypes],
-                 min_threshold_dict: Dict[str, float] = defaultdict(float),
-                 max_threshold_dict: Dict[str, float] = defaultdict(float),
-                 increase_step=0.5):
-        self.experiment_name = experiment_name
-        self.experiment_description = experiment_description
-        self.experiment_tags = experiment_tags
-        self.tracking_uri = tracking_uri
-
-        self.dataset_type = dataset_type
-        self.ner_data_file = ner_data_file
-        self.columns = columns
-        self.umls_code_types = umls_code_types
-        self.text_types = text_types
-        self.min_threshold_dict = min_threshold_dict
-        self.max_threshold_dict = max_threshold_dict
-        self.increase_step = increase_step
-
-    def build(self):
-        self.datasets = {}
-        self.items = []
-        # columns = ['tui', 'cui', 'entities']
-        if self.umls_code_types is not None and self.text_types is not None:
-            # add checking statements
-            _umls_codes = [t.value[0] for t in self.umls_code_types]
-            _text_types = [t.value[0] for t in self.text_types]
-            _columns = [f'{item[0]}_{item[1]}' for item in product(
-                _umls_codes, _text_types)]
-            self.columns.extend(_columns)
-        print(f'Columns: {self.columns}')
-        self.ner_df = CTakesNER().load(filename=self.ner_data_file)  if self.ner_data_file else None
-        for column in self.columns:
-            min_threshold = self.min_threshold_dict[column]
-            max_threshold = self.max_threshold_dict[column]
-            kwargs = {}
-            kwargs['threshold_method'] = 'idf'
-            kwargs['tui_threshold'] = 0
-            kwargs['cui_threshold'] = 0
-            kwargs['entities_threshold'] = 0
-
-            for threshold in np.arange(min_threshold, max_threshold, self.increase_step):
-                print(threshold)
-                if column.startswith('tui'):
-                    kwargs['tui_threshold'] = threshold
-                if column.startswith('cui'):
-                    kwargs['cui_threshold'] = threshold
-                if column.startswith('entities'):
-                    kwargs['entities_threshold'] = threshold
-                dataset = self.dataset_type(
-                    # chemical_property_columns=[],
-                    # embedding_columns=[],
-                    # ner_columns=[column],
-                    columns=[column],
-                    ner_df= self.ner_df,
-                    embedding_size = None,
-                    embedding_dict = None,
-                    embeddings_pooling_strategy = None,
-                    **kwargs)
-
-                # train_idx_arr, val_idx_arr  bir kez hesaplanması yeterli aslında
-                X_train, X_test, y_train, y_test, X_train.index, X_test.index, train_idx_arr, val_idx_arr = dataset.load()
-                group_items = dataset.produce_inputs()
-                for item in group_items:
-                    # item[0] = f'threshold_{threshold}_{item[0]}'
-                    item[0] = f'threshold_{item[0]}_{threshold}'
-                self.datasets[item[0]] = dataset.ddis_df
- 
-                self.items.extend(group_items)
-        self.y_test_label = self.items[0][4]
-        self.train_idx_arr = train_idx_arr
-        self.val_idx_arr = val_idx_arr
-
-
-    def run(self, model_func, batch_size=128, epochs=100):
-            mlflow.set_tracking_uri(self.tracking_uri)
-
-            if mlflow.get_experiment_by_name(self.experiment_name) == None:
-                mlflow.create_experiment(self.experiment_name)
-                mlflow.set_experiment_tags(self.experiment_tags)
-            mlflow.set_experiment(self.experiment_name)
-
-            y_test_label = self.items[0][4]
-            multi_modal = TFMultiModal(
-                model_func=model_func, batch_size=batch_size,  epochs=epochs)  # 100
-            multi_modal.set_data(
-                self.items, self.train_idx_arr, self.val_idx_arr, y_test_label)
-            result = multi_modal.predict()
-            return result