ddi-fw 0.0.185__tar.gz → 0.0.187__tar.gz

{ddi_fw-0.0.185 → ddi_fw-0.0.187}/PKG-INFO

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

{ddi_fw-0.0.185 → ddi_fw-0.0.187}/pyproject.toml

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

{ddi_fw-0.0.185 → ddi_fw-0.0.187}/src/ddi_fw/datasets/core.py

@@ -60,10 +60,10 @@ class BaseDataset(BaseModel):
     dataset_splitter_type: Type[DatasetSplitter]
     class_column: str = 'class'
     dataframe: Optional[pd.DataFrame] = None
-    X_train: Optional[pd.DataFrame | np.ndarray] = None
-    X_test: Optional[pd.DataFrame | np.ndarray] = None
-    y_train: Optional[pd.Series | np.ndarray] = None
-    y_test: Optional[pd.Series | np.ndarray] = None
+    X_train: Optional[np.ndarray] = None
+    X_test: Optional[np.ndarray] = None
+    y_train: Optional[np.ndarray] = None
+    y_test: Optional[np.ndarray] = None
     train_indexes: Optional[pd.Index] = None
     test_indexes: Optional[pd.Index] = None
     train_idx_arr: Optional[List[np.ndarray]] = None
@@ -81,7 +81,7 @@ class BaseDataset(BaseModel):
             self.y_train), np.array(self.y_test)
 
         if self.columns is None or len(self.columns) == 0:
-            items.append([f'defaukt', np.nan_to_num(self.X_train),
+            items.append([f'default', np.nan_to_num(self.X_train),
                           y_train_label, np.nan_to_num(self.X_test), y_test_label])
         else:
             for index, column in enumerate(self.columns):
@@ -127,11 +127,12 @@ class BaseDataset(BaseModel):
         Load the dataset. If X_train, y_train, X_test, and y_test are already provided,
         skip deriving them. Otherwise, derive them from the dataframe and indices.
         """
-        if self.X_train is not None and self.y_train is not None and self.X_test is not None and self.y_test is not None:
+        if self.X_train  and self.y_train and self.X_test and self.y_test :
             # Data is already provided, no need to calculate
             logging.info(
                 "X_train, y_train, X_test, and y_test are already provided. Skipping calculation.")
-            return self.X_train, self.X_test, self.y_train, self.y_test, self.train_indexes, self.test_indexes, self.train_idx_arr, self.val_idx_arr
+            return
+            # return self.X_train, self.X_test, self.y_train, self.y_test, self.train_indexes, self.test_indexes, self.train_idx_arr, self.val_idx_arr
 
         self.prep()
 
@@ -150,24 +151,26 @@ class BaseDataset(BaseModel):
 
         train = self.dataframe[self.dataframe.index.isin(train_idx_all)]
         test = self.dataframe[self.dataframe.index.isin(test_idx_all)]
+        X_train = train.drop(self.class_column, axis=1)
+        X_train = train.drop(self.class_column, axis=1)
+        y_train = train[self.class_column]
+        X_test = test.drop(self.class_column, axis=1)
+        y_test = test[self.class_column]
+        
+        self.X_train = np.array(X_train)
+        self.y_train = np.array(y_train)
+        self.X_test = np.array(X_test)
+        self.y_test = np.array(y_test)
 
-        self.X_train = train.drop(self.class_column, axis=1)
-        self.y_train = train[self.class_column]
-        self.X_test = test.drop(self.class_column, axis=1)
-        self.y_test = test[self.class_column]
-
-        self.train_indexes = self.X_train.index
-        self.test_indexes = self.X_test.index
+        self.train_indexes = X_train.index
+        self.test_indexes = X_test.index
         self.train_idx_arr = train_idx_arr
         self.val_idx_arr = val_idx_arr
 
         # Dataframe to numpy array conversion
-        self.X_train = np.array(self.X_train)
-        self.y_train = np.array(self.y_train)
-        self.X_test = np.array(self.X_test)
-        self.y_test = np.array(self.y_test)
+       
 
-        return self.X_train, self.X_test, self.y_train, self.y_test, self.train_indexes, self.test_indexes, self.train_idx_arr, self.val_idx_arr
+        # return self.X_train, self.X_test, self.y_train, self.y_test, self.train_indexes, self.test_indexes, self.train_idx_arr, self.val_idx_arr
 
     def __get_indexes__(self, path):
         train_index_path = path+'/train_indexes.txt'
@@ -219,21 +222,16 @@ class BaseDataset(BaseModel):
 
         X_train, X_test, y_train, y_test, X_train.index, X_test.index, train_idx_arr, val_idx_arr = self.dataset_splitter.split(
             X=X, y=y)
-        self.X_train = X_train
-        self.X_test = X_test
-        self.y_train = y_train
-        self.y_test = y_test
+        self.X_train = np.array(self.X_train)
+        self.X_test = np.array(self.X_test)
+        self.y_train =  np.array(y_train.tolist())
+        self.y_test = np.array(y_test.tolist())
         self.train_indexes = X_train.index
         self.test_indexes = X_test.index
         self.train_idx_arr = train_idx_arr
         self.val_idx_arr = val_idx_arr
 
-        # Dataframe to numpy array conversion
-        self.X_train = np.array(self.X_train)
-        self.y_train = np.array(self.y_train.tolist())
-        self.X_test = np.array(self.X_test)
-        self.y_test = np.array(self.y_test.tolist())
-
+       
         if save_indexes:
             # train_pairs = [row['id1'].join(',').row['id2'] for index, row in X_train.iterrows()]
             self.__save_indexes__(

{ddi_fw-0.0.185 → ddi_fw-0.0.187}/src/ddi_fw/ml/ml_helper.py

@@ -32,7 +32,7 @@ import ddi_fw.utils as utils
 
 class MultiModalRunner:
     # todo model related parameters to config
-    def __init__(self, library, multi_modal, use_mlflow=True):
+    def __init__(self, library, multi_modal, use_mlflow=False):
         self.library = library
         self.multi_modal = multi_modal
         self.use_mlflow = use_mlflow
@@ -111,44 +111,6 @@ class MultiModalRunner:
         if self.use_mlflow:
             with mlflow.start_run(run_name=self.prefix, description="***") as run:
                 self.__predict(single_results)
-                # self.level_0_run_id = run.info.run_id
-                # item_dict = {t[0]: t for t in self.items}
-                # print("multi_modal")
-                # print(self.multi_modal)
-                # print(item_dict.keys())
-
-                # 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':
-                #         # check keys
-                #         filtered_dict = {k: item_dict[k]
-                #                          for k in inputs if k in item_dict}
-                #         print(filtered_dict.keys())
-                #         first_input = next(iter(filtered_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[4]
-                #         single_modal.set_data(
-                #             self.train_idx_arr, self.val_idx_arr, train_data, train_label, test_data, test_label)
-                #     else:
-                #         raise Exception("check configurations")
-                #     logs, metrics, prediction = single_modal.fit_and_evaluate()
-                #     self.result.add_metric(name, metrics)
-                #     single_results[name] = prediction
         else:
             self.__predict(single_results)
         if combinations:

{ddi_fw-0.0.185 → ddi_fw-0.0.187}/src/ddi_fw/ml/tensorflow_wrapper.py

@@ -120,7 +120,7 @@ class TFModelWrapper(ModelWrapper):
         print(self.train_data.shape)
         models = {}
         models_val_acc = {}
-        if self.train_idx_arr is not None and self.val_idx_arr is not None:
+        if self.train_idx_arr and self.val_idx_arr:
             for i, (train_idx, val_idx) in enumerate(zip(self.train_idx_arr, self.val_idx_arr)):
                 print(f"Validation {i}")
 
@@ -155,7 +155,8 @@ class TFModelWrapper(ModelWrapper):
                     self.train_data, self.train_label, None, None)
                 models[self.descriptor] = model
                 models_val_acc[self.descriptor] = checkpoint.best
-
+        if models_val_acc == {}:
+            return model, None
         best_model_key = max(models_val_acc, key=lambda k: models_val_acc[k])
         # best_model_key = max(models_val_acc, key=models_val_acc.get)
         best_model = models[best_model_key]

{ddi_fw-0.0.185 → ddi_fw-0.0.187}/src/ddi_fw/pipeline/ner_pipeline.py

@@ -106,7 +106,7 @@ class NerParameterSearch:
                     **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()
+                dataset.load()
                 group_items = dataset.produce_inputs()
                 for item in group_items:
                     # item[0] = f'threshold_{threshold}_{item[0]}'
@@ -115,8 +115,8 @@ class NerParameterSearch:
 
                 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
+        self.train_idx_arr = dataset.train_idx_arr
+        self.val_idx_arr = dataset.val_idx_arr
 
     def run(self, model_func, batch_size=128, epochs=100):
         mlflow.set_tracking_uri(self.tracking_uri)

{ddi_fw-0.0.185 → ddi_fw-0.0.187}/src/ddi_fw/pipeline/pipeline.py

@@ -36,7 +36,7 @@ class Pipeline(BaseModel):
     combinations: Optional[List[str]] = None
     model: Optional[Any] = None
     multi_modal:  Optional[Any] = None
-    use_mlflow: bool = True
+    use_mlflow: bool = False
     _items:List=[]
     _train_idx_arr:List|None=[]
     _val_idx_arr:List|None=[]
@@ -53,45 +53,7 @@ class Pipeline(BaseModel):
 
     class Config:
         arbitrary_types_allowed = True
-
-# class Pipeline:
-#     def __init__(self,
-#                  library='tensorflow',
-#                  experiment_name=None,
-#                  experiment_description=None,
-#                  experiment_tags=None,
-#                  artifact_location=None,
-#                  tracking_uri=None,
-#                  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,
-#                  ner_data_file=None,
-#                  ner_threshold=None,
-#                  combinations=None,
-#                  model=None,
-#                  multi_modal = None ):
-#         self.library = library
-#         self.experiment_name = experiment_name
-#         self.experiment_description = experiment_description
-#         self.experiment_tags = experiment_tags
-#         self.artifact_location = artifact_location
-#         self.tracking_uri = tracking_uri
-#         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
-#         self.ner_data_file = ner_data_file
-#         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):
         """
@@ -194,35 +156,27 @@ class Pipeline(BaseModel):
                 embedding_dict=embedding_dict,
                 embedding_size=embedding_size,
                 embeddings_pooling_strategy=pooling_strategy,
-                dataset_splitter = dataset_splitter,
+                dataset_splitter_type = self.dataset_splitter_type,
+                **kwargs)
+        elif self.dataset_type == BaseDataset:
+             dataset = self.dataset_type(
+                dataset_splitter_type = self.dataset_splitter_type,
                 **kwargs)
         else:
             dataset = self.dataset_type(**kwargs)
 
         # X_train, X_test, y_train, y_test, train_indexes, test_indexes, train_idx_arr, val_idx_arr = dataset.load()
         dataset.load()
-
         dataframe = dataset.dataframe
+        b = not( dataset.X_train and dataset.y_train and dataset.X_test and dataset.y_test)
+        c = dataframe is None or dataframe.empty 
 
-        if dataframe is None:  # if the dataframe is None, it means that the dataset is not loaded
+        if b or c:
             raise ValueError("The dataset is not loaded")
-
-        # dataframe.dropna()
-        # X_train = dataset.X_train
-        # X_test = dataset.X_test
-        # y_train = dataset.y_train
-        # y_test = dataset.y_test
-        # self._train_idx_arr = dataset.train_idx_arr
-        # self._val_idx_arr = dataset.val_idx_arr
-        # Logic to set up the experiment
+ 
         # column name, train data, train label, test data, test label
         self._items = dataset.produce_inputs()
-
-        # unique_classes = pd.unique(dataframe[dataset.class_column])
-        # 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: {dataset}, Model: {self.model}")
@@ -244,7 +198,7 @@ class Pipeline(BaseModel):
 
         y_test_label = self.items[0][4]
         multi_modal_runner = MultiModalRunner(
-            library=self.library, multi_modal=self.multi_modal)
+            library=self.library, multi_modal=self.multi_modal, use_mlflow=self.use_mlflow)
         # multi_modal_runner = MultiModalRunner(
         #     library=self.library, model_func=model_func, batch_size=batch_size,  epochs=epochs)
         # multi_modal = TFMultiModal(

{ddi_fw-0.0.185 → ddi_fw-0.0.187}/src/ddi_fw.egg-info/PKG-INFO

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