ddi-fw 0.0.130__tar.gz → 0.0.132__tar.gz

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/PKG-INFO

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

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/pyproject.toml

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

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/src/ddi_fw/datasets/__init__.py

@@ -1,5 +1,6 @@
 from .core import BaseDataset
 from .ddi_mdl.base import DDIMDLDataset 
+from .ddi_mdl_text.base import DDIMDLDatasetV2
 from .mdf_sa_ddi.base import MDFSADDIDataset
 from .embedding_generator import create_embeddings
 from .idf_helper import IDF

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/src/ddi_fw/datasets/ddi_mdl_text/base.py

@@ -22,8 +22,8 @@ list_of_embedding_columns = ['description',
                              'description_indication_mechanism_of_action',
                              'description_indication_pharmacodynamics',
                              'description_mechanism_of_action_pharmacodynamics',
-                             'indication_mechanism_of_action_pharmacodynamics'
-                             'description_indication_mechanism_of_action_pharmacodynamics',
+                             'indication_mechanism_of_action_pharmacodynamics',
+                             'description_indication_mechanism_of_action_pharmacodynamics'
                              ]
 
 list_of_chemical_property_columns = ['enzyme',
@@ -46,7 +46,7 @@ def indices_to_binary_vector(indices, vector_length=881):
     return binary_vector
 
 
-class DDIMDLDataset(BaseDataset):
+class DDIMDLDatasetV2(BaseDataset):
     def __init__(self, embedding_size,
                  embedding_dict,
                  embeddings_pooling_strategy: PoolingStrategy,

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/src/ddi_fw/ml/ml_helper.py

@@ -3,6 +3,7 @@ from matplotlib import pyplot as plt
 from ddi_fw.ml.model_wrapper import Result
 from ddi_fw.ml.pytorch_wrapper import PTModelWrapper
 from ddi_fw.ml.tensorflow_wrapper import TFModelWrapper
+from ddi_fw.utils.package_helper import get_import
 import tensorflow as tf
 from tensorflow import keras
 from keras.models import Model, Sequential
@@ -30,11 +31,9 @@ import ddi_fw.utils as utils
 
 class MultiModalRunner:
     # todo model related parameters to config
-    def __init__(self, library ,model_func, batch_size=128, epochs=100):
+    def __init__(self, library, multi_modal):
         self.library = library
-        self.model_func = model_func
-        self.batch_size = batch_size
-        self.epochs = epochs
+        self.epochs = multi_modal
         self.result = Result()
 
     def set_data(self, items, train_idx_arr, val_idx_arr, y_test_label):
@@ -43,7 +42,7 @@ class MultiModalRunner:
         self.val_idx_arr = val_idx_arr
         self.y_test_label = y_test_label
 
-    def __create_multi_modal(self,library):
+    def __create_model(self,library):
         if library == 'tensorflow':
             return TFModelWrapper
         elif library == 'pytorch':
@@ -66,18 +65,49 @@ class MultiModalRunner:
 
         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])
-                T = self.__create_multi_modal(self.library)
-                single_modal=T(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])
+            item_dict = {t[0]: t for t in self.items}
+            for m in self.multi_modal:
+                name = m.get('name')
+                input_type = m.get('input_type')
+                input = m.get('input')
+                inputs = m.get('inputs')
+                model_type = get_import(m.get("model_type"))
+                kwargs = m.get('params')
+                T = self.__create_model(self.library)
+                single_modal=T(self.date, name, model_type, **kwargs)
+                if input_type == '1D':
+                    item = item_dict[input]
+                    single_modal.set_data(
+                        self.train_idx_arr, self.val_idx_arr, item[1], item[2], item[3], item[4])
+                elif input_type == '2D':
+                    filtered_dict = {k: item_dict[k] for k in inputs if k in item_dict}
+                    first_input = next(iter(item_dict.values()))
+                    train_data_list = [f[1] for f in filtered_dict.values()]
+                    test_data_list = [f[3] for f in filtered_dict.values()]
+                    train_data = np.stack(train_data_list, axis=1)
+                    test_data = np.stack(test_data_list, axis=1)
+                    train_label = first_input[2]
+                    test_label = first_input[2]
+                    single_modal.set_data(
+                        self.train_idx_arr, self.val_idx_arr, train_data, train_label, test_data, test_label)
                 logs, metrics, prediction = single_modal.predict()
-                # self.result.add_log(item[0], logs)
-                #Check
                 self.result.add_metric(item[0], metrics)
-                single_results[item[0]] = prediction
-                # sum = sum + prediction
+                single_results[name] = prediction
+
+
+            # for item in self.items:
+            #     print(item[0])
+            #     T = self.__create_model(self.library)
+            #     # parameters of model should be dictionary 
+            #     single_modal=T(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)
+            #     #Check
+            #     self.result.add_metric(item[0], metrics)
+            #     single_results[item[0]] = prediction
+            #     # sum = sum + prediction
 
             if combinations:
                 self.evaluate_combinations(single_results, combinations)

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/src/ddi_fw/ml/model_wrapper.py

@@ -15,12 +15,12 @@ class Result:
 
 
 class ModelWrapper:
-    def __init__(self, date, descriptor, model_func, batch_size=128, epochs=100):
+    def __init__(self, date, descriptor, model_func ,**kwargs):
         self.date = date
         self.descriptor = descriptor
         self.model_func = model_func
-        self.batch_size = batch_size
-        self.epochs = epochs
+        self.kwargs = kwargs
+       
 
     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

ddi_fw-0.0.132/src/ddi_fw/ml/tensorflow_wrapper.py

@@ -0,0 +1,152 @@
+from ddi_fw.ml.model_wrapper import ModelWrapper
+import tensorflow as tf
+from tensorflow import keras
+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
+
+from mlflow.models import infer_signature
+from ddi_fw.ml.evaluation_helper import Metrics, evaluate
+
+# import tf2onnx
+# import onnx
+
+import ddi_fw.utils as utils
+import os
+
+
+class TFModelWrapper(ModelWrapper):
+
+    def __init__(self, date, descriptor, model_func, **kwargs):
+        super().__init__(date, descriptor, model_func, **kwargs)
+        self.batch_size = kwargs.get('batch_size',128)
+        self.epochs = kwargs.get('epochs',100)
+
+    def fit_model(self, X_train, y_train, X_valid, y_valid):
+        self.kwargs['input_shape'] = self.train_data.shape
+        model = self.model_func(**self.kwargs)
+        checkpoint = ModelCheckpoint(
+            filepath=f'{self.descriptor}_validation.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, mode='auto')
+        custom_callback = CustomCallback()
+
+        history = model.fit(
+            X_train, y_train,
+            batch_size=self.batch_size,
+            epochs=self.epochs,
+            validation_data=(X_valid, y_valid),
+            callbacks=[early_stopping, checkpoint, custom_callback]
+        )
+
+        if os.path.exists(f'{self.descriptor}_validation.weights.h5'):
+            os.remove(f'{self.descriptor}_validation.weights.h5')
+
+        return model, checkpoint
+
+    def fit(self):
+        print(self.train_data.shape)
+        models = {}
+        models_val_acc = {}
+        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:
+                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]
+                model, best_val_acc = self.fit_model(
+                    X_train_cv, y_train_cv, X_valid_cv, y_valid_cv)
+                models[f'validation_{i}'] = model
+                models_val_acc[f'{self.descriptor}_validation_{i}'] = best_val_acc
+
+        best_model_key = max(models_val_acc, key=models_val_acc.get)
+        best_model = models[best_model_key]
+        return best_model, best_model_key
+
+    # https://github.com/mlflow/mlflow/blob/master/examples/tensorflow/train.py
+
+    def predict(self, best_model):
+        pred = best_model.predict(self.test_data)
+        return pred
+
+    def fit_and_evaluate(self):
+
+        with mlflow.start_run(run_name=self.descriptor, description="***", nested=True) as run:
+            print(run.info.artifact_uri)
+            best_model, best_model_key = self.fit()
+            pred = self.predict(best_model)
+            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)
+
+            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())

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/src/ddi_fw/pipeline/multi_pipeline.py

@@ -49,8 +49,8 @@ class MultiPipeline():
     def __create_pipeline(self, config):
         type = config.get("type")
         library = config.get("library")
-        batch_size = config.get("batch_size")
-        epochs = config.get("epochs")
+        # batch_size = config.get("batch_size")
+        # epochs = config.get("epochs")
 
         # dataset_module = config.get("dataset_module")
         # dataset_name = config.get("dataset_name")
@@ -60,6 +60,8 @@ class MultiPipeline():
         experiment_tags = config.get("experiment_tags")
         tracking_uri = config.get("tracking_uri")
         artifact_location = config.get("artifact_location")
+        #new
+        multi_modal = config.get("multi_modal")
         columns = config.get("columns")
         ner_data_file = config.get("ner_data_file")
         ner_threshold = config.get("ner_threshold")
@@ -69,8 +71,9 @@ class MultiPipeline():
         embedding_pooling_strategy = get_import(
             config.get("embedding_pooling_strategy_type")) if config.get("embedding_pooling_strategy_type") else None
         # Dynamically import the model and dataset classes
-        model_type = get_import(config.get("model_type"))
+        # model_type = get_import(config.get("model_type"))
         dataset_type = get_import(config.get("dataset_type"))
+
         combination_type = None
         kwargs_combination_params=None
         if config.get("combination_strategy"):
@@ -100,7 +103,8 @@ class MultiPipeline():
                 embedding_pooling_strategy_type=embedding_pooling_strategy,
                 ner_data_file=ner_data_file,
                 ner_threshold=ner_threshold,
-                combinations=combinations)
+                combinations=combinations,
+                multi_modal= multi_modal)
         elif type== "ner_search":
             pipeline = NerParameterSearch(
                 library=library,
@@ -119,9 +123,9 @@ class MultiPipeline():
         return {
             "name": experiment_name,
             "library": library,
-            "batch_size": batch_size,
-            "epochs": epochs,
-            "model_type": model_type,
+            # "batch_size": batch_size,
+            # "epochs": epochs,
+            # "model_type": model_type,
             "pipeline": pipeline}
 
     def build(self):
@@ -135,11 +139,11 @@ class MultiPipeline():
             print(f"{item['name']} is running")
             pipeline = item['pipeline']
             model_type = item['model_type']
-            batch_size = item['batch_size']
-            epochs = item['epochs']
+            # 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)
+            result = pipeline.run(model_type)
             self.pipeline_resuts[item['name']] = result
         return self
 

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/src/ddi_fw/pipeline/pipeline.py

@@ -28,7 +28,8 @@ class Pipeline:
                  ner_data_file=None,
                  ner_threshold=None,
                  combinations=None,
-                 model=None):
+                 model=None,
+                 multi_modal = None ):
         self.library = library
         self.experiment_name = experiment_name
         self.experiment_description = experiment_description
@@ -46,6 +47,7 @@ class Pipeline:
         self.ner_threshold = ner_threshold
         self.combinations = combinations
         self.model = model
+        self.multi_modal = multi_modal
 
     def __create_or_update_embeddings__(self, embedding_dict, vector_db_persist_directory, vector_db_collection_name, column=None):
         """
@@ -155,6 +157,7 @@ class Pipeline:
         self.train_idx_arr = self.dataset.train_idx_arr
         self.val_idx_arr = self.dataset.val_idx_arr
         # Logic to set up the experiment
+        # column name, train data, train label, test data, test label
         self.items = self.dataset.produce_inputs()
 
         unique_classes = pd.unique(self.dataframe['event_category'])
@@ -168,7 +171,7 @@ class Pipeline:
         # Implement additional build logic as needed
         return self
 
-    def run(self, model_func, batch_size=128, epochs=100):
+    def run(self):
         mlflow.set_tracking_uri(self.tracking_uri)
 
         if mlflow.get_experiment_by_name(self.experiment_name) == None:
@@ -178,8 +181,9 @@ class Pipeline:
         mlflow.set_experiment(self.experiment_name)
 
         y_test_label = self.items[0][4]
-        multi_modal_runner = MultiModalRunner(
-            library=self.library, model_func=model_func, batch_size=batch_size,  epochs=epochs)
+        multi_modal_runner = MultiModalRunner(library=self.library, multi_modal = self.multi_modal)
+        # multi_modal_runner = MultiModalRunner(
+        #     library=self.library, model_func=model_func, batch_size=batch_size,  epochs=epochs)
         # multi_modal = TFMultiModal(
         #     model_func=model_func, batch_size=batch_size,  epochs=epochs)  # 100
         multi_modal_runner.set_data(

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/src/ddi_fw.egg-info/PKG-INFO

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

{ddi_fw-0.0.130 → ddi_fw-0.0.132}/src/ddi_fw.egg-info/SOURCES.txt

@@ -94,6 +94,7 @@ src/ddi_fw/pipeline/multi_modal_combination_strategy.py
 src/ddi_fw/pipeline/multi_pipeline.py
 src/ddi_fw/pipeline/ner_pipeline.py
 src/ddi_fw/pipeline/pipeline.py
+src/ddi_fw/test/__init__.py
 src/ddi_fw/test/basic_test.py
 src/ddi_fw/test/combination_test.py
 src/ddi_fw/test/compress_json_test.py

ddi_fw-0.0.130/src/ddi_fw/ml/tensorflow_wrapper.py

@@ -1,157 +0,0 @@
-from ddi_fw.ml.model_wrapper import ModelWrapper
-import tensorflow as tf
-from tensorflow import keras
-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
-
-from mlflow.models import infer_signature
-from ddi_fw.ml.evaluation_helper import Metrics, evaluate
-
-# import tf2onnx
-# import onnx
-
-import ddi_fw.utils as utils
-
-
-class TFModelWrapper(ModelWrapper):
-    # 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]
-
-                    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()
-                    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, checkpoint, custom_callback])
-                    # histories[f'validation_{i}'] = history
-                    # 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]
-            # 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(
-                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())