rasar 0.1.0__tar.gz

rasar-0.1.0/LICENSE

@@ -0,0 +1,177 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of discussing and
+      improving the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as
+      "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and incorporated
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or any Contribution
+      constitutes direct or contributory patent infringement, then any patent
+      licenses granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that You distribute, alongside or as an addendum to
+          the NOTICE text from the Work, provided that such additional
+          attribution notices cannot be construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, and
+      distribute Your modifications as part of a Derivative Work.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may offer only
+      conditions consistent with this License.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 rasar
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

rasar-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: rasar
+Version: 0.1.0
+Summary: The components of this module can be used for read-across related calculations.
+License: Apache License 2.0
+Requires-Python: >=3.10.4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas==2.3.3
+Requires-Dist: numpy==2.2.6
+Requires-Dist: matplotlib==3.10.7
+Requires-Dist: scikit-learn==1.7.2
+Dynamic: license-file
+
+#rasar
+The components of this module can be used for read-across related calculations. It is a crucial module for cheminformatics applications. 
+
+
+## Installation
+pip install rasar
+
+
+## Usage
+This module supports five different read-across tasks, including pairwise similarity calculation, read-across prediction, read-across optimization, read-across feature importance calculation, and rasar descriptor calculation.
+
+
+## Getting started
+import pandas as pd
+from rasar import ra_similarity, ra_pred, ra_optimization, ra_importance, calculate_descriptor
+tr = pd.read_excel('train.xlsx', index_col=0)
+te = pd.read_excel('test.xlsx', index_col=0)
+xtr = tr.iloc[:,:-1]
+ytr = tr.iloc[:,-1]
+xte = te.iloc[:,:-1]
+yte = te.iloc[:,-1]
+sim = ra_similarity(des_tr=xtr, des_te=xte)
+sim1 = sim.similarity_calculation(method='Euclidean Distance')
+pred = ra_pred(df1=tr, df2=te).weighted_prediction(method='Laplacian Kernel', ctc=6, gamma=0.5)
+opt = ra_optimization(method='Laplacian Kernel', data=tr, parameters={'CTC': [1, 3, 6, 10], 
+                                                                      'Gamma': [0.1, 0.5, 1],
+                                                                      'Threshold': [0.0]}, 
+                                                                      objective_function="MAE", 
+                                                                      cv_fold=5)
+imp = ra_importance(df1=tr).imp_calculation(method='Laplacian Kernel', ctc=6, gamma=0.5, ths=2)
+ra_importance(df1=tr).plot_importance(imp_df=imp, plot_type='coefficient', color="winter_r", index=1)
+des_tr, des_te = calculate_descriptor(df1=tr, df2=te, method='Laplacian Kernel', ctc=6, gamma=0.5, merge = True)
+
+##Cite
+To use this module, users need to cite the following paper:
+
+Pore, S. and Roy, K., 2025. “intelligent Read Across (iRA)”-A tool for read-across-based toxicity prediction of nanoparticles. Computational and Structural Biotechnology Journal. https://doi.org/10.1016/j.csbj.2025.07.032
+
+
+##LICENSE
+Apache License 2.0
+

rasar-0.1.0/README.md

@@ -0,0 +1,42 @@
+#rasar
+The components of this module can be used for read-across related calculations. It is a crucial module for cheminformatics applications. 
+
+
+## Installation
+pip install rasar
+
+
+## Usage
+This module supports five different read-across tasks, including pairwise similarity calculation, read-across prediction, read-across optimization, read-across feature importance calculation, and rasar descriptor calculation.
+
+
+## Getting started
+import pandas as pd
+from rasar import ra_similarity, ra_pred, ra_optimization, ra_importance, calculate_descriptor
+tr = pd.read_excel('train.xlsx', index_col=0)
+te = pd.read_excel('test.xlsx', index_col=0)
+xtr = tr.iloc[:,:-1]
+ytr = tr.iloc[:,-1]
+xte = te.iloc[:,:-1]
+yte = te.iloc[:,-1]
+sim = ra_similarity(des_tr=xtr, des_te=xte)
+sim1 = sim.similarity_calculation(method='Euclidean Distance')
+pred = ra_pred(df1=tr, df2=te).weighted_prediction(method='Laplacian Kernel', ctc=6, gamma=0.5)
+opt = ra_optimization(method='Laplacian Kernel', data=tr, parameters={'CTC': [1, 3, 6, 10], 
+                                                                      'Gamma': [0.1, 0.5, 1],
+                                                                      'Threshold': [0.0]}, 
+                                                                      objective_function="MAE", 
+                                                                      cv_fold=5)
+imp = ra_importance(df1=tr).imp_calculation(method='Laplacian Kernel', ctc=6, gamma=0.5, ths=2)
+ra_importance(df1=tr).plot_importance(imp_df=imp, plot_type='coefficient', color="winter_r", index=1)
+des_tr, des_te = calculate_descriptor(df1=tr, df2=te, method='Laplacian Kernel', ctc=6, gamma=0.5, merge = True)
+
+##Cite
+To use this module, users need to cite the following paper:
+
+Pore, S. and Roy, K., 2025. “intelligent Read Across (iRA)”-A tool for read-across-based toxicity prediction of nanoparticles. Computational and Structural Biotechnology Journal. https://doi.org/10.1016/j.csbj.2025.07.032
+
+
+##LICENSE
+Apache License 2.0
+

rasar-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rasar"
+version = "0.1.0"
+description = "The components of this module can be used for read-across related calculations."
+readme = "README.md"
+requires-python = ">=3.10.4"
+license = { text = "Apache License 2.0" }
+
+dependencies = [
+    "pandas==2.3.3",
+    "numpy==2.2.6",
+    "matplotlib==3.10.7",
+    "scikit-learn==1.7.2",
+]

rasar-0.1.0/rasar/__init__.py

@@ -0,0 +1,5 @@
+from .similarity import ra_similarity
+from .prediction import ra_pred
+from .optimization import ra_optimization
+from .feature_importance import ra_importance
+from .rasar_descriptors import calculate_descriptor

rasar-0.1.0/rasar/feature_importance.py

@@ -0,0 +1,140 @@
+import pandas as pd
+from rasar.prediction import ra_pred
+from itertools import chain, combinations
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+#factorial calculator
+def factorial(n):
+    result = 1
+    for i in range(1, n + 1):
+        result *= i
+    return result
+
+#combination generator
+def generate_combinations(lst, lnt=8):
+    min_length = len(lst)-lnt
+    all_combinations = chain.from_iterable(combinations(lst, r) for r in range(len(lst), min_length-1,-1))
+    return [list(combo) for combo in all_combinations]
+
+def summary_plot_cal(df1:pd.DataFrame, df2:pd.DataFrame):
+        """
+        df1: Importance file \n
+        df2: Non-standardize input file (xtr) \n
+        both files should not contain any response column"""
+        std_df2 = (df2-df2.min())/(df2.max()-df2.min())
+        abs_df1 = df1.abs()
+        abs_df1_mean = abs_df1.mean()
+        imp_fea = abs_df1_mean.sort_values(kind="mergesort")
+        imp_fea1 = imp_fea.index.values.tolist()
+        ndf1 = df1[imp_fea1].copy()
+        ndf2 = std_df2[imp_fea1].copy()
+        return ndf1, ndf2, imp_fea1
+
+
+
+class ra_importance:
+
+    def __init__(self, df1: pd.DataFrame): #df1 is the training set
+        self.df1 = df1
+        self.x_tr = df1.iloc[:,:-1]
+        self.y_tr = df1.iloc[:,-1]
+        self.ndes = len(self.x_tr.columns)
+        self.ncomp = len(self.x_tr)
+
+    
+    def imp_calculation(self, method:str, ctc, ths, sigma=1.0, gamma=1.0, similarity_cutoff=0.0, p_mk=3, degree=3.0, coef0=1):
+        if ths == None:
+            ths = int(len(self.x_tr.columns.tolist())/4)
+        else:
+            ths = ths
+        fea_list = self.x_tr.columns.tolist()
+        n_fact = factorial(n=len(fea_list))
+        fea_comb = generate_combinations(fea_list, lnt=ths)
+        print(fea_comb)
+        importance = []
+        for i in fea_list:
+            comb1 = [list(co) for co in fea_comb if str(i) in co]
+            comb1_comp = [[item for item in sublist if item != str(i)] for sublist in comb1]
+            cal_list=[]
+            print(comb1)
+            print(comb1_comp)
+            for j,k in zip(comb1, comb1_comp):
+                nxtr1 = self.x_tr[j].copy()
+                nxtr1_comp = self.x_tr[k].copy()
+                ndf1 = pd.concat([nxtr1, self.y_tr], axis=1)
+                ndf1_comp = pd.concat([nxtr1_comp, self.y_tr], axis=1)
+                pred1 = ra_pred(df1=ndf1, df2=ndf1).weighted_prediction(method=method, ctc=ctc, sigma=sigma,
+                                                                        gamma=gamma, similarity_cutoff=similarity_cutoff,
+                                                                        p_mk=p_mk, degree=degree, coef0=coef0)
+                pred2 = ra_pred(df1=ndf1_comp, df2=ndf1_comp).weighted_prediction(method=method, ctc=ctc, sigma=sigma,
+                                                                        gamma=gamma, similarity_cutoff=similarity_cutoff,
+                                                                        p_mk=p_mk, degree=degree, coef0=coef0)
+                pred1.fillna(0, inplace=True)
+                pred2.fillna(0, inplace=True)
+                delta_pred = ((factorial(n=len(k))*(factorial(n=len(fea_list)-len(k)-1)))/n_fact)*(pred1-pred2)
+                cal_list.append(delta_pred)
+            cal_df = pd.DataFrame(cal_list)
+            marginal_contribution = (cal_df.T).sum(axis=1)
+            importance.append(marginal_contribution)
+        imp_df = pd.DataFrame(importance).T
+        imp_df.columns=self.x_tr.columns.to_list()
+        imp_df.index=self.x_tr.index.values
+        return imp_df
+            
+    def plot_importance(self, imp_df, plot_type:str, color:str, index=0):
+        if plot_type == "bar":
+            plt.rcParams['font.family'] = 'Times New Roman' 
+            plt.rcParams['font.size'] = 17 
+            plt.figure(figsize=(12,10))
+            abs_df1 = imp_df.abs()
+            abs_df1_mean = abs_df1.mean()
+            imp_fea = abs_df1_mean.sort_values(ascending=False, kind="mergesort")
+            plt.bar(imp_fea.index.values.tolist(), imp_fea.values.tolist(), color=	"#4169E1", edgecolor="black")
+            plt.title("Read Across Feature Importance", fontsize=23, fontweight='bold')
+            plt.xlabel("Features", fontsize=17, fontweight='bold')
+            plt.ylabel("Feature Importance", fontsize=17, fontweight='bold')
+            plt.show()
+        
+        if plot_type == "summary":
+            plt.rcParams['font.family'] = 'Times New Roman' 
+            plt.rcParams['font.size'] = 17  
+            plt.figure(figsize=(12,10))
+            ndf1, ndf2, imp_fea1 = summary_plot_cal(df1=imp_df, df2=self.x_tr)
+            num_points = len(ndf1)
+            jitter_base = np.linspace(-0.2, 0.2, num_points)
+            for i, feature_idx in enumerate(imp_fea1):
+                print(feature_idx)
+                y_values = i + np.sort(jitter_base) 
+                plt.scatter(
+                   ndf1[[feature_idx]],
+                   y_values,
+                   c=ndf2[[feature_idx]].values,
+                   cmap=color,
+                    edgecolors="k",
+                    linewidth=0.3,
+                    s=60
+                )
+            plt.title("Read Across Feature Importance", fontsize=23, fontweight='bold')
+            plt.yticks(range(len(imp_fea1)), imp_fea1)
+            plt.axvline(x=0, color="black", linestyle="-", linewidth=1)
+            plt.xlabel("Feature Importance", fontsize=17, fontweight='bold')
+            plt.ylabel("Features", fontsize=17, fontweight='bold')
+            plt.show()
+        if plot_type == "coefficient":
+            plt.rcParams['font.family'] = 'Times New Roman' 
+            plt.rcParams['font.size'] = 17
+            plt.figure(figsize=(12,10))
+            coefficients = imp_df.iloc[index]
+            coefficient = coefficients.tolist()
+            coef_colors = ["blue" if coef > 0 else "red" for coef in coefficients]
+            plt.barh(coefficients.index.tolist(), coefficient, color=coef_colors, edgecolor="black", alpha=0.7)
+            plt.axvline(x=0, color="black", linestyle="-", linewidth=1)
+            plt.title(f"Read Across Feature Importance for Observation {index}", fontsize=23, fontweight='bold')
+            plt.xlabel("Feature Contribution", fontsize=17, fontweight='bold')
+            plt.ylabel("Features", fontsize=17, fontweight='bold')
+            plt.show()
+                
+
+

rasar-0.1.0/rasar/optimization.py

@@ -0,0 +1,160 @@
+import pandas as pd
+import numpy as np
+from rasar.prediction import ra_pred
+from sklearn.model_selection import KFold
+from itertools import product
+from sklearn.metrics import accuracy_score, f1_score, matthews_corrcoef, cohen_kappa_score
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+
+
+
+def ra_optimization(method: str, data: pd.DataFrame, parameters: dict, objective_function: str, cv_fold: int):
+    """
+    data: should have the arrangements like ID-Descriptors-Response
+    parameters: Dictionary (having different descriptor combination)
+    """
+    folds = KFold(n_splits=cv_fold)
+    
+    # Generate all combinations
+    keys = parameters.keys()
+    values = parameters.values()
+    combinations = [dict(zip(keys, v)) for v in product(*values)]
+    
+    results = []  # To store results
+    
+    for comb in combinations:
+        split_results = []  # To store values for each fold
+        
+        for i, (train_index, test_index) in enumerate(folds.split(data), start=1):
+            train_data = data.iloc[train_index]
+            test_data = data.iloc[test_index]
+            yte = test_data.iloc[:, -1]
+
+            if method == "Gaussian Kernel":
+                sigma_value = comb["Sigma"]
+                ctc_value = comb["CTC"]
+                threshold_value = comb["Threshold"]
+                if ctc_value == "auto":
+                    ctc_f = "auto"
+                else:
+                    ctc_f = int(ctc_value)
+                ytep = ra_pred(df1=train_data, df2=test_data).weighted_prediction(method=method,
+                                                                                  ctc=ctc_f,
+                                                                                  similarity_cutoff=float(threshold_value),
+                                                                                  sigma=float(sigma_value))
+                
+                
+            elif method == "Laplacian Kernel" or method == "Chi2_Kernel":
+                gamma_value = comb["Gamma"]
+                ctc_value = comb["CTC"]
+                threshold_value = comb["Threshold"]
+                if ctc_value == "auto":
+                    ctc_f = "auto"
+                else:
+                    ctc_f = int(ctc_value)
+                ytep = ra_pred(df1=train_data, df2=test_data).weighted_prediction(method=method,
+                                                                                  ctc=ctc_f,
+                                                                                  similarity_cutoff=float(threshold_value),
+                                                                                  gamma=float(gamma_value))
+               
+            elif method == "Minkowski Distance":
+                p_value = comb["P_Value"]
+                ctc_value=comb["CTC"]
+                threshold_value = comb["Threshold"]
+                if ctc_value == "auto":
+                    ctc_f = "auto"
+                else:
+                    ctc_f = int(ctc_value)
+                ytep = ra_pred(df1=train_data, df2=test_data).weighted_prediction(method=method,
+                                                                                  ctc=ctc_f,
+                                                                                  similarity_cutoff=float(threshold_value),
+                                                                                  p_mk=int(p_value))
+                
+            elif method == "Polynomial_Kernel":
+                degree_value = comb["Degree"]
+                gamma_value = comb["Gamma"]
+                coef0_value = comb["Coef0"]
+                ctc_value = comb["CTC"]
+                threshold_value = comb["Threshold"]
+                if ctc_value == "auto":
+                    ctc_f = "auto"
+                else:
+                    ctc_f = int(ctc_value)
+                ytep = ra_pred(df1=train_data, df2=test_data).weighted_prediction(method=method,
+                                                                                  ctc=ctc_f,
+                                                                                  similarity_cutoff=float(threshold_value),
+                                                                                  degree=float(degree_value),
+                                                                                  gamma=float(gamma_value),
+                                                                                  coef0=float(coef0_value))
+                
+            elif method == "Sigmoid_Kernel":
+                gamma_value = comb["Gamma"]
+                coef0_value = comb["Coef0"]
+                ctc_value = comb["CTC"]
+                threshold_value = comb["Threshold"]
+                if ctc_value == "auto":
+                    ctc_f = "auto"
+                else:
+                    ctc_f = int(ctc_value)
+                ytep = ra_pred(df1=train_data, df2=test_data).weighted_prediction(method=method,
+                                                                                  ctc=ctc_f,
+                                                                                  similarity_cutoff=float(threshold_value),
+                                                                                  gamma=float(gamma_value),
+                                                                                  coef0=float(coef0_value))
+                
+            else:
+                ctc_value = comb["CTC"]
+                threshold_value = comb["Threshold"]
+                if ctc_value == "auto":
+                    ctc_f = "auto"
+                else:
+                    ctc_f = int(ctc_value)
+                ytep = ra_pred(df1=train_data, df2=test_data).weighted_prediction(method=method,
+                                                                                  similarity_cutoff=float(threshold_value),
+                                                                                  ctc=ctc_f)
+                
+
+
+            
+            # Compute the objective function
+            if ytep.isna().any().any():
+                cal_val = np.nan
+            else:
+                if objective_function == "MAE":
+                    cal_val = mean_absolute_error(yte, ytep)
+                elif objective_function == "MSE":
+                    cal_val = mean_squared_error(yte, ytep)
+                elif objective_function == "RMSE":
+                    cal_val = np.sqrt(mean_squared_error(yte, ytep))
+                elif objective_function == "accuracy":
+                    ytep1 = (ytep >= 0.5).astype(int)
+                    cal_val = accuracy_score(yte, ytep1)
+                elif objective_function == "f1-score":
+                    ytep1 = (ytep >= 0.5).astype(int)
+                    cal_val = f1_score(yte, ytep1)
+                elif objective_function == "MCC":
+                    ytep1 = (ytep >= 0.5).astype(int)
+                    cal_val = matthews_corrcoef(yte, ytep1)
+                elif objective_function == "Cohen's Kappa":
+                    ytep1 = (ytep >= 0.5).astype(int)
+                    cal_val = cohen_kappa_score(yte, ytep1)
+                else:
+                    raise ValueError("Invalid objective function")
+
+            split_results.append(cal_val)
+        
+        comb_result = comb.copy()
+        for j, val in enumerate(split_results, start=1):
+            comb_result[f"split_{j}"] = val  
+        comb_result["Mean_Result"] = np.nanmean(split_results)  
+        print(f"Completed combination: {comb_result}")
+        
+        results.append(comb_result)
+
+   
+    return pd.DataFrame(results)
+
+
+
+
+        

rasar-0.1.0/rasar/prediction.py

@@ -0,0 +1,303 @@
+import numpy as  np
+import pandas as pd
+from rasar.similarity import ra_similarity
+
+
+#==================================Helper Functions==================================
+
+def standerdization(df1, df2):
+    mea=df1.mean()
+    stdv=df1.std()
+    ndf1=(df1-mea)/stdv
+    ndf2=(df2-mea)/stdv
+    return ndf1, ndf2
+
+def data_sort(frame, id):#id is the index of the new data frame
+    df_sorted = pd.DataFrame(frame.apply(lambda row: sorted(zip(frame.columns, row), 
+                                                            key=lambda x: x[1], reverse=True), axis=1).tolist(), index=id)
+    df_val = pd.DataFrame(frame.apply(lambda row: [x[1] for x in sorted(zip(frame.columns, row), 
+                                                                        key=lambda x: x[1], reverse=True)], 
+                                                                        axis=1).tolist(), index=id)
+    df_sorted_columns = pd.DataFrame(frame.apply(lambda row: [x[0] for x in sorted(zip(frame.columns, row), 
+                                                                                   key=lambda x: x[1], reverse=True)], 
+                                                                                   axis=1).tolist(), index=id)
+    
+    return df_sorted, df_val, df_sorted_columns
+
+mylist = ["Euclidean Distance", 
+            "Gaussian Kernel", 
+            "Laplacian Kernel",
+            "Linear Kernel",
+            "Polynomial_Kernel",
+            "Sigmoid_Kernel",
+            "Cosine Similarity",
+            "Manhattan Distance",
+            "Chebyshev Distance",
+            "Minkowski Distance",
+            "SEuclidean Distance",
+            "Mahalanobis Distance",
+            "Canberra Distance",
+            "BrayCurtis Distance"]
+
+def mse(df1:pd.DataFrame, df2:pd.DataFrame, max_ctc=10, obj="MAE"): 
+    df1 = df1.iloc[:,0:max_ctc]
+    df2 = df2.iloc[:,0:max_ctc]
+    result = pd.DataFrame(index=df1.index)
+    
+    for i in range(len(df2.columns)):
+        column_sum = pd.Series(0, index=df1.index)
+        
+        for j in range(len(df1.columns)):
+            if j <= i:
+                if obj =="MSE":
+                    diff_squared = ((df2.iloc[:, i] - df1.iloc[:, j]) ** 2)
+                elif obj =="MAE":
+                    diff_squared = abs(df2.iloc[:, i] - df1.iloc[:, j])
+                column_sum += diff_squared
+        column_sum /= (i + 1)     
+        result[i] = column_sum
+    #result/=df2
+    return result
+
+def min_loc(df1:pd.DataFrame, df2:pd.DataFrame):  # df1 is the MSE matrix and df2 is the WAP matrix
+    min_indices = []
+    col2 = []
+    corresponding_values = []
+
+    for index, row in df1.iloc[:, 1:].iterrows():
+        if row.isna().all():  # Check if all values in the row are NaN
+            min_indices.append(None)
+            corresponding_values.append(np.nan)  # Assign NaN instead of 0
+            col2.append(np.nan)
+        else:
+            col_name = row.idxmin()
+            corresponding_value = df2.loc[index, col_name]
+            min_indices.append(col_name)
+            corresponding_values.append(corresponding_value)
+            col2.append(col_name + 1)
+
+    pd_fr = pd.Series(corresponding_values, index=df1.index)
+    ctc = pd.DataFrame(col2, index=df1.index, columns=["CTC"])
+    
+    return pd_fr, ctc
+
+def auto_na(df1:pd.DataFrame, df2:pd.DataFrame, df3:pd.DataFrame, ctc_val:pd.DataFrame, ctc_max=10):
+    """
+    This function generate files for RA metrics calculation in the case of auto CTC \n
+    df1: whole similarity matrix \n
+    df2: whole weightage matrix \n
+    df3: whole response matrix \n
+    all the thress matrix have the sorted value along the row \n
+    ctc_val: compound specific CTC for the prediction \n
+    ctc_max: upper bound 
+    """
+    ndf1 = df1.iloc[:,0:ctc_max]
+    ndf2 = df2.iloc[:,0:ctc_max]
+    ndf3 = df3.iloc[:,0:ctc_max]
+    for idx, col_idx in enumerate(ctc_val['CTC']):
+        ndf1.iloc[idx, col_idx:] = np.nan
+    ndf2 = ndf2.where(~ndf1.isna(), np.nan)
+    ndf3 = ndf3.where(~ndf1.isna(), np.nan)
+    return ndf1, ndf2, ndf3
+
+def ra_met(wap:pd.DataFrame, sim_df:pd.DataFrame, weight:pd.DataFrame, res_df:pd.DataFrame, tr_mean:float):
+
+    """
+    This function return calculated metrics of read-across function \n
+    wap: weighted average predicted values (have only one column) \n
+    sim_df: similarity matrix used in the generation of prediction \n
+    weight: weights used in the generation of prediction (Individual Similarity/Total Similarity) \n
+    res_df: response matrix of close source compounds\n
+    tr_mean: training set response mean (Experimental Value) \n 
+
+    Return -> dictionary of the calculated RA metrics \n
+
+    """
+
+
+    #n_effective
+    weitage2 = weight**2
+    n_eff = ((weight.sum(axis=1))**2)/(weitage2.sum(axis=1))
+
+    #sd_activity
+    tem_nu = weight*((res_df.sub(wap.iloc[:,0], axis=0))**2)
+    tem_nu_sum = tem_nu.sum(axis=1)
+    sda_part1 = (tem_nu_sum)/(weight.sum(axis=1))
+    sda_part2 = n_eff/(n_eff-1)
+    sd_activity = pd.Series(np.sqrt(sda_part1*sda_part2))
+
+    #cv_activity
+    cv_activity = sd_activity.div(wap.iloc[:,0])
+
+    #avg_similarity
+    avg_similarity = sim_df.mean(axis=1)
+
+    #sd_similarity
+    sd_similarity = sim_df.std(axis=1)
+
+    #cv_similarity
+    cv_similarity = sd_similarity/avg_similarity
+
+    #standard_error
+    stand_error = sd_activity.div(np.sqrt(n_eff))
+
+    #max_pos & maxpos_avgsim
+    mp_res = res_df.copy()
+    mp_res[mp_res<tr_mean] = np.nan
+    mp_sim = sim_df.where(~mp_res.isna(), np.nan)
+    max_pos = mp_sim.max(axis=1)
+    max_pos.fillna(0, inplace=True)
+    maxpos_avgsim = mp_sim.mean(axis=1)
+    maxpos_avgsim.fillna(0, inplace=True)
+
+    #max_neg & maxneg_avgsim
+    ne_res = res_df.copy()
+    ne_res[ne_res>=tr_mean] = np.nan
+    ne_sim = sim_df.where(~ne_res.isna(), np.nan)
+    max_neg = ne_sim.max(axis=1)
+    max_neg.fillna(0, inplace=True)
+    maxneg_avgsim = ne_sim.mean(axis=1)
+    maxneg_avgsim.fillna(0, inplace=True)
+
+    #abs_diff
+    abs_diff = np.abs(max_pos-max_neg)
+
+    #g and gm
+    pos_frac = mp_sim.count(axis=1)/res_df.count(axis=1)
+    pos_frac_diff = 2*np.abs(pos_frac-0.5)
+    g_val = 1-pos_frac_diff
+    gm_val = np.where(max_pos >= max_neg, pos_frac_diff, -pos_frac_diff)
+
+    #derived metrics
+    gm_avgsim = gm_val*avg_similarity
+    gm_sdsim = gm_val*sd_similarity
+
+    #sm1 and sm2
+    sm1 = (max_pos-max_neg)/np.maximum(max_pos, max_neg)
+    sm2 = (maxpos_avgsim -maxneg_avgsim)/avg_similarity
+
+
+    #next gen error met
+    #nem1
+    diff = (res_df.sub(wap.iloc[:,0], axis=0)).abs()
+    nem1 = diff.mean(axis=1)
+    
+    #nem2
+    sq_diff = (res_df.sub(wap.iloc[:,0], axis=0))**2
+    nem2 = sq_diff.mean(axis=1)
+    
+
+    met_dict = {
+        "n_effective": n_eff,
+        "SD_Activity": sd_activity,
+        "CV_Activity": cv_activity,
+        "Avg_similarity": avg_similarity,
+        "SD_similarity": sd_similarity,
+        "CV_similarity": cv_similarity,
+        "Standard_Error (SE)": stand_error,
+        "MaxPos": max_pos,
+        "PosAvgSim": maxpos_avgsim,
+        "MaxNeg": max_neg,
+        "NegAvgSim": maxneg_avgsim,
+        "AbsDiff": abs_diff,
+        "g": g_val,
+        "gm": gm_val,
+        "gm*AvgSim": gm_avgsim,
+        "gm*SD_Similarity": gm_sdsim,
+        "sm1": sm1,
+        "sm2": sm2,
+        "NEM1": nem1,
+        "NEM2": nem2
+    }
+    return met_dict
+
+
+    
+#================================RA Prediction Class==================================
+
+class ra_pred:
+
+    def __init__(self, df1:pd.DataFrame, df2:pd.DataFrame):
+        '''
+        df1: training data frame with response variable in the last column \n
+        df2: test data frame with or without response variable (if response variable is present, it should be in the last column)
+        '''
+        self.df1 = df1
+        self.df2 = df2
+        self.x_tr = df1.iloc[:,:-1]
+        self.y_tr = df1.iloc[:,-1]
+        self.xtr_len = len(self.x_tr)
+        if len(df1.columns)==len(df2.columns):
+            self.x_te = df2.iloc[:,:-1]
+            self.y_te = df2.iloc[:,-1]
+        else:
+            self.x_te = df2
+
+    def weighted_prediction(self, method:str, ctc, sigma=1.0, gamma=1.0, 
+                            p_mk = 3, degree=3.0, coef0 = 1, similarity_cutoff=0.0, 
+                            max_ctc=10, log_outp=False):
+        '''
+        method: similarity/distance method to be used for calculation\n
+        ctc: CTC value to be used for prediction (can be "auto" or integer value)\n
+        sigma: sigma value for Gaussian Kernel\n   
+        gamma: gamma value for Laplacian Kernel, Chi2_Kernel, Polynomial Kernel, Sigmoid Kernel\n
+        p_mk: p value for Minkowski Distance\n
+        degree: degree value for Polynomial Kernel\n
+        coef0: coef0 value for Polynomial Kernel, Sigmoid Kernel\n
+        similarity_cutoff: similarity cutoff value for the selection of close source compounds (applicable only when ctc is an integer)\n
+        max_ctc: upper bound for CTC value (applicable only when ctc is "auto")\n
+        log_outp: whether to return the detailed output for RA metrics calculation (True/False)\n
+        '''
+        if method in mylist:
+            des_tr, des_te = standerdization(df1=self.x_tr, df2=self.x_te)
+            
+            
+        else:
+            des_tr, des_te = self.x_tr, self.x_te
+        sim = ra_similarity(des_tr=des_tr, des_te=des_te)
+        sim1=sim.similarity_calculation(method=method, sigma=sigma, gamma=gamma, 
+                                        p_mk=p_mk, degree=degree, coef0=coef0)
+        if np.array_equal(sim1.index.values, sim1.columns.values):
+            np.fill_diagonal(sim1.values, 0)
+        else:
+            pass
+        sim2=sim1.copy()
+        sim2.columns=self.y_tr.values.tolist()
+        df_sort, sort_val, sort_col = data_sort(sim1, id=self.df2.index)
+        df_sort_res, sort_val_res, sort_col_res = data_sort(sim2, id=self.df2.index)
+        similarity_sum = sort_val_res.sum(axis=1)
+        if ctc == "auto":
+            wei = (sort_val_res.T/similarity_sum).T
+            wei_res = wei*sort_col_res
+            wei_res_cum = wei_res.cumsum(axis=1)
+            wei_cum = wei.cumsum(axis=1)
+            wap = wei_res_cum/wei_cum
+            mse_cal = mse(sort_col_res, wap, max_ctc=max_ctc)
+            yte_pred, ctc_cal = min_loc(mse_cal, wap.iloc[:,0:max_ctc])
+            if log_outp == True:
+                ramet_similarity, ramet_weitage, ramet_response = auto_na(df1=sort_val_res, df2=wei, 
+                                                                          df3=sort_col_res, ctc_val=ctc_cal, 
+                                                                          ctc_max=max_ctc)
+            else:
+                pass
+        else:
+            sort_val_res1=sort_val_res.iloc[:,0:ctc]
+            sort_col_res1=sort_col_res.iloc[:,0:ctc]
+            sort_val_res1 = sort_val_res1.mask(sort_val_res1 < similarity_cutoff, np.nan)
+            single_value_rows = sort_val_res1.notna().sum(axis=1) == 1
+            sort_val_res1 = sort_val_res1.mask(single_value_rows, np.nan)
+            sort_col_res1 = sort_col_res1.where(~sort_val_res1.isna(), np.nan)
+            wei1 = (sort_val_res1.T/similarity_sum).T
+            wei_res1 = wei1*sort_col_res1
+            wap=wei_res1.sum(axis=1)/wei1.sum(axis=1)
+            yte_pred=wap
+            ramet_similarity, ramet_weitage, ramet_response = sort_val_res1, wei1, sort_col_res1
+        if log_outp == False:
+            return yte_pred
+        if log_outp == True:
+            ra_metrics = ra_met(wap=pd.DataFrame(yte_pred), sim_df=ramet_similarity, 
+                                weight=ramet_weitage, res_df=ramet_response, 
+                                tr_mean=float(self.y_tr.mean()))
+            ra_metrics_df = pd.DataFrame(ra_metrics, index=self.x_te.index.values)
+            return yte_pred, ra_metrics_df, sort_col_res, sort_col
+

rasar-0.1.0/rasar/rasar_descriptors.py

@@ -0,0 +1,23 @@
+import pandas as pd
+from rasar.prediction import ra_pred
+import numpy as np
+
+def calculate_descriptor(df1:pd.DataFrame, df2:pd.DataFrame, 
+                         method:str, ctc, sigma=1.0, 
+                         gamma=1.0, similarity_cutoff=0.0, 
+                         p_mk=3, degree=3.0, coef0=1, log = True, data_fusion = True):
+    
+    wap_pred_tr, ra_meas_tr, __, __ = ra_pred(df1=df1, df2=df1).weighted_prediction(method=method, ctc=ctc, sigma=sigma,
+                                                        gamma=gamma, similarity_cutoff=similarity_cutoff,
+                                                        p_mk=p_mk, degree=degree, coef0=coef0, log_outp=log)
+    wap_tr_df = pd.DataFrame(wap_pred_tr, columns=["RA_function"], index=df1.index.values)
+    tr_met = pd.concat([wap_tr_df, ra_meas_tr], axis=1)
+    wap_pred_te, ra_meas_te, __, __ = ra_pred(df1=df1, df2=df2).weighted_prediction(method=method, ctc=ctc, sigma=sigma,
+                                                        gamma=gamma, similarity_cutoff=similarity_cutoff,
+                                                        p_mk=p_mk, degree=degree, coef0=coef0, log_outp=log)
+    wap_te_df = pd.DataFrame(wap_pred_te, columns=["RA_function"], index=df2.index.values)
+    te_met = pd.concat([wap_te_df, ra_meas_te], axis=1)
+    if data_fusion == True:
+        tr_met = pd.concat([tr_met, df1.iloc[:,:-1]], axis=1)
+        te_met = pd.concat([te_met, df2.iloc[:,:-1]], axis=1)
+    return tr_met, te_met

rasar-0.1.0/rasar/similarity.py

@@ -0,0 +1,180 @@
+import pandas as pd
+import numpy as np
+from sklearn.metrics import DistanceMetric
+from sklearn.metrics.pairwise import additive_chi2_kernel, chi2_kernel
+from sklearn.metrics.pairwise import linear_kernel, polynomial_kernel, sigmoid_kernel
+from sklearn.metrics.pairwise import cosine_similarity, rbf_kernel, laplacian_kernel
+
+
+def fragment_calculator(row1, row2):
+    val1 = np.sum(row2)
+    val2 = np.sum(row1)
+    val3 = np.sum(row1 & row2)
+    return val1, val2, val3
+
+
+class ra_similarity:
+
+    def __init__(self, des_tr: pd.DataFrame, des_te: pd.DataFrame):
+        '''
+        Pairwise Similarity Calculation:\n
+        This class is used to calculate the pairwise similarity between\n training and test set compounds using various methods.\n
+        des_tr: training descriptors \n
+        des_te: testing descriptors 
+        '''
+        self.des_tr = des_tr
+        self.des_te = des_te
+        self.tr_comp = len(des_tr)#m
+        self.te_comp = len(des_te)
+        self.n_fea = len(des_tr.columns)
+
+    
+    def similarity_calculation(self, method:str, sigma=1.0, gamma=1.0, p_mk = 3, degree=3.0, coef0 = 1):
+        '''
+        method: similarity/distance method to be used for calculation\n
+        sigma: sigma value for Gaussian Kernel\n
+        gamma: gamma value for Laplacian Kernel, Chi2_Kernel, Polynomial Kernel, Sigmoid Kernel\n
+        p_mk: p value for Minkowski Distance\n
+        degree: degree value for Polynomial Kernel\n
+        coef0: coef0 value for Polynomial Kernel, Sigmoid Kernel\n
+         Supported Methods:\n
+        1. Minkowski Distance\n
+        2. Gaussian Kernel\n
+        3. Laplacian Kernel\n
+        4. Linear Kernel\n
+        5. Polynomial Kernel\n
+        6. Sigmoid Kernel\n
+        7. SEuclidean Distance\n
+        8. Euclidean Distance\n
+        9. Mahalanobis Distance\n
+        10. Hamming Distance\n
+        11. Canberra Distance\n
+        12. BrayCurtis Distance\n
+        13. Matching Distance\n
+        14. Kulsinski Distance\n
+        15. RogersTanimoto Distance\n
+        16. SokalMichener Distance\n
+        17. SokalSneath Distance\n
+        18. Cosine Similarity\n
+        19. Tanimoto Coefficient\n
+        20. Dice Coefficient\n
+        21. Cosine Similarity (FP)\n
+        22. Russell-rao Coefficient\n
+        23. Forbes Coefficient\n
+        24. Euclidean Distance (FP)\n
+        25. Manhattan Distance (FP)\n
+        26. Manhattan Distance\n
+        27. Chebyshev Distance\n
+        28. Chi2_Kernel\n
+        29. Additive_Chi2\n
+        '''
+        similarity = []
+        if method == "Minkowski Distance":
+            dist = DistanceMetric.get_metric("minkowski", p=p_mk)
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1/(1+sim)
+        elif method == "SEuclidean Distance":
+            variance = self.des_tr.var()
+            dist = DistanceMetric.get_metric("seuclidean", V=variance)
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1/(1+sim)
+        elif method == "Euclidean Distance":
+            dist = DistanceMetric.get_metric("euclidean")
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1/(1+sim)
+        elif method == "Mahalanobis Distance":
+            V1 = np.cov(self.des_tr, rowvar=False)
+            dist = DistanceMetric.get_metric("mahalanobis", V=V1)
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1/(1+sim)
+        elif method == "Hamming Distance":
+            dist = DistanceMetric.get_metric("hamming")
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1/(1+sim)
+        elif method == "Canberra Distance":
+            dist = DistanceMetric.get_metric("canberra")
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1/(1+sim)
+        elif method == "BrayCurtis Distance":
+            dist = DistanceMetric.get_metric("braycurtis")
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1/(1+sim)
+
+        elif method == "Matching Distance":
+            dist = DistanceMetric.get_metric("matching")
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1-sim
+
+        elif method == "Kulsinski Distance":
+            dist = DistanceMetric.get_metric("kulsinski")
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1-sim
+        
+        elif method == "RogersTanimoto Distance":
+            dist = DistanceMetric.get_metric("rogerstanimoto")
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1-sim
+
+        elif method == "SokalMichener Distance":
+            dist = DistanceMetric.get_metric("sokalmichener")
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1-sim
+        
+        elif method == "SokalSneath Distance":
+            dist = DistanceMetric.get_metric("sokalsneath")
+            sim = dist.pairwise(self.des_te, self.des_tr)
+            similarity = 1-sim
+        elif method == "Cosine Similarity":
+            similarity = cosine_similarity(self.des_te, self.des_tr)
+        elif method == "Linear Kernel":
+            similarity = linear_kernel(self.des_te, self.des_tr)
+        elif method == "Additive_Chi2":
+            similarity = additive_chi2_kernel(self.des_te, self.des_tr)
+        elif method == "Chi2_Kernel":
+            similarity = chi2_kernel(self.des_te, self.des_tr, gamma=gamma)
+        elif method == "Polynomial_Kernel":
+            similarity = polynomial_kernel(self.des_te, self.des_tr, gamma=gamma, degree=degree, coef0=coef0)
+        elif method == "Sigmoid_Kernel":
+            similarity = sigmoid_kernel(self.des_te, self.des_tr, gamma=gamma, coef0=coef0)
+        elif method == "Gaussian Kernel":
+            similarity = rbf_kernel(self.des_te, self.des_tr, gamma=1/(2*(sigma**2)))
+        elif method == "Laplacian Kernel":
+            similarity = laplacian_kernel(self.des_te, self.des_tr, gamma=gamma)
+        else:
+            for i in range(len(self.des_te)):
+                temp = []
+                for j in range(len(self.des_tr)):
+                    if method == "Tanimoto Coefficient" or method == "Soergel Distance":
+                        a,b,c = fragment_calculator(row1=self.des_te.values[i], row2 = self.des_tr.values[j])
+                        sim = c/(a+b-c)
+                    if method =="Dice Coefficient":
+                        a,b,c = fragment_calculator(row1=self.des_te.values[i], row2 = self.des_tr.values[j])
+                        sim = (2*c)/(a+b)
+                    if method == "Cosine Similarity (FP)":
+                        a,b,c = fragment_calculator(row1=self.des_te.values[i], row2 = self.des_tr.values[j])
+                        sim = c/((a*b)**0.5)
+                    if method == "Russell-rao Coefficient":
+                        a,b,c = fragment_calculator(row1=self.des_te.values[i], row2 = self.des_tr.values[j])
+                        sim = c/self.tr_comp
+                    if method == "Forbes Coefficient":
+                        a,b,c = fragment_calculator(row1=self.des_te.values[i], row2 = self.des_tr.values[j])
+                        sim = (c*self.tr_comp)/(a*b)
+                    if method == "Euclidean Distance (FP)":
+                        a,b,c = fragment_calculator(row1=self.des_te.values[i], row2 = self.des_tr.values[j])
+                        sim = (a+b-(2*c))**0.5
+                        sim = 1/(1+sim)
+                    if method == "Manhattan Distance (FP)":
+                        a,b,c = fragment_calculator(row1=self.des_te.values[i], row2 = self.des_tr.values[j])
+                        sim = (a+b-(2*c))
+                        sim = 1/(1+sim)
+                    if method == "Manhattan Distance":
+                        sim = sum(np.abs(self.des_te.values[i] - self.des_tr.values[j]))
+                        sim = 1/(1+sim)
+                    if method == "Chebyshev Distance":
+                        sim = max(np.abs(self.des_te.values[i] - self.des_tr.values[j]))
+                        sim = 1/(1+sim)
+                    temp.append(sim)
+                similarity.append(temp)
+
+        sim_df = pd.DataFrame(similarity, index=self.des_te.index.values, columns=self.des_tr.index.values.tolist())
+        return sim_df

rasar-0.1.0/rasar.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: rasar
+Version: 0.1.0
+Summary: The components of this module can be used for read-across related calculations.
+License: Apache License 2.0
+Requires-Python: >=3.10.4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas==2.3.3
+Requires-Dist: numpy==2.2.6
+Requires-Dist: matplotlib==3.10.7
+Requires-Dist: scikit-learn==1.7.2
+Dynamic: license-file
+
+#rasar
+The components of this module can be used for read-across related calculations. It is a crucial module for cheminformatics applications. 
+
+
+## Installation
+pip install rasar
+
+
+## Usage
+This module supports five different read-across tasks, including pairwise similarity calculation, read-across prediction, read-across optimization, read-across feature importance calculation, and rasar descriptor calculation.
+
+
+## Getting started
+import pandas as pd
+from rasar import ra_similarity, ra_pred, ra_optimization, ra_importance, calculate_descriptor
+tr = pd.read_excel('train.xlsx', index_col=0)
+te = pd.read_excel('test.xlsx', index_col=0)
+xtr = tr.iloc[:,:-1]
+ytr = tr.iloc[:,-1]
+xte = te.iloc[:,:-1]
+yte = te.iloc[:,-1]
+sim = ra_similarity(des_tr=xtr, des_te=xte)
+sim1 = sim.similarity_calculation(method='Euclidean Distance')
+pred = ra_pred(df1=tr, df2=te).weighted_prediction(method='Laplacian Kernel', ctc=6, gamma=0.5)
+opt = ra_optimization(method='Laplacian Kernel', data=tr, parameters={'CTC': [1, 3, 6, 10], 
+                                                                      'Gamma': [0.1, 0.5, 1],
+                                                                      'Threshold': [0.0]}, 
+                                                                      objective_function="MAE", 
+                                                                      cv_fold=5)
+imp = ra_importance(df1=tr).imp_calculation(method='Laplacian Kernel', ctc=6, gamma=0.5, ths=2)
+ra_importance(df1=tr).plot_importance(imp_df=imp, plot_type='coefficient', color="winter_r", index=1)
+des_tr, des_te = calculate_descriptor(df1=tr, df2=te, method='Laplacian Kernel', ctc=6, gamma=0.5, merge = True)
+
+##Cite
+To use this module, users need to cite the following paper:
+
+Pore, S. and Roy, K., 2025. “intelligent Read Across (iRA)”-A tool for read-across-based toxicity prediction of nanoparticles. Computational and Structural Biotechnology Journal. https://doi.org/10.1016/j.csbj.2025.07.032
+
+
+##LICENSE
+Apache License 2.0
+

rasar-0.1.0/rasar.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+rasar/__init__.py
+rasar/feature_importance.py
+rasar/optimization.py
+rasar/prediction.py
+rasar/rasar_descriptors.py
+rasar/similarity.py
+rasar.egg-info/PKG-INFO
+rasar.egg-info/SOURCES.txt
+rasar.egg-info/dependency_links.txt
+rasar.egg-info/requires.txt
+rasar.egg-info/top_level.txt

rasar-0.1.0/rasar.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rasar-0.1.0/rasar.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pandas==2.3.3
+numpy==2.2.6
+matplotlib==3.10.7
+scikit-learn==1.7.2

rasar-0.1.0/rasar.egg-info/top_level.txt

@@ -0,0 +1 @@
+rasar

rasar-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+