ddi-fw 0.0.148__tar.gz → 0.0.150__tar.gz

{ddi_fw-0.0.148 → ddi_fw-0.0.150}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ddi_fw
-Version: 0.0.148
+Version: 0.0.150
 Summary: Do not use :)
 Author-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>
 Maintainer-email: Kıvanç Bayraktar <bayraktarkivanc@gmail.com>
@@ -22,6 +22,7 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: pydantic==2.10.6
 Requires-Dist: importlib-resources==6.4.5
 Requires-Dist: python-stopwatch==1.1.11
 Requires-Dist: lxml==5.3.0
@@ -35,7 +36,7 @@ Requires-Dist: rdkit==2023.3.3
 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: sentence-transformers<=3.3.1,>=3.0.1
 Requires-Dist: transformers>=4.42.4
 Requires-Dist: stanza==1.9.2
 Requires-Dist: tokenizers>=0.19.1
@@ -49,3 +50,5 @@ 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
+Requires-Dist: tensorflow<2.18.0,>=2.17.0
+Requires-Dist: tf-keras==2.17.0

{ddi_fw-0.0.148 → ddi_fw-0.0.150}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ddi_fw"
-version = "0.0.148"
+version = "0.0.150"
 description = "Do not use :)"
 readme = "README.md"
 authors = [
@@ -45,7 +45,8 @@ license = { file = "LICENSE" }
 
 requires-python = ">=3.10"
 dependencies = [
-"importlib-resources==6.4.5"
+"pydantic==2.10.6"
+,"importlib-resources==6.4.5"
 ,"python-stopwatch==1.1.11"
 ,"lxml==5.3.0"
 ,"matplotlib==3.8.0"
@@ -58,7 +59,7 @@ dependencies = [
 ,"scikit-learn==1.5.2"
 ,"scipy==1.13.1"
 ,"accelerate>=0.33.0"
-,"sentence-transformers>=3.0.1"
+,"sentence-transformers>=3.0.1,<=3.3.1"
 ,"transformers>=4.42.4"
 ,"stanza==1.9.2"
 ,"tokenizers>=0.19.1"
@@ -71,7 +72,9 @@ dependencies = [
 ,"chromadb>=0.5.15"
 ,"langchain_community==0.3.3"
 ,"datasets==3.0.2"
-,"unstructured==0.16.3"
+,"unstructured==0.16.3",
+"tensorflow>=2.17.0,<2.18.0"
+,"tf-keras==2.17.0"
 ]
  
 
@@ -85,3 +88,15 @@ where = ["src"]  # list of folders that contain the packages (["."] by default)
 # See https://setuptools.pypa.io/en/latest/userguide/datafiles.html
 [tool.setuptools.package-data]
 "*" = ["*.*"]
+
+[tool.coverage.run]
+source = ["src"]
+
+# pyproject.toml
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+
+testpaths = [
+    "tests"
+]

{ddi_fw-0.0.148 → ddi_fw-0.0.150}/src/ddi_fw/datasets/__init__.py

@@ -5,7 +5,7 @@ from .mdf_sa_ddi.base import MDFSADDIDataset
 from .embedding_generator import create_embeddings
 from .idf_helper import IDF
 from .feature_vector_generation import SimilarityMatrixGenerator, VectorGenerator
-
+from .dataset_splitter import DatasetSplitter
 __all__  = ['BaseDataset','DDIMDLDataset','MDFSADDIDataset']
 
 

ddi_fw-0.0.150/src/ddi_fw/datasets/core.py

@@ -0,0 +1,211 @@
+import glob
+from typing import List, Optional, Type
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel, Field, computed_field
+from ddi_fw.datasets.dataset_splitter import DatasetSplitter
+from ddi_fw.datasets.feature_vector_generation import SimilarityMatrixGenerator, VectorGenerator
+from ddi_fw.langchain.embeddings import PoolingStrategy
+from ddi_fw.utils.utils import create_folder_if_not_exists
+
+
+def stack(df_column):
+    return np.stack(df_column.values)
+
+
+def generate_vectors(df, columns):
+    vectorGenerator = VectorGenerator(df)
+    generated_vectors = vectorGenerator.generate_feature_vectors(
+        columns)
+    return generated_vectors
+
+
+def generate_sim_matrices_new(df, generated_vectors, columns, key_column="id"):
+    jaccard_sim_dict = {}
+    sim_matrix_gen = SimilarityMatrixGenerator()
+
+    for column in columns:
+        # key = '2D_'+column
+        key = column
+        jaccard_sim_dict[column] = sim_matrix_gen.create_jaccard_similarity_matrices(
+            generated_vectors[key])
+
+    similarity_matrices = {}
+    keys = df[key_column].to_list()
+    new_columns = {}
+    for idx in range(len(keys)):
+        new_columns[idx] = keys[idx]
+    for column in columns:
+        new_df = pd.DataFrame.from_dict(jaccard_sim_dict[column])
+        new_df = new_df.rename(index=new_columns, columns=new_columns)
+        similarity_matrices[column] = new_df
+    return similarity_matrices
+
+
+class BaseDataset(BaseModel):
+    dataset_name: str
+    index_path: str
+    dataset_splitter_type: Type[DatasetSplitter]
+    class_column: str = 'class'
+    dataframe: Optional[pd.DataFrame] = None
+    X_train:	Optional[pd.DataFrame] = None
+    X_test:	Optional[pd.DataFrame] = None
+    y_train:	Optional[pd.Series] = None
+    y_test:	Optional[pd.Series] = None
+    train_indexes:	Optional[pd.Index] = None
+    test_indexes:	Optional[pd.Index] = None
+    train_idx_arr:	List|None = None
+    val_idx_arr:	List|None = None
+    # train_idx_arr:	Optional[List[np.ndarray]] = None
+    # val_idx_arr:	Optional[List[np.ndarray]] = None
+    columns: List[str] = []
+
+    # feature_process: FeatureProcessor
+    # similarity_matrix_service: SimilarityMatrixService
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def produce_inputs(self):
+        items = []
+        if self.X_train is None or self.X_test is None:
+            raise Exception("There is no data to produce inputs")
+        y_train_label, y_test_label = stack(self.y_train), stack(self.y_test)
+
+        for column in self.columns:
+            train_data, test_data = stack(
+                self.X_train[column]), stack(self.X_test[column])
+            items.append([f'{column}', np.nan_to_num(train_data),
+                          y_train_label, np.nan_to_num(test_data), y_test_label])
+
+            # items.append([f'{column}_embedding', train_data,
+            #             y_train_label, test_data, y_test_label])
+        return items
+    
+    @computed_field
+    @property
+    def dataset_splitter(self) -> DatasetSplitter:
+        return self.dataset_splitter_type()
+
+    def set_dataframe(self, dataframe: pd.DataFrame):
+        self.dataframe = dataframe
+
+    # @abstractmethod
+    def prep(self):
+        pass
+
+    def load(self):
+        if self.index_path is None:
+            raise Exception(
+                "There is no index path, please call split function")
+
+        try:
+            train_idx_all, test_idx_all, train_idx_arr, val_idx_arr = self.__get_indexes__(
+                self.index_path)
+        except FileNotFoundError as e:
+            raise FileNotFoundError(f"Index files not found: {e.filename}")
+
+        self.prep()
+
+        if self.dataframe is None:
+            raise Exception("There is no dataframe")
+
+        train = self.dataframe[self.dataframe.index.isin(train_idx_all)]
+        test = self.dataframe[self.dataframe.index.isin(test_idx_all)]
+
+        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_idx_arr = train_idx_arr
+        self.val_idx_arr = val_idx_arr
+
+        return self.X_train, self.X_test, self.y_train, self.y_test, self.X_train.index, self.X_test.index, train_idx_arr, val_idx_arr
+
+    def __get_indexes__(self, path):
+        train_index_path = path+'/train_indexes.txt'
+        test_index_path = path+'/test_indexes.txt'
+        train_fold_files = f'{path}/train_fold_*.txt'
+        val_fold_files = f'{path}/validation_fold_*.txt'
+        train_idx_arr = []
+        val_idx_arr = []
+        with open(train_index_path, 'r', encoding="utf8") as f:
+            train_idx_all = [int(r) for r in f.readlines()]
+        with open(test_index_path, 'r', encoding="utf8") as f:
+            test_idx_all = [int(r) for r in f.readlines()]
+
+        for filepath in glob.glob(train_fold_files):
+            with open(filepath, 'r', encoding="utf8") as f:
+                train_idx = [int(r) for r in f.readlines()]
+                train_idx_arr.append(train_idx)
+        for filepath in glob.glob(val_fold_files):
+            with open(filepath, 'r', encoding="utf8") as f:
+                val_idx = [int(r) for r in f.readlines()]
+                val_idx_arr.append(val_idx)
+        return train_idx_all, test_idx_all, train_idx_arr, val_idx_arr
+
+    def __save_indexes__(self, path, filename, indexes):
+        create_folder_if_not_exists(path)
+        file_path = path + '/'+filename
+        str_indexes = [str(index) for index in indexes]
+        with open(file_path, 'w') as f:
+            f.write('\n'.join(str_indexes))
+
+    def split_dataset(self, save_indexes: bool = False):
+        # TODO class type should be parametric
+
+        save_path = self.index_path
+        self.prep()
+
+        if self.dataframe is None:
+            raise Exception("There is no data")
+
+        X = self.dataframe.drop(self.class_column, axis=1)
+        y = self.dataframe[self.class_column]
+
+        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.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
+
+        if save_indexes:
+            # train_pairs = [row['id1'].join(',').row['id2'] for index, row in X_train.iterrows()]
+            self.__save_indexes__(
+                save_path, 'train_indexes.txt', self.train_indexes.values)
+            self.__save_indexes__(
+                save_path, 'test_indexes.txt',  self.test_indexes.values)
+
+            for i, (train_idx, val_idx) in enumerate(zip(train_idx_arr, val_idx_arr)):
+                self.__save_indexes__(
+                    save_path, f'train_fold_{i}.txt', train_idx)
+                self.__save_indexes__(
+                    save_path, f'validation_fold_{i}.txt', val_idx)
+
+        # return X_train, X_test, y_train, y_test, folds
+
+
+class TextDatasetMixin(BaseDataset):
+    embedding_size: int
+    embedding_dict: dict
+    embeddings_pooling_strategy: PoolingStrategy | None = None
+
+    def process_text(self):
+        pass
+
+
+# class ImageDatasetMixin(BaseModel):
+#     image_size: tuple[int, int] = Field(default=(224, 224))
+#     augmentations: list[str] = Field(default_factory=list)
+
+#     def process_image_data(self):
+#         print(
+#             f"Processing image data with size {self.image_size} and augmentations {self.augmentations}...")

ddi_fw-0.0.150/src/ddi_fw/datasets/dataset_splitter.py

@@ -0,0 +1,39 @@
+from typing import List, Tuple
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel, Field
+from sklearn.model_selection import StratifiedKFold, train_test_split
+
+
+class DatasetSplitter(BaseModel):
+    fold_size: int = Field(default=5, ge=2)
+    test_size: float = Field(default=0.2, ge=0.0, le=1.0)
+    shuffle: bool = True
+    random_state: int = Field(default=42)
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def split(self, X: pd.DataFrame, y: pd.Series)-> Tuple[
+    pd.DataFrame, pd.DataFrame, pd.Series, pd.Series, pd.Index, pd.Index, List[np.ndarray], List[np.ndarray]]:
+        print(
+            f"Splitting dataset into {self.fold_size} folds with shuffle={self.shuffle}...")
+        #TODO check it
+        if len(y.shape) == 1:
+            y = pd.Series(np.expand_dims(y.to_numpy(), axis=1).flatten())
+        stacked = np.vstack(tuple(y.to_numpy()))
+        stratify = np.argmax(stacked, axis=1)
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, shuffle=self.shuffle, test_size=self.test_size, stratify=stratify)
+
+        k_fold = StratifiedKFold(
+            n_splits=self.fold_size, shuffle=self.shuffle, random_state=self.random_state)
+        folds = k_fold.split(X_train, np.argmax(
+            np.vstack(y_train.to_numpy()), axis=1))
+        train_idx_arr = []
+        val_idx_arr = []
+        for i, (train_index, val_index) in enumerate(folds):
+            train_idx_arr.append(train_index)
+            val_idx_arr.append(val_index)
+
+        return X_train, X_test, y_train, y_test, X_train.index, X_test.index, train_idx_arr, val_idx_arr

ddi_fw-0.0.150/src/ddi_fw/datasets/ddi_mdl/base.py

@@ -0,0 +1,213 @@
+import glob
+import pathlib
+from typing import List, Optional, Tuple
+from ddi_fw.datasets.core import BaseDataset, TextDatasetMixin, generate_sim_matrices_new, generate_vectors
+from ddi_fw.datasets.dataset_splitter import DatasetSplitter
+from ddi_fw.datasets.db_utils import create_connection
+from ddi_fw.datasets.idf_helper import IDF
+from ddi_fw.utils.utils import create_folder_if_not_exists
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel, Field, model_validator, root_validator
+from ddi_fw.datasets.feature_vector_generation import SimilarityMatrixGenerator,VectorGenerator
+from ddi_fw.langchain.embeddings import PoolingStrategy
+from abc import ABC, abstractmethod
+from sklearn.preprocessing import LabelBinarizer
+
+from sklearn.model_selection import KFold, StratifiedKFold, train_test_split
+
+# Constants for embedding, chemical properties, and NER columns
+LIST_OF_EMBEDDING_COLUMNS = [
+    'all_text', 'description', 'synthesis_reference', 'indication',
+    'pharmacodynamics', 'mechanism_of_action', 'toxicity', 'metabolism',
+    'absorption', 'half_life', 'protein_binding', 'route_of_elimination',
+    'volume_of_distribution', 'clearance'
+]
+
+LIST_OF_CHEMICAL_PROPERTY_COLUMNS = ['enzyme', 'target', 'pathway', 'smile']
+LIST_OF_NER_COLUMNS = ['tui', 'cui', 'entities']
+
+HERE = pathlib.Path(__file__).resolve().parent
+
+class DDIMDLDataset(TextDatasetMixin):
+    index_path: str = Field(default_factory=lambda: str(
+        pathlib.Path(__file__).resolve().parent.joinpath('indexes')))
+    # drugs_df: pd.DataFrame = Field(default_factory=pd.DataFrame)
+    # ddis_df: pd.DataFrame = Field(default_factory=pd.DataFrame)
+    drugs_df: Optional[pd.DataFrame] = None 
+    ddis_df: Optional[pd.DataFrame] = None 
+
+    chemical_property_columns: list[str] = Field(
+        default_factory=lambda: LIST_OF_CHEMICAL_PROPERTY_COLUMNS)
+    embedding_columns: list[str] = Field(default_factory=list)
+    ner_columns: list[str] = Field(default_factory=list)
+    ner_df: pd.DataFrame | None = None
+    tui_threshold: float | None = None
+    cui_threshold: float | None = None
+    entities_threshold: float | None = None
+
+
+    # @model_validator
+    def validate_columns(self, values):
+        if not set(values['chemical_property_columns']).issubset(LIST_OF_CHEMICAL_PROPERTY_COLUMNS):
+            raise ValueError("Invalid chemical property columns")
+        if not set(values['ner_columns']).issubset(LIST_OF_NER_COLUMNS):
+            raise ValueError("Invalid NER columns")
+        return values
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.class_column = 'event_category'
+        _db_path = HERE.joinpath('data/event.db')
+        
+        self.__similarity_related_columns__ = []
+        self.__similarity_related_columns__.extend(self.chemical_property_columns)
+        self.__similarity_related_columns__.extend(self.ner_columns)
+        # TODO with resource
+        self._conn = create_connection(_db_path.absolute().as_posix())
+        self.load_drugs_and_events()
+
+    def load_drugs_and_events(self):
+        self.drugs_df = self.__select_all_drugs_as_dataframe__()
+        self.ddis_df = self.__select_all_events__()
+
+    def __select_all_drugs_as_dataframe__(self):
+        headers = ['index', 'id', 'name',
+                   'target', 'enzyme', 'pathway', 'smile']
+        if self._conn is None:
+            raise Exception("There is no connection")
+        cur = self._conn.cursor()
+        cur.execute(
+            '''SELECT "index", id, name, target, enzyme, pathway, smile FROM drug'''
+        )
+        rows = cur.fetchall()
+        df = pd.DataFrame(columns=headers, data=rows)
+
+        # Convert string fields to lists
+        for col in ['enzyme', 'target', 'pathway', 'smile']:
+            df[col] = df[col].apply(lambda x: x.split('|'))
+
+        return df
+
+    def __select_all_events__(self):
+        if self._conn is None:
+            raise Exception("There is no connection")
+        cur = self._conn.cursor()
+        cur.execute('''
+            SELECT ex."index", d1.id, d1.name, d2.id, d2.name, mechanism || ' ' || action
+            FROM extraction ex
+            JOIN drug d1 ON d1.name = ex.drugA
+            JOIN drug d2 ON d2.name = ex.drugB
+        ''')
+        rows = cur.fetchall()
+        headers = ["index", "id1", "name1", "id2", "name2", "event_category"]
+        return pd.DataFrame(columns=headers, data=rows)
+
+    def prep(self):
+        if self.drugs_df is None or self.ddis_df is None:
+            raise Exception("There is no data")
+        
+        drug_ids = self.drugs_df['id'].to_list()
+        
+        filtered_df = self.drugs_df
+        combined_df = filtered_df.copy()
+
+        if self.ner_df is not None and not self.ner_df.empty:
+            filtered_ner_df = self.ner_df[self.ner_df['drugbank_id'].isin(
+                drug_ids)]
+            filtered_ner_df = self.ner_df.copy()
+
+            # TODO: eğer kullanılan veri setinde tui, cui veya entity bilgileri yoksa o veri setine bu sütunları eklemek için aşağısı gerekli
+
+            # idf_calc = IDF(filtered_ner_df, [f for f in filtered_ner_df.keys()])
+            idf_calc = IDF(filtered_ner_df, self.ner_columns)
+            idf_calc.calculate()
+            idf_scores_df = idf_calc.to_dataframe()
+
+            # for key in filtered_ner_df.keys():
+            for key in self.ner_columns:
+                threshold = 0
+                if key.startswith('tui'):
+                    threshold = self.tui_threshold
+                if key.startswith('cui'):
+                    threshold = self.cui_threshold
+                if key.startswith('entities'):
+                    threshold = self.entities_threshold
+                combined_df[key] = filtered_ner_df[key]
+                valid_codes = idf_scores_df[idf_scores_df[key] > threshold].index
+
+                # print(f'{key}: valid code size = {len(valid_codes)}')
+                combined_df[key] = combined_df[key].apply(lambda items:
+                                                        [item for item in items if item in valid_codes])
+
+        moved_columns = ['id']
+        moved_columns.extend(self.__similarity_related_columns__)
+        chemical_properties_df = combined_df[moved_columns]
+
+        chemical_properties_df = chemical_properties_df.fillna("").apply(list)
+
+        # generate vectors dictionary içinde ndarray dönecek
+        generated_vectors = generate_vectors(chemical_properties_df, self.__similarity_related_columns__)
+
+        similarity_matrices = generate_sim_matrices_new(
+            chemical_properties_df,generated_vectors,  self.__similarity_related_columns__, key_column= "id")
+
+        event_categories = self.ddis_df['event_category']
+        labels = event_categories.tolist()
+        lb = LabelBinarizer()
+        lb.fit(labels)
+        classes = lb.transform(labels)
+      
+        def similarity_lambda_fnc(row, value):
+            if row['id1'] in value:
+                return value[row['id1']]
+
+        def lambda_fnc(row: pd.Series, value)-> Optional[np.float16]:
+            if row['id1'] in value and row['id2'] in value:
+                return np.float16(np.hstack(
+                    (value[row['id1']], value[row['id2']])))
+            return None
+                # return np.hstack(
+                #     (value[row['id1']], value[row['id2']]), dtype=np.float16)
+
+        def x_fnc(row, embeddings_after_pooling):
+            if row['id1'] in embeddings_after_pooling:
+                v1 = embeddings_after_pooling[row['id1']]
+            else:
+                v1 = np.zeros(self.embedding_size)
+            if row['id2'] in embeddings_after_pooling:
+                v2 = embeddings_after_pooling[row['id2']]
+            else:
+                v2 = np.zeros(self.embedding_size)
+            return np.float16(np.hstack(
+                (v1, v2)))
+
+        for key, value in similarity_matrices.items():
+
+            print(f'sim matrix: {key}')
+            self.ddis_df[key] = self.ddis_df.apply(
+                lambda_fnc, args=(value,), axis=1)
+            self.columns.append(key)
+            print(self.ddis_df[key].head())
+
+        for embedding_column in self.embedding_columns:
+            print(f"concat {embedding_column} embeddings")
+            embeddings_after_pooling = {k: self.embeddings_pooling_strategy.apply(
+                v) for k, v in self.embedding_dict[embedding_column].items()}
+            # column_embeddings_dict = embedding_values[embedding_column]
+            self.ddis_df[embedding_column+'_embedding'] = self.ddis_df.apply(
+                x_fnc, args=(embeddings_after_pooling,), axis=1)
+            self.columns.append(embedding_column+'_embedding')
+
+        dataframe = self.ddis_df.copy()
+        if not isinstance(classes, (list, pd.Series, np.ndarray)):
+         raise TypeError("classes must be an iterable (list, Series, or ndarray)")
+
+        if len(classes) != len(dataframe):
+            raise ValueError("Length of classes must match the number of rows in the DataFrame")
+
+        dataframe['class'] = list(classes)
+        self.set_dataframe(dataframe)
+        
+
+    

ddi_fw-0.0.150/src/ddi_fw/datasets/ddi_mdl/debug.log

@@ -0,0 +1 @@
+[0217/121135.683:ERROR:registration_protocol_win.cc(108)] CreateFile: Sistem belirtilen dosyayı bulamıyor. (0x2)

{ddi_fw-0.0.148 → ddi_fw-0.0.150}/src/ddi_fw/datasets/embedding_generator.py

@@ -58,7 +58,8 @@ def create_embeddings(model, data, column, drop_column=True):
     column_embeddings_dict[row['id']] = sum_of_embeddings
     # data.iloc[index][column+'_embedding']=sum_of_embeddings
   
-  data[column+'_embedding'] = pd.Series(column_embeddings_dict.values())
+  # data[column+'_embedding'] = pd.Series(column_embeddings_dict.values())
+  data[column+'_embedding'] = pd.Series(list(column_embeddings_dict.values()))
   if(drop_column):
     data.drop([column], axis = 1, inplace = True)
   # data[column+'_embedding'] = [column_embeddings_dict[row['name']] for index, row in data.iterrows()]

{ddi_fw-0.0.148 → ddi_fw-0.0.150}/src/ddi_fw/langchain/embeddings.py

@@ -82,6 +82,7 @@ class PretrainedEmbeddings(Embeddings):
                 text, return_tensors='pt', padding=True)
             output_embeddings.append(self.model(
                 input_ids).last_hidden_state.mean(dim=1))
+        return output_embeddings
 
     def embed_query(self, text: str) -> List[float]:
         return self.embed_documents([text])[0]