ddi-fw 0.0.94__py3-none-any.whl → 0.0.96__py3-none-any.whl

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/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

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/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/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/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/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,37 @@ class Pipeline:
         self.combinations = combinations
         self.model = model
 
+    def __create_or_update_embeddings__(self, 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.
+
+        """
+        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 +85,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.94.dist-info → ddi_fw-0.0.96.dist-info}/METADATA

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

{ddi_fw-0.0.94.dist-info → ddi_fw-0.0.96.dist-info}/RECORD

@@ -55,30 +55,24 @@ ddi_fw/drugbank/drugbank_parser.py,sha256=lxUuhB0s8ef_aPNDs0V8ClKF7-KIWugNIV9gVs
 ddi_fw/drugbank/drugbank_processor.py,sha256=vmkt68n9nFLevufgGyXhOSDtTo4G1XzwT9PVncGTXtk,18127
 ddi_fw/drugbank/drugbank_processor_org.py,sha256=eO5Yset50P91qkic79RUXPoEuxRxQKFkKW0l4G29Mas,13322
 ddi_fw/drugbank/event_extractor.py,sha256=6odoZohhK7OdLF-LF0l-5BFq0_NMG_5jrFJbHrBXsI8,4600
-ddi_fw/experiments/__init__.py,sha256=5L2xSolpFycNnflqOMdvJSiqRB16ExA5bbVGORKFX04,195
-ddi_fw/experiments/custom_torch_model.py,sha256=iQ_R_EApzD2JCcASN8cie6D21oh7VCxaOQ45_dkiGwc,2576
-ddi_fw/experiments/evaluation_helper.py,sha256=o4-w5Xa3t4olLW4ymx_8L-Buhe5wfQEmT2bh4Zz544c,13066
-ddi_fw/experiments/pipeline.py,sha256=4ltPCcfLZ1fFpiOd8ahPognI6NLmRLzJvUqyFpn3z18,5693
-ddi_fw/experiments/pipeline_ner.py,sha256=unxEJCYrG6wEZjLmqvGdLRTMOBwELbGKkdygSpAR3b8,5043
-ddi_fw/experiments/tensorflow_helper.py,sha256=m3Mppl-tbccTMAKLpZg2YC0xpcukkyQihPw_uwAlRRY,11857
-ddi_fw/experiments/test.py,sha256=z1TfBpK75zGKpp2ZU8f6APjZlgBFthaCBN61YB9ma4o,2049
 ddi_fw/langchain/__init__.py,sha256=8dBPZivc01WWaCH8sZ_UV8-XPyo74e9Qy6-fYgAiNLE,248
 ddi_fw/langchain/embeddings.py,sha256=8J_SfO9pyET2W-Ltzq0_r9EchFzBsYdUabiOMma42Us,7515
 ddi_fw/langchain/sentence_splitter.py,sha256=h_bYElx4Ud1mwDNJfL7mUwvgadwKX3GKlSzu5L2PXzg,280
 ddi_fw/langchain/storage.py,sha256=uy5clVB07So2eFbRGdAKzHIPdfEk4se33cPktis7Aa4,2716
-ddi_fw/ml/__init__.py,sha256=0YubqmEpJKp3OfqlLKkD5N9L6WDWew3QEtnbdY3mqKg,180
-ddi_fw/ml/ml_helper.py,sha256=yeNfTg9aC6woQLYbR3ofSUE1b79k1SQPrLAr2yYxHVA,4498
-ddi_fw/ml/model_wrapper.py,sha256=ZExnsLMjHKL3BaI4aKkbyWTp8vbswLeF2_T3cZ73YpQ,1144
-ddi_fw/ml/pytorch_wrapper.py,sha256=YdwzR5qAHFNajYB_elFqDhVKRLeajaRpopNzyQ6gIIA,3725
-ddi_fw/ml/tensorflow_wrapper.py,sha256=pSeiJDuaLf9MhZVlLuLJBA-LH-H-Dl2TyYbB39iGsto,5748
+ddi_fw/ml/__init__.py,sha256=tIxiW0g6q1VsmDYVXR_ovvHQR3SCir8g2bKxx_CrS7s,221
+ddi_fw/ml/evaluation_helper.py,sha256=o4-w5Xa3t4olLW4ymx_8L-Buhe5wfQEmT2bh4Zz544c,13066
+ddi_fw/ml/ml_helper.py,sha256=fySjIAFzkeEOvaLJhDwtCOgRhgYQ7H106eqaP16GhDY,4489
+ddi_fw/ml/model_wrapper.py,sha256=W-bed6NOJxuXs7d3nG6iU8bkUX8LBPFQ0gMjZ7Qc0Sw,1135
+ddi_fw/ml/pytorch_wrapper.py,sha256=AkG-2sKDXr0IBhgmkbjG0i20OuwQv3mhdvqp6UvJDCA,3716
+ddi_fw/ml/tensorflow_wrapper.py,sha256=E46lC9qMkM5NvFTL-eOuMcMhEUso5UYfP66Du4BOhfQ,6423
 ddi_fw/ner/__init__.py,sha256=JwhGXrepomxPSsGsg2b_xPRC72AjvxOIn2CW5Mvscn0,26
 ddi_fw/ner/mmlrestclient.py,sha256=NZta7m2Qm6I_qtVguMZhqtAUjVBmmXn0-TMnsNp0jpg,6859
 ddi_fw/ner/ner.py,sha256=BEs9AFljAxOQrC2BEP1raSzRoypcfELS5UTdl4bjTqw,15863
 ddi_fw/pipeline/__init__.py,sha256=tKDM_rW4vPjlYTeOkNgi9PujDzb4e9O3LK1w5wqnebw,212
 ddi_fw/pipeline/multi_modal_combination_strategy.py,sha256=qIst7vxHaOAhRv4lgozszwa3b1QE4aIrN74t41Xnvr4,1637
-ddi_fw/pipeline/multi_pipeline.py,sha256=5UDpTYgvrbbaMCoLu4BtlqfGy5MA2lTSNakm6hBVdGw,5669
+ddi_fw/pipeline/multi_pipeline.py,sha256=t_Z7d7xRfDnhpQTlqCf7c0isZ5hZlyXavKhC7ePsnJY,5903
 ddi_fw/pipeline/ner_pipeline.py,sha256=wB7hz4YCOv7UAz6bGE6sSpPXXIdoOflOVK5UCc1fO-o,5586
-ddi_fw/pipeline/pipeline.py,sha256=uiRS0MmOOto3RUp5C4pRJZcZQHpevuZGGLrsZP6FmJ8,5599
+ddi_fw/pipeline/pipeline.py,sha256=q7jfTt7ryYa3xBscPtxvanB-j5RzWVZUKir0KmAdTKc,8357
 ddi_fw/test/basic_test.py,sha256=fEOGcZm1ObnsDvMiXNmdmz6YCeUrGc8V0DwlSwGhsq8,376
 ddi_fw/test/combination_test.py,sha256=TWNE8sf-DSh1Q9-yRaRBc774Sn1kSMGXLwQhd2_Qynk,324
 ddi_fw/test/compress_json_test.py,sha256=BGny56YqiG-pzhMoDzLKQBQI1E7o3jU0S7VYWtclAx4,1045
@@ -95,7 +89,7 @@ ddi_fw/utils/enums.py,sha256=19eJ3fX5eRK_xPvkYcukmug144jXPH4X9zQqtsFBj5A,671
 ddi_fw/utils/py7zr_helper.py,sha256=gOqaFIyJvTjUM-btO2x9AQ69jZOS8PoKN0wetYIckJw,4747
 ddi_fw/utils/utils.py,sha256=szwnxMTDRrZoeNRyDuf3aCbtzriwtaRk4mHSH3asLdA,4301
 ddi_fw/utils/zip_helper.py,sha256=YRZA4tKZVBJwGQM0_WK6L-y5MoqkKoC-nXuuHK6CU9I,5567
-ddi_fw-0.0.94.dist-info/METADATA,sha256=R-lLr-tlzZPcKnW35DlxhJ5CtlbVasb4qE5NLS5nV9A,1966
-ddi_fw-0.0.94.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-ddi_fw-0.0.94.dist-info/top_level.txt,sha256=PMwHICFZTZtcpzQNPV4UQnfNXYIeLR_Ste-Wfc1h810,7
-ddi_fw-0.0.94.dist-info/RECORD,,
+ddi_fw-0.0.96.dist-info/METADATA,sha256=b2D7e7ub3byUbTwEPdw6FvUqTEK-H_KflNXwqbk4r7s,1966
+ddi_fw-0.0.96.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+ddi_fw-0.0.96.dist-info/top_level.txt,sha256=PMwHICFZTZtcpzQNPV4UQnfNXYIeLR_Ste-Wfc1h810,7
+ddi_fw-0.0.96.dist-info/RECORD,,

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/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/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/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

ddi_fw/experiments/tensorflow_helper.py

@@ -1,284 +0,0 @@
-from matplotlib import pyplot as plt
-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 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 evaluate
-
-# import tf2onnx
-# import onnx
-
-import itertools
-import ddi_fw.utils as utils
-
-# https://github.com/YifanDengWHU/DDIMDL/blob/master/newTask.py
-# from numpy.random import seed
-# seed(1)
-# from tensorflow import set_random_seed
-# set_random_seed(2)
-tf.random.set_seed(1)
-np.random.seed(2)
-np.set_printoptions(precision=4)
-
-
-class Result:
-    def __init__(self) -> None:
-        self.log_dict = {}
-        self.metric_dict = {}
-
-    def add_log(self, key, logs):
-        self.log_dict[key] = logs
-
-    def add_metric(self, key, metrics):
-        self.metric_dict[key] = metrics
-
-
-class TFMultiModal:
-    # todo model related parameters to config
-    def __init__(self, model_func, batch_size=128, epochs=100):
-        self.model_func = model_func
-        self.batch_size = batch_size
-        self.epochs = epochs
-        self.result = Result()
-
-    def set_data(self, items, train_idx_arr, val_idx_arr, y_test_label):
-        self.items = items
-        self.train_idx_arr = train_idx_arr
-        self.val_idx_arr = val_idx_arr
-        self.y_test_label = y_test_label
-
-    def predict(self, combinations: list = [], generate_combinations=False):
-        self.prefix = utils.utc_time_as_string()
-        self.date = utils.utc_time_as_string_simple_format()
-        sum = np.zeros(
-            (self.y_test_label.shape[0], self.y_test_label.shape[1]))
-        single_results = dict()
-
-        if generate_combinations:
-            l = [item[0] for item in self.items]
-            combinations = []
-            for i in range(2, len(l) + 1):
-                combinations.extend(list(itertools.combinations(l, i)))  # all
-
-        with mlflow.start_run(run_name=self.prefix, description="***") as run:
-            self.level_0_run_id = run.info.run_id
-            for item in self.items:
-                print(item[0])
-                single_modal = TFSingleModal(
-                    self.date, item[0], self.model_func, self.batch_size, self.epochs)
-                single_modal.set_data(
-                    self.train_idx_arr, self.val_idx_arr, item[1], item[2], item[3], item[4])
-                logs, metrics, prediction = single_modal.predict()
-                self.result.add_log(item[0], logs)
-                # self.result.add_metric(item[0], metrics)
-                # single_results[item[0]] = prediction  
-                single_results[item[0]] = tf.nn.softmax(prediction).numpy()  
-                # sum = sum + prediction
-
-            if combinations:
-                self.evaluate_combinations(single_results, combinations)
-        # TODO: sum'a gerek yok
-        return self.result
-
-    def evaluate_combinations(self, single_results, combinations):
-        for combination in combinations:
-            combination_descriptor = '-'.join(combination)
-            with mlflow.start_run(run_name=combination_descriptor, description="***", nested=True) as combination_run:
-                prediction = np.zeros(
-                    (self.y_test_label.shape[0], self.y_test_label.shape[1]))
-                for item in combination:
-                    prediction = prediction + single_results[item]
-                logs, metrics = evaluate(
-                    actual=self.y_test_label, pred=prediction, info=combination_descriptor)
-                mlflow.log_metrics(logs)
-                metrics.format_float()
-                # TODO path bulunamadı hatası aldık
-                print(
-                    f'combination_artifact_uri:{combination_run.info.artifact_uri}')
-                utils.compress_and_save_data(
-                    metrics.__dict__, combination_run.info.artifact_uri, f'{self.date}_metrics.gzip')
-                # self.result.add_log(combination_descriptor,logs)
-                # self.result.add_metric(combination_descriptor,metrics)
-
-
-class TFSingleModal:
-    def __init__(self, date, descriptor, model_func, batch_size=128, epochs=100):
-        self.date = date
-        self.descriptor = descriptor
-        self.model_func = model_func
-        self.batch_size = batch_size
-        self.epochs = epochs
-
-    def set_data(self, train_idx_arr, val_idx_arr, train_data, train_label, test_data, test_label):
-        self.train_idx_arr = train_idx_arr
-        self.val_idx_arr = val_idx_arr
-        self.train_data = train_data
-        self.train_label = train_label
-        self.test_data = test_data
-        self.test_label = test_label
-
-# https://github.com/mlflow/mlflow/blob/master/examples/tensorflow/train.py
-    def predict(self):
-        print(self.train_data.shape)
-
-        # Failed to convert a NumPy array to a Tensor
-        with mlflow.start_run(run_name=self.descriptor, description="***", nested=True) as run:
-            models = dict()
-            histories = dict()
-            models_val_acc = dict()
-            # with batch_metrics_logger(run_id) as metrics_logger:
-            for i, (train_idx, val_idx) in enumerate(zip(self.train_idx_arr, self.val_idx_arr)):
-                print(f"Validation {i}")
-
-                with mlflow.start_run(run_name=f'Validation {i}', description='CV models', nested=True) as cv_fit:
-                    model = self.model_func(self.train_data.shape[1])
-                    models[f'validation_{i}'] = model
-                    X_train_cv = self.train_data[train_idx]
-                    y_train_cv = self.train_label[train_idx]
-                    X_valid_cv = self.train_data[val_idx]
-                    y_valid_cv = self.train_label[val_idx]
-
-                    early_stopping = EarlyStopping(
-                        monitor='val_loss', patience=10, verbose=0, mode='auto')
-                    custom_callback = CustomCallback()
-                    history = model.fit(X_train_cv, y_train_cv,
-                                        batch_size=self.batch_size,
-                                        epochs=self.epochs,
-                                        validation_data=(
-                                            X_valid_cv, y_valid_cv),
-                                        callbacks=[early_stopping, custom_callback])
-                    # histories[f'validation_{i}'] = history
-                    models_val_acc[f'validation_{i}'] = history.history['val_accuracy'][-1]
-                    # 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])
-            pred = best_model.predict(self.test_data)
-
-            logs, metrics = evaluate(
-                actual=self.test_label, pred=pred, info=self.descriptor)
-            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,
-            )
-            print(run.info.artifact_uri)
-            # todo tf2onnx not compatible with keras > 2.15
-            # onnx_model, _ = tf2onnx.convert.from_keras(
-            #     best_model, input_signature=None, opset=13)
-            # onnx.save(onnx_model, run.info.artifact_uri +
-            #           '/model/model.onnx')
-            utils.compress_and_save_data(
-                metrics.__dict__, run.info.artifact_uri, f'{self.date}_metrics.gzip')
-
-        return logs, metrics, pred
-
-
-class CustomCallback(keras.callbacks.Callback):
-    def on_train_begin(self, logs=None):
-        keys = list(logs.keys())
-        mlflow.log_param("train_begin_keys", keys)
-        config = self.model.optimizer.get_config()
-        for attribute in config:
-            mlflow.log_param("opt_" + attribute, config[attribute])
-
-        sum_list = []
-        self.model.summary(print_fn=sum_list.append)
-        summary = "\n".join(sum_list)
-        mlflow.log_text(summary, artifact_file="model_summary.txt")
-
-    def on_train_end(self, logs=None):
-        print(logs)
-        mlflow.log_metrics(logs)
-
-    def on_epoch_begin(self, epoch, logs=None):
-        keys = list(logs.keys())
-
-    def on_epoch_end(self, epoch, logs=None):
-        keys = list(logs.keys())
-
-    def on_test_begin(self, logs=None):
-        keys = list(logs.keys())
-
-    def on_test_end(self, logs=None):
-        mlflow.log_metrics(logs)
-        print(logs)
-
-    def on_predict_begin(self, logs=None):
-        keys = list(logs.keys())
-
-    def on_predict_end(self, logs=None):
-        keys = list(logs.keys())
-        mlflow.log_metrics(logs)
-
-    def on_train_batch_begin(self, batch, logs=None):
-        keys = list(logs.keys())
-
-    def on_train_batch_end(self, batch, logs=None):
-        keys = list(logs.keys())
-
-    def on_test_batch_begin(self, batch, logs=None):
-        keys = list(logs.keys())
-
-    def on_test_batch_end(self, batch, logs=None):
-        keys = list(logs.keys())
-
-    def on_predict_batch_begin(self, batch, logs=None):
-        keys = list(logs.keys())
-
-    def on_predict_batch_end(self, batch, logs=None):
-        keys = list(logs.keys())
-    # def on_train_begin(self, logs=None):  # pylint: disable=unused-argument
-    #     config = self.model.optimizer.get_config()
-    #     for attribute in config:
-    #         mlflow.log_param("opt_" + attribute, config[attribute])
-
-    #     sum_list = []
-    #     self.model.summary(print_fn=sum_list.append)
-    #     summary = "\n".join(sum_list)
-    #     mlflow.log_text(summary, artifact_file="model_summary.txt")
-
-    # def on_epoch_end(self, epoch, logs=None):
-    #     # NB: tf.Keras uses zero-indexing for epochs, while other TensorFlow Estimator
-    #     # APIs (e.g., tf.Estimator) use one-indexing. Accordingly, the modular arithmetic
-    #     # used here is slightly different from the arithmetic used in `_log_event`, which
-    #     # provides  metric logging hooks for TensorFlow Estimator & other TensorFlow APIs
-    #     if epoch % self.log_every_n_steps == 0:
-    #         self.metrics_logger.record_metrics(logs, epoch)
-
-    # def predict(self):
-    #     model = self.model_func()
-    #     # Failed to convert a NumPy array to a Tensor
-    #     for i, (train_idx, val_idx) in enumerate(zip(self.train_idx_arr, self.val_idx_arr)):
-    #         print(f"Validation {i}")
-    #         X_train_cv = self.train_data[train_idx]
-    #         y_train_cv = self.train_label[train_idx]
-    #         X_valid_cv = self.train_data[val_idx]
-    #         y_valid_cv = self.train_label[val_idx]
-
-    #         early_stopping = EarlyStopping(
-    #             monitor='val_loss', patience=10, verbose=0, mode='auto')
-    #         model.fit(X_train_cv, y_train_cv, batch_size=128, epochs=20, validation_data=(X_valid_cv, y_valid_cv),
-    #                   callbacks=[early_stopping])
-    #     pred = model.predict(self.test_data)
-    #     return pred

ddi_fw/experiments/test.py

@@ -1,61 +0,0 @@
-# # https://github.com/kashif/tf-keras-tutorial/blob/tf2/3-imdb.ipynb
-# # TensorFlow and tf.keras
-# import tensorflow as tf
-
-# # Helper libraries
-# import numpy as np
-# import matplotlib.pyplot as plt
-# from tensorflow_helper import CustomCallback
-
-# print(tf.__version__)
-
-
-# imdb = tf.keras.datasets.imdb
-
-# (train_data, train_labels), (test_data, test_labels) = tf.keras.datasets.imdb.load_data(num_words=10000)
-
-
-# class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
-#                'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
-
-  
-# # Create a model
-# model = tf.keras.Sequential()
-# custom_callback = CustomCallback()
-
-#  # input shape here is the length of our movie review vector
-# model.add(tf.keras.layers.Dense(16, activation=tf.nn.relu, input_shape=(10000,)))
-# model.add(tf.keras.layers.Dense(16, activation=tf.nn.relu))
-# model.add(tf.keras.layers.Dense(1, activation=tf.nn.sigmoid))
-
-# optimizer = tf.keras.optimizers.RMSprop(learning_rate=0.001)
-
-# model.compile(loss='binary_crossentropy',
-#               optimizer=optimizer,
-#               metrics=['binary_accuracy'])
-
-# model.summary()
- 
-# VAL_SIZE = 10000
-# x  = np.array(train_data[:VAL_SIZE].tolist())
-
-# val_data = np.asarray(train_data[:VAL_SIZE])
-# partial_train_data = np.asarray(train_data[VAL_SIZE:])
-
-
-# val_labels = train_labels[:VAL_SIZE]
-# partial_train_labels = train_labels[VAL_SIZE:]
-
-# BATCH_SIZE = 512
-# SHUFFLE_SIZE = 1000
-
-# # training_set = tf.data.Dataset.from_tensor_slices((partial_train_data, partial_train_labels))
-# # training_set = training_set.shuffle(SHUFFLE_SIZE).batch(BATCH_SIZE)
-
-# model.fit(partial_train_data , partial_train_labels , batch_size=128, epochs=20, validation_data=(val_data , val_labels ),
-#                           callbacks=[custom_callback])
-
-# loss, accuracy = model.evaluate(test_data, test_labels,callbacks=[custom_callback])
-# print('Test accuracy: %.2f' % (accuracy))
-
-from langchain.embeddings import SentenceTransformerEmbeddings