ddi-fw 0.0.73__py3-none-any.whl → 0.0.75__py3-none-any.whl

ddi_fw/experiments/__init__.py

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

ddi_fw/experiments/ml_helper.py

@@ -0,0 +1,137 @@
+from typing import Dict, List, Tuple
+from matplotlib import pyplot as plt
+from ddi_fw.experiments.ml_pt import PTSingleModal
+from ddi_fw.experiments.ml_tf import TFSingleModal
+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 Metrics, evaluate
+
+# import tf2onnx
+# import onnx
+
+import itertools
+import ddi_fw.utils as utils
+
+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 SingleModal:
+    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) -> Tuple[Dict[str, float], Metrics, List[float]]:
+        pass
+ 
+
+class MultiModalRunner:
+    # todo model related parameters to config
+    def __init__(self, library ,model_func, batch_size=128, epochs=100):
+        self.library = library
+        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 __create_multi_modal(self,library):
+        if library == 'tensorflow':
+            return TFSingleModal
+        elif library == 'pytorch':
+            return PTSingleModal
+        else:
+            raise ValueError("Unsupported library type. Choose 'tensorflow' or 'pytorch'.")
+
+    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])
+                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])
+                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
+                # 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)

ddi_fw/experiments/ml_pt.py

@@ -0,0 +1,83 @@
+import mlflow
+import torch
+from ddi_fw.experiments.ml_helper import SingleModal
+from ddi_fw.experiments.evaluation_helper import evaluate
+
+
+class PTSingleModal(SingleModal):
+    def __init__(self, date, descriptor, model_func, batch_size=128, epochs=100, **kwargs):
+        super().__init__(date, descriptor, model_func, batch_size, epochs)
+        self.optimizer = kwargs['optimizer']
+        self.criterion = kwargs['criterion']
+
+    def _create_dataloader(self, data, labels):
+        dataset = torch.utils.data.TensorDataset(data, labels)
+        return torch.utils.data.DataLoader(dataset, batch_size=self.batch_size, shuffle=True)
+
+    def predict(self):
+        print(self.train_data.shape)
+
+        with mlflow.start_run(run_name=self.descriptor, description="***", nested=True) as run:
+            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:
+                    model = self.model_func(self.train_data.shape[1])
+                    models[f'validation_{i}'] = model
+
+                    # Create DataLoaders
+                    X_train_cv = torch.tensor(self.train_data[train_idx], dtype=torch.float16)
+                    y_train_cv = torch.tensor(self.train_label[train_idx], dtype=torch.float16)
+                    X_valid_cv = torch.tensor(self.train_data[val_idx], dtype=torch.float16)
+                    y_valid_cv = torch.tensor(self.train_label[val_idx], dtype=torch.float16)
+
+                    train_loader = self._create_dataloader(X_train_cv, y_train_cv)
+                    valid_loader = self._create_dataloader(X_valid_cv, y_valid_cv)
+
+                    optimizer = self.optimizer
+                    criterion = self.criterion
+                    best_val_loss = float('inf')
+
+                    for epoch in range(self.epochs):
+                        model.train()
+                        for batch_X, batch_y in train_loader:
+                            optimizer.zero_grad()
+                            output = model(batch_X)
+                            loss = criterion(output, batch_y)
+                            loss.backward()
+                            optimizer.step()
+
+                        model.eval()
+                        with torch.no_grad():
+                            val_loss = self._validate(model, valid_loader)
+
+                        # Callbacks after each epoch
+                        for callback in self.callbacks:
+                            callback.on_epoch_end(epoch, logs={'loss': loss.item(), 'val_loss': val_loss.item()})
+
+                        if val_loss < best_val_loss:
+                            best_val_loss = val_loss
+                            best_model = model
+
+                    # Evaluate on test data
+                    with torch.no_grad():
+                        pred = best_model(torch.tensor(self.test_data, dtype=torch.float16))
+                        logs, metrics = evaluate(
+                            actual=self.test_label, pred=pred.numpy(), info=self.descriptor)
+                        mlflow.log_metrics(logs)
+
+            return logs, metrics, pred.numpy()
+
+    def _validate(self, model, valid_loader):
+        total_loss = 0
+        criterion = self.criterion
+
+        for batch_X, batch_y in valid_loader:
+            output = model(batch_X)
+            loss = criterion(output, batch_y)
+            total_loss += loss.item()
+
+        return total_loss / len(valid_loader)

ddi_fw/experiments/ml_tf.py

@@ -0,0 +1,148 @@
+from typing import Dict, List, Tuple
+from matplotlib import pyplot as plt
+from ddi_fw.experiments.ml_helper import SingleModal
+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 Metrics, evaluate
+
+# import tf2onnx
+# import onnx
+
+import itertools
+import ddi_fw.utils as utils
+
+
+class TFSingleModal(SingleModal):
+    # 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())

ddi_fw/experiments/tensorflow_helper.py

@@ -78,9 +78,10 @@ class TFMultiModal:
                 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_log(item[0], logs)
                 # self.result.add_metric(item[0], metrics)
-                single_results[item[0]] = prediction
+                # single_results[item[0]] = prediction  
+                single_results[item[0]] = tf.nn.softmax(prediction).numpy()  
                 # sum = sum + prediction
 
             if combinations:

{ddi_fw-0.0.73.dist-info → ddi_fw-0.0.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ddi_fw
-Version: 0.0.73
+Version: 0.0.75
 Summary: Do not use :)
 Author-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>
 Maintainer-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>
@@ -36,10 +36,17 @@ Requires-Dist: scikit-learn==1.5.2
 Requires-Dist: scipy==1.13.1
 Requires-Dist: accelerate==0.33.0
 Requires-Dist: sentence-transformers==3.0.1
+Requires-Dist: transformers==4.42.4
 Requires-Dist: stanza==1.9.2
 Requires-Dist: tokenizers==0.19.1
 Requires-Dist: tqdm==4.66.5
 Requires-Dist: xmlschema==3.4.2
 Requires-Dist: zipp==3.20.2
 Requires-Dist: py7zr==0.22.0
+Requires-Dist: openai==1.52.2
+Requires-Dist: langchain==0.3.4
+Requires-Dist: chromadb==0.5.15
+Requires-Dist: langchain-community==0.3.3
+Requires-Dist: datasets==3.0.2
+Requires-Dist: unstructured==0.16.3
 

{ddi_fw-0.0.73.dist-info → ddi_fw-0.0.75.dist-info}/RECORD

@@ -55,13 +55,16 @@ 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/__init__.py,sha256=FwfHXSKhWrkAYq5-FEFZqCl7i3udr4mfxZEYNadlvAI,248
 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/ml_helper.py,sha256=OAFYCrwsvCdtAGo407Cwu4xvl7GMq0vwa2gndFImSUA,5468
+ddi_fw/experiments/ml_pt.py,sha256=9Tl_kn5u6CRqMcJBpfqhCXamyMTrU8v97zJMUPm6K3A,3727
+ddi_fw/experiments/ml_tf.py,sha256=jWqq5sQjoazNxtDiUlFWtygOiga3FSZLsmrZm0vifcE,5788
 ddi_fw/experiments/pipeline.py,sha256=N07EBv2IGa9oD0A1XxvUktDjGHi0SFmt3QqupF2rs3k,5681
 ddi_fw/experiments/pipeline_builder_pattern.py,sha256=w6x7ietk4vONCAvUfssPycaRUQIYUJsbCNNj3BTASBI,5454
 ddi_fw/experiments/pipeline_ner.py,sha256=unxEJCYrG6wEZjLmqvGdLRTMOBwELbGKkdygSpAR3b8,5043
-ddi_fw/experiments/tensorflow_helper.py,sha256=xUnbntWyc2Wm4TvmVFAnpwLHg-o13oM26GUHom6d5m0,11776
+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
@@ -86,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.73.dist-info/METADATA,sha256=_TGLs-BxfZCpTdHvOUpiuniNKSF9iJDRkipbMn6ovR4,1720
-ddi_fw-0.0.73.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-ddi_fw-0.0.73.dist-info/top_level.txt,sha256=PMwHICFZTZtcpzQNPV4UQnfNXYIeLR_Ste-Wfc1h810,7
-ddi_fw-0.0.73.dist-info/RECORD,,
+ddi_fw-0.0.75.dist-info/METADATA,sha256=XXvBSuoVcdQ-npCJpaZiFACOsnk2_1EjwC2YMtOJxEk,1966
+ddi_fw-0.0.75.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+ddi_fw-0.0.75.dist-info/top_level.txt,sha256=PMwHICFZTZtcpzQNPV4UQnfNXYIeLR_Ste-Wfc1h810,7
+ddi_fw-0.0.75.dist-info/RECORD,,

{ddi_fw-0.0.73.dist-info → ddi_fw-0.0.75.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any