MASSA-Algorithm 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

MASSA_Algorithm/MASSA.py

@@ -1,3 +1,4 @@
+import time
 from MASSA_Algorithm import MASSAlogos
 from MASSA_Algorithm import MASSAargs
 from MASSA_Algorithm import MASSAod
@@ -8,6 +9,8 @@ from MASSA_Algorithm import MASSApreparation
 from MASSA_Algorithm import MASSAcluster
 from MASSA_Algorithm import MASSAsplit
 from MASSA_Algorithm import MASSAmoloutput
+from joblib import parallel_backend
+
 
 
 def returns_zero(total, test, validation):
@@ -48,10 +51,11 @@ def main():
         Main subroutine, allows the program to run directly from
         the command line when installed via pip.
     """
+    parallel_backend('multiprocessing')
     # Initializing from the command line.
     # Print the program logo:
     MASSAlogos.initial_print()
-
+    start_time = time.time()
     # It captures command line arguments.
     (file_input,
      file_output,
@@ -67,18 +71,32 @@ def main():
      linkage_method,
      flag_dendrogram,
      splitting_strategy,
-     drop_errors) = MASSAargs.capture_args()
+     drop_errors,
+     large_library) = MASSAargs.capture_args()
     print('Initializing, wait...\n')
 
     # Create log.txt file in directory:
-    arqlog = directoryfile_output+'/log.txt'
-    writelog = open(arqlog, 'w')
+    log_path = directoryfile_output+'/log.txt'
+    write_log = open(log_path, 'w')
 
     # Initial file management:
-    # It creates the output directories.
-    MASSAod.output_directory(directoryfile_output)
     # Read molecules.
-    mols = MASSAopen_files.read_molecules(file_input, writelog, drop_errors)
+    mols = MASSAopen_files.read_molecules(file_input, write_log, drop_errors)
+
+    # If auto detection is enable to select the initial cluster algorithm.
+    if large_library == 'auto':
+        if int(len(mols)) > 9999:
+            large_library = True
+        else:
+            large_library = False
+
+    if large_library == True:
+        # Deactivates the HCA dendrogram.
+        flag_dendrogram = False
+
+    # It creates the output directories.
+    MASSAod.output_directory(directoryfile_output, flag_dendrogram)
+
     # Extracting the property names from the ".sdf" input file.
     sdf_property_names = MASSAopen_files.get_sdf_property_names(mols)
     # Structure 3D management - It adds hydrogens keeping 3D coordenates.
@@ -87,6 +105,7 @@ def main():
     # Extraction properties from ".sdf":
     # It extracts the names of the molecules and creates a name:molecule dictionary and a dataframe.
     names, dataframe = MASSAextraction.name_extraction(mols_h)
+
     # It defines a list of what biological activities are being extracted.
     biological_activity = MASSAextraction.the_biological_handler(
         sdf_property_names, number_bioact, bioactivities_as_args)
@@ -112,16 +131,28 @@ def main():
     # PCA for the structural domain.
     fp_pca = MASSApreparation.pca_maker(fp_matrix, npcs, svd_parameter)
 
-    # First clustering (HCA):
-    # It performs HCA clustering without generating the dendrogram for the biological domain.
-    leaves_cluster_bio, bio_hca, linkage_bio, cutoff_bio = MASSAcluster.hca_clusters(
-        bio_pca, names, 'bio', directoryfile_output, extension_type, linkage_method)
-    # It performs HCA clustering without generating the dendrogram for the physicochemical domain.
-    leaves_cluster_phch, phch_hca, linkage_phch, cutoff_phch = MASSAcluster.hca_clusters(
-        phch_pca, names, 'PhCh', directoryfile_output, extension_type, linkage_method)
-    # It performs HCA clustering without generating the dendrogram for the structural domain.
-    leaves_cluster_fp, fp_hca, linkage_fp, cutoff_fp = MASSAcluster.hca_clusters(
-        fp_pca, names, 'FP', directoryfile_output, extension_type, linkage_method)
+    if large_library == True:
+        # First clustering (MiniBatch-KMeans):
+        # It performs KMeans clustering for the biological domain.
+        bio_hca = MASSAcluster.kmeans_clusters(
+            bio_pca, names, 'bio', directoryfile_output, extension_type)
+        # It performs KMeans clustering for the physicochemical domain.
+        phch_hca = MASSAcluster.kmeans_clusters(
+            phch_pca, names, 'PhCh', directoryfile_output, extension_type)
+        # It performs KMeans clustering for the structural domain.
+        fp_hca = MASSAcluster.kmeans_clusters(
+            fp_pca, names, 'FP', directoryfile_output, extension_type)
+    else:
+        # First clustering (HCA):
+        # It performs HCA clustering without generating the dendrogram for the biological domain.
+        leaves_cluster_bio, bio_hca, linkage_bio, cutoff_bio = MASSAcluster.hca_clusters(
+            bio_pca, names, 'bio', directoryfile_output, extension_type, linkage_method)
+        # It performs HCA clustering without generating the dendrogram for the physicochemical domain.
+        leaves_cluster_phch, phch_hca, linkage_phch, cutoff_phch = MASSAcluster.hca_clusters(
+            phch_pca, names, 'PhCh', directoryfile_output, extension_type, linkage_method)
+        # It performs HCA clustering without generating the dendrogram for the structural domain.
+        leaves_cluster_fp, fp_hca, linkage_fp, cutoff_fp = MASSAcluster.hca_clusters(
+            fp_pca, names, 'FP', directoryfile_output, extension_type, linkage_method)
 
     # It adds the biological cluster identification to the spreadsheet.
     dataframe = MASSApreparation.organize_df_clusterization(
@@ -137,7 +168,8 @@ def main():
     # It creates a matrix with cluster identifications for each of the three domains for Kmodes.
     matrix_for_kmodes = MASSApreparation.organize_for_kmodes(dataframe)
     # It performs Kmodes clustering for the general domain.
-    all_hca = MASSAcluster.kmodes_clusters(matrix_for_kmodes, names)
+    all_hca = MASSAcluster.kmodes_clusters(matrix_for_kmodes, names,
+                                           directoryfile_output, extension_type)
     # It adds the general cluster identification to the spreadsheet.
     dataframe = MASSApreparation.organize_df_clusterization(
         dataframe, all_hca, 'all')
@@ -239,27 +271,30 @@ def main():
     MASSAsplit.log_of_distributions(
         bio_distr, bio_total, bio_training,
         bio_test, bio_val, splitting_strategy,
-        writelog
+        write_log
     )
     phch_distr = 'Physicochemical Distribution'
     MASSAsplit.log_of_distributions(
         phch_distr, phch_total, phch_training,
         phch_test, phch_val, splitting_strategy,
-        writelog
+        write_log
     )
     fp_distr = 'Structural (FP) Distribution'
     MASSAsplit.log_of_distributions(
         fp_distr, fp_total, fp_training,
         fp_test, fp_val, splitting_strategy,
-        writelog
+        write_log
     )
     all_distr = 'General Distribution'
     MASSAsplit.log_of_distributions(
         all_distr, all_total, all_training,
         all_test, all_val, splitting_strategy,
-        writelog
+        write_log
     )
-    writelog.close()
+
+    # Output management:
+    # It adds, for each molecule, the values of the calculated properties, the identifications of each cluster and which set the molecule belongs to.
+    MASSAmoloutput.output_file_mols(dataframe, file_output)
 
     # Plot HCAs:
     if flag_dendrogram == True:
@@ -280,7 +315,8 @@ def main():
             extension_type, dendrogram_xfont_size, test_or_val_molecules
         )  # fp_Plot: Plot the HCA dendrogram
 
-    # Output management:
-    # It adds, for each molecule, the values of the calculated properties, the identifications of each cluster and which set the molecule belongs to.
-    MASSAmoloutput.output_mols(dataframe, file_output)
-    print('Completed')
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    write_log.write(f'Completed! Elapsed time = {elapsed_time} s.')
+    write_log.close()
+    print(f'Completed! Elapsed time = {elapsed_time} s.')

MASSA_Algorithm/MASSAargs.py

@@ -26,7 +26,7 @@ def capture_args():
             '[-n <number_of_principal_components>] [-v <svd_parameter>] [-l <linkage_method] '
             '[-t <extension_for_images>] [-d <dendrogram_font_size_on_Xaxis>] '
             '[-x <frequency_bar_plot_font_size_on_Xaxis>] [-f <toggle_dendrogram>] '
-            '[-e <drop_molecules_with_errors]'
+            '[-e <drop_molecules_with_errors] [-a <large_dataset>]'
         )
     )
     required = parser.add_argument_group('required arguments')
@@ -120,9 +120,17 @@ def capture_args():
                                 )
                           )
     optional.add_argument('-e', '--drop_errors', type=str, choices=['true', 'false'],
-                          metavar='DROP_MOLECULES_WITH_ERRORS', default='false', help=(
+                          metavar='DROP_MOLECULES_WITH_ERRORS', default='true', help=(
                           'Ignore chemistry errors, saving only molecules without any errors. '
-                          'Default = \'false\'.'
+                          'False will treat molecule errors as fatal and fail the execution. '
+                          'Default = \'true\'.'
+                          ))
+    optional.add_argument('-a', '--large_dataset', type=str, choices=['auto', 'true', 'false'],
+                          metavar='LARGE_DATASET', default='auto', help=(
+                          'Switch the MASSA algorithm from HCA to KMeans to handle large datasets. '
+                          'Options = auto (switches to KMeans if ≥ 10,000 molecules),  '
+                          'false = use HCA (for smaller datasets), '
+                          'true = use KMeans (for large datasets).'
                           ))
     args = parser.parse_args()
 
@@ -153,6 +161,12 @@ def capture_args():
     flag_strategy = str(args.splitting_strategy).lower()
     # It captures whether or not to ignore chemistry errors.
     drop = str(args.drop_errors).lower()
+    # It captures whether or not is handling with a large dataset.
+    large_dataset = str(args.large_dataset).lower()
+    if large_dataset == 'true':
+        large_dataset = True
+    elif large_dataset == 'false':
+        large_dataset = False
 
     if args.the_biological_activities != None:
         # It creates a list with the names of the biological activities to be searched for.
@@ -210,5 +224,6 @@ def capture_args():
         linkage_method,
         flag_dendrogram,
         flag_strategy,
-        drop
+        drop,
+        large_dataset
     )

MASSA_Algorithm/MASSAcluster.py

@@ -3,6 +3,9 @@ from matplotlib import pyplot as plt
 from matplotlib import colors as colrs
 import scipy.cluster.hierarchy as sch
 from kmodes import kmodes
+from sklearn.cluster import MiniBatchKMeans as KMeans
+from multiprocessing import cpu_count as mpi_count
+from scipy.spatial.distance import cdist
 
 
 def numerical_number_of_clusters(distances_list):
@@ -26,12 +29,15 @@ def numerical_number_of_clusters(distances_list):
     return distances.index(max(distances)) + 1
 
 
-def categorical_number_of_clusters(file):
+def categorical_number_of_clusters(file, directory_fileoutput, extension_type):
     # Elbow method using the clustering cost:
     list_clus_costs = []
-    for n in range(2, 21):  # Calculate the cost for each n cluster.
+    maxcluster = 31
+    ran_curve = [x for x in range(2, maxcluster, 2)]
+    for n in range(2, maxcluster):  # Calculate the cost for each n cluster.
         km = kmodes.KModes(n_clusters=n, verbose=0,
-                           n_init=20, init='Cao', max_iter=300)
+                           n_init=20, init='Cao',
+                           n_jobs=-1, max_iter=300)
         km.fit(X=file)
         # Costs = Clustering cost, defined as the sum distance of all points
         # to their respective cluster centroids.
@@ -39,10 +45,10 @@ def categorical_number_of_clusters(file):
     # Define the x-axis coordinates of the first and last points on the line.
     x1, y1 = 2, list_clus_costs[0]
     # Define the y-axis coordinates of the first and last points on the line.
-    x2, y2 = 20, list_clus_costs[len(list_clus_costs)-1]
+    x2, y2 = 20, list_clus_costs[18]
 
     distances = []
-    for i in range(len(list_clus_costs)):
+    for i in range(19):
         # Coordinate on the x-axis of the point to calculate the distance to the line.
         x0 = i+2
         # Coordinate on the y-axis of the point to calculate the distance to the line.
@@ -51,7 +57,52 @@ def categorical_number_of_clusters(file):
         denominator = ((y2 - y1)**2 + (x2 - x1)**2)**(1/2)
         # Distance between a point and a line.
         distances.append(numerator/denominator)
-    return (distances.index(max(distances)) + 2)
+    number_of_clusters = (distances.index(max(distances)) + 2)
+    ident = "all"
+    plot_distortion(
+        list_clus_costs, directory_fileoutput,
+        ident, extension_type, number_of_clusters,
+        ran_curve)
+    return number_of_clusters
+
+
+def kmeans_number_of_clusters(file, ident, directory_fileoutput, extension_type):
+    # Elbow method using the clustering cost:
+    list_clus_costs = []
+    maxcluster = 31
+    ran_curve = [x for x in range(2, maxcluster, 2)]
+    for n in range(2, maxcluster):  # Calculate the cost for each n cluster.
+        km = KMeans(n_clusters=n, verbose=0,
+                    init='k-means++', max_iter=300,
+                    batch_size=256*int(mpi_count()),
+                    compute_labels=True, random_state=2025)
+        km.fit(X=file)
+        # Costs = Clustering cost, defined as the sum distance of all points
+        # to their respective cluster centroids.
+        list_clus_costs.append(
+            np.sum(np.min(cdist(file, km.cluster_centers_, 'euclidean'), axis=1)**2) / file.shape[0])
+    # Define the x-axis coordinates of the first and last points on the line.
+    x1, y1 = 2, list_clus_costs[0]
+    # Define the y-axis coordinates of the first and last points on the line.
+    x2, y2 = 20, list_clus_costs[18]
+
+    distances = []
+    for i in range(19):
+        # Coordinate on the x-axis of the point to calculate the distance to the line.
+        x0 = i+2
+        # Coordinate on the y-axis of the point to calculate the distance to the line.
+        y0 = list_clus_costs[i]
+        numerator = abs((y2-y1)*x0 - (x2-x1)*y0 + x2*y1 - y2*x1)
+        denominator = ((y2 - y1)**2 + (x2 - x1)**2)**(1/2)
+        # Distance between a point and a line.
+        distances.append(numerator/denominator)
+
+    number_of_clusters = (distances.index(max(distances)) + 2)
+    plot_distortion(
+        list_clus_costs, directory_fileoutput,
+        ident, extension_type, number_of_clusters,
+        ran_curve)
+    return number_of_clusters
 
 
 def optimal_threshold(file, ident, directory_fileoutput, extension_type, linkage):
@@ -69,7 +120,7 @@ def optimal_threshold(file, ident, directory_fileoutput, extension_type, linkage
     if ident == 'bio':
         # Define the name, directory and extension of the Euclidean distance graph.
         name_euc_dist_file = directory_fileoutput + \
-            '/Images/Distance_HCA_Images/Dist_HCA_biological.'+extension_type
+            'Images/Distance_Images/Dist_HCA_biological.'+extension_type
         title_distances = 'Plot of Euclidean Distances from Biological HCA'
         print('Number of clusters:')
         # Print the number of clusters for the biological domain.
@@ -80,7 +131,7 @@ def optimal_threshold(file, ident, directory_fileoutput, extension_type, linkage
     elif ident == 'PhCh':
         # Define the name, directory and extension of the Euclidean distance graph.
         name_euc_dist_file = directory_fileoutput + \
-            '/Images/Distance_HCA_Images/Dist_HCA_physicochemical.'+extension_type
+            'Images/Distance_Images/Dist_HCA_physicochemical.'+extension_type
         title_distances = 'Plot of Euclidean Distances from Physicochemical HCA'
         # Print the number of clusters for the physicochemical domain.
         print('Physicochemical:', number_of_clusters)
@@ -90,7 +141,7 @@ def optimal_threshold(file, ident, directory_fileoutput, extension_type, linkage
     else:
         # Define the name, directory and extension of the Euclidean distance graph.
         name_euc_dist_file = directory_fileoutput + \
-            '/Images/Distance_HCA_Images/Dist_HCA_structural.'+extension_type
+            'Images/Distance_Images/Dist_HCA_structural.'+extension_type
         title_distances = 'Plot of Euclidean Distances from Structural HCA'
         # Print the number of clusters for the structural domain.
         print('Structural:', number_of_clusters)
@@ -279,24 +330,24 @@ def hca_plot(
     if ident == 'bio':
         plt.title('HCA of biological activity')
         plt.savefig(directory_fileoutput +
-                    '/Images/Dendrogram_HCA_Images/HCA_biological.'+extension_type)
+                    'Images/Dendrogram_HCA_Images/HCA_biological.'+extension_type)
         plt.close()
     elif ident == 'PhCh':
         plt.title('HCA of physicochemical properties')
         plt.savefig(directory_fileoutput +
-                    '/Images/Dendrogram_HCA_Images/HCA_physicochemical.'+extension_type)
+                    'Images/Dendrogram_HCA_Images/HCA_physicochemical.'+extension_type)
         plt.close()
     else:
         plt.title('HCA of AtomPairs fingerprint')
         plt.savefig(directory_fileoutput +
-                    '/Images/Dendrogram_HCA_Images/HCA_structural.'+extension_type)
+                    'Images/Dendrogram_HCA_Images/HCA_structural.'+extension_type)
         plt.close()
 
 
-def kmodes_clusters(file, names):
+def kmodes_clusters(file, names, directory_fileoutput, extension_type):
     # Calculate the number of clusters for the Kmodes:
-    n_clusters = categorical_number_of_clusters(file)
-    print('General:', n_clusters)  # Print the number of clusters.
+    n_clusters = categorical_number_of_clusters(
+        file, directory_fileoutput, extension_type)
 
     # Run Kmodes with the calculated number of clusters:
     # Parameter setting.
@@ -311,3 +362,114 @@ def kmodes_clusters(file, names):
     for i, a in zip(names, clusters_list):
         HCA_General_dict[i] = int(a+1)
     return HCA_General_dict
+
+
+def plot_distortion(
+        list_clus_costs, directory_fileoutput,
+        ident, extension_type, number_of_clusters,
+        ran_curve):
+    plt.plot(
+        list(range(2, len(list_clus_costs)+2)),
+        list_clus_costs, '-o',
+        color='black',
+        markersize=4, linewidth=1,
+        markeredgewidth=1
+    )  # Initial setting of graph values and parameters.
+    if ident == 'bio':
+        # Define the name, directory and extension of the Distortion graph.
+        name_euc_dist_file = directory_fileoutput + \
+            'Images/Distance_Images/Distortion_biological.'+extension_type
+        title_distances = 'Plot of Distortion from Biological Space'
+        print('Number of clusters:')
+        # Print the number of clusters for the biological domain.
+        print('Biological:', number_of_clusters)
+        plt.ylabel('KMeans Distortion')  # Set the y-axis label.
+    elif ident == 'PhCh':
+        # Define the name, directory and extension of the Distortion graph.
+        name_euc_dist_file = directory_fileoutput + \
+            'Images/Distance_Images/Distortion_physicochemical.'+extension_type
+        title_distances = 'Plot of Distortion from Physicochemical Space'
+        # Print the number of clusters for the physicochemical domain.
+        print('Physicochemical:', number_of_clusters)
+        plt.ylabel('KMeans Distortion')  # Set the y-axis label.
+    elif ident == 'FP':
+        # Define the name, directory and extension of the Distortion graph.
+        name_euc_dist_file = directory_fileoutput + \
+            'Images/Distance_Images/Distortion_structural.'+extension_type
+        title_distances = 'Plot of Distortion from Structural Space'
+        # Print the number of clusters for the structural domain.
+        print('Structural:', number_of_clusters)
+        plt.ylabel('KMeans Distortion')  # Set the y-axis label.
+    else:
+        # Define the name, directory and extension of the Distortion graph.
+        name_euc_dist_file = directory_fileoutput + \
+            'Images/Distance_Images/Cost_general.'+extension_type
+        title_distances = 'Cost Plot from General (KModes)'
+        # Print the number of clusters for the structural domain.
+        print('General:', number_of_clusters)
+        plt.ylabel('KModes Cost')  # Set the y-axis label.
+    plt.title(title_distances)  # Define the graph title.
+    plt.xticks(ran_curve)  # Define the x-axis ticks.
+    plt.savefig(name_euc_dist_file)  # Save figure.
+    plt.close()  # Close plot.
+
+
+def kmeans_number_of_clusters(file, ident, directory_fileoutput, extension_type):
+    # Elbow method using the clustering cost:
+    list_clus_costs = []
+    maxcluster = 31
+    ran_curve = [x for x in range(2, maxcluster, 2)]
+    for n in range(2, maxcluster):  # Calculate the cost for each n cluster.
+        km = KMeans(n_clusters=n, verbose=0,
+                    init='k-means++', max_iter=300,
+                    batch_size=256*int(mpi_count()),
+                    compute_labels=True, random_state=2025)
+        km.fit(X=file)
+        # Costs = Clustering cost, defined as the sum distance of all points
+        # to their respective cluster centroids.
+        list_clus_costs.append(
+            np.sum(np.min(cdist(file, km.cluster_centers_, 'euclidean'), axis=1)**2) / file.shape[0])
+    # Define the x-axis coordinates of the first and last points on the line.
+    x1, y1 = 2, list_clus_costs[0]
+    # Define the y-axis coordinates of the first and last points on the line.
+    x2, y2 = 20, list_clus_costs[18]
+
+    distances = []
+    for i in range(19):
+        # Coordinate on the x-axis of the point to calculate the distance to the line.
+        x0 = i+2
+        # Coordinate on the y-axis of the point to calculate the distance to the line.
+        y0 = list_clus_costs[i]
+        numerator = abs((y2-y1)*x0 - (x2-x1)*y0 + x2*y1 - y2*x1)
+        denominator = ((y2 - y1)**2 + (x2 - x1)**2)**(1/2)
+        # Distance between a point and a line.
+        distances.append(numerator/denominator)
+
+    number_of_clusters = (distances.index(max(distances)) + 2)
+    plot_distortion(
+        list_clus_costs, directory_fileoutput,
+        ident, extension_type, number_of_clusters,
+        ran_curve)
+    return number_of_clusters
+
+
+def kmeans_clusters(file, names, ident, directory_fileoutput, extension_type):
+    # Calculate the number of clusters for the Kmodes:
+    n_clusters = kmeans_number_of_clusters(
+        file, ident, directory_fileoutput, extension_type)
+
+    # Run Kmodes with the calculated number of clusters:
+    # Parameter setting.
+    km = KMeans(n_clusters=n_clusters, verbose=0,
+                init='k-means++', max_iter=300,
+                batch_size=256*int(mpi_count()),
+                compute_labels=True, random_state=2025)
+    # Run Kmodes for the dataset and return an array with cluster labels for each molecule.
+    clusters = km.fit_predict(file)
+    clusters_list = list(clusters)  # Transform np.array into a list.
+
+    # Create a dictionary with the pair "molecule name": "General cluster ID":
+    kmeans_cluster_dict = {}
+    for i, a in zip(names, clusters_list):
+        kmeans_cluster_dict[i] = int(a+1)
+    return kmeans_cluster_dict

MASSA_Algorithm/MASSAextraction.py

@@ -5,11 +5,11 @@ from rdkit.Chem import AllChem
 def name_extraction(file):
     names = []
     dict_names = {}
-    for i in file:
+    for idx, f in enumerate(file):
         try:
-            names.append(i.GetProp('_Name'))  # Get name of molecules to a list
+            names.append(f.GetProp('_Name'))  # Get name of molecules to a list
             # Get name of molecules to a dict
-            dict_names[i.GetProp('_Name')] = i
+            dict_names[idx] = [f.GetProp('_Name'), f]
         except:
             names.append(None)
     if None in names:  # If any molecule is unnamed it returns an error.
@@ -17,8 +17,39 @@ def name_extraction(file):
         print('Closing...')
         exit()
     else:
-        dataframe = pd.DataFrame({'molecules': pd.Series(dict_names)})
-    return names, dataframe
+        # Dealing with duplicates:
+        duplicates = {}
+        for idx, value in dict_names.items():
+            name = value[0]
+            mol = value[1]
+            if name in duplicates.keys():
+                duplicates[name].append([idx, mol])
+            else:
+                duplicates[name] = [[idx, mol]]
+
+        final_names = []
+        final_names_dict = {}
+        for k, v in duplicates.items():
+            name = k
+            replicates = v
+            if len(replicates) > 1:
+                for r in replicates:
+                    index = r[0]
+                    molecule = r[1]
+                    final_key = f"{name}_idx-_{index}"
+                    molecule.SetProp("_Name", final_key)
+                    final_names_dict[final_key] = molecule
+                    final_names.append(final_key)
+            else:
+                for r in replicates:
+                    index = r[0]
+                    molecule = r[1]
+                    final_key = name
+                    molecule.SetProp("_Name", final_key)
+                    final_names_dict[final_key] = molecule
+                    final_names.append(final_key)
+        dataframe = pd.DataFrame({'molecules': pd.Series(final_names_dict)})
+    return final_names, dataframe
 
 
 def the_biological_handler(sdf_property_names, numberBioAct, BioActAsArgs):

MASSA_Algorithm/MASSAlogos.py

@@ -20,7 +20,7 @@ def initial_print():
        ██░░░▓▓▓▓░░░░░░░▓▓▓▓░░░░░░░▓▓▓▓░░░░█
      ██░░░░▓▓▓▓▓▓░░░░░▓▓▓▓▓▓░░░░░▓▓▓▓▓▓░░░░█                                 MASSA Algorithm:
    ████░░░░░▓▓▓▓░░░░░░░▓▓▓▓░░░░░░░▓▓▓▓░░░░░█████          Molecular data set sampling  —  Training-Test Separation
-  █▓▓▓███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███▓▓▓█                            Version: v. 1.0.0
+  █▓▓▓███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███▓▓▓█                            Version: v. 2.0.1
  █▒▓▓▒▒▒████░░░░░░░░░░░░░░░░░░░░░░░░░░░░████▒▒▓▓▒█
  ██▓▒▒▒▓▓▓▓██████████████████████████████▓▓▓▒▒▒▒▓█                Developed by: Gabriel Corrêa Veríssimo
  ██▒▒▒▓▓▒▒▒▒▓▓▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▓▓▒▒▒▓▓▒▒██                           LICENSE: AGPL-3.0
@@ -28,3 +28,7 @@ def initial_print():
      ███▓▓▓▓▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▓▓████
         ███████████████████████████████████
         ''')
+
+
+def python_logo():
+    print("🍕 MASSA Algorithm v. 2.0.1: Molecular data set sampling")

MASSA_Algorithm/MASSAmoloutput.py

@@ -1,7 +1,7 @@
 from rdkit.Chem import AllChem
 
 
-def output_mols(dataframe, file_output):
+def output_mols(dataframe):
     """
     For each molecule, adds the values of the calculated properties,
     the identifications of each cluster and which set the molecule belongs to.
@@ -9,7 +9,6 @@ def output_mols(dataframe, file_output):
 
     Args:
         dataframe (pd.DataFrame): The dataframe of molecules.
-        file_output (str): The path to the output file.
     """
     # Creation of dictionaries with the name of the molecule:
     dict_molecules = dict(
@@ -41,6 +40,8 @@ def output_mols(dataframe, file_output):
 
     # Add the properties to molecules from the name:molecule dictionary:
     for i in dict_molecules.keys():
+        name = dict_molecules[i].GetProp('_Name')
+        dict_molecules[i].SetProp("_Name", name)
         dict_molecules[i].SetProp('Set', str(dict_set[i]))
         dict_molecules[i].SetProp('HBA count', str(dic_hba[i]))
         dict_molecules[i].SetProp('HBD count', str(dic_hbd[i]))
@@ -62,9 +63,27 @@ def output_mols(dataframe, file_output):
 
     # Create a dict_values with just the molecules
     # (the name of the molecule is already part of molecule object):
-    output_mols = dict_molecules.values()
+    out_mols = list(dict_molecules.values())
+    return out_mols
+
+
+def output_file_mols(dataframe, file_output):
+    """
+    For each molecule, adds the values of the calculated properties,
+    the identifications of each cluster and which set the molecule belongs to.
+    Also, it creates the final output .sdf file.
+
+    Args:
+        dataframe (pd.DataFrame): The dataframe of molecules.
+        file_output (str): The path to the output file.
+    """
+
+    # Recovers a list with just the molecules
+    # (the name of the molecule is already part of molecule object):
+    out_mols = output_mols(dataframe)
 
     # Create output ".sdf" file:
     with AllChem.SDWriter(file_output) as w:
-        for m in output_mols:
+        for m in out_mols:
             w.write(m)
+    return out_mols

MASSA_Algorithm/MASSAod.py

@@ -1,7 +1,7 @@
 import os
 
 
-def output_directory(directory_file_output):
+def output_directory(directory_file_output, flag_dendrogram):
     """
     Creates the output directories.
     """
@@ -10,13 +10,14 @@ def output_directory(directory_file_output):
     except FileExistsError:
         pass
     try:
-        os.makedirs(directory_file_output+'Images/Distance_HCA_Images')
-    except FileExistsError:
-        pass
-    try:
-        os.makedirs(directory_file_output+'Images/Dendrogram_HCA_Images')
+        os.makedirs(directory_file_output+'Images/Distance_Images')
     except FileExistsError:
         pass
+    if flag_dendrogram == True:
+        try:
+            os.makedirs(directory_file_output+'Images/Dendrogram_HCA_Images')
+        except FileExistsError:
+            pass
     try:
         os.makedirs(directory_file_output+'Images/Distribution')
     except FileExistsError:

MASSA_Algorithm/MASSAopen_files.py

@@ -50,33 +50,33 @@ def find_name_column(columns):
     Returns:
         column_name (str): returns the name of the molecule name column.
     """
-
+    name_column = ""
     for column in columns:
         if "molecule name" == column.lower():
             print((f"Found '{column}' column."
                    " Using it to name the molecules."))
             name_column = column
-            return name_column
+            break
         elif "name" == column.lower():
             print((f"Found '{column}' column."
                    " Using it to name the molecules."))
             name_column = column
-            return name_column
+            break
         elif "molecule chembl id" == column.lower():
             print((f"Found '{column}' column."
                    " Using it to name the molecules."))
             name_column = column
-            return name_column
+            break
         elif "id" == column.lower():
             print((f"Found '{column}' column."
                    " Using it to name the molecules."))
             name_column = column
-            return name_column
-        else:
-            print(("Unable to find a column with molecule names."
-                   " Using the index to name the molecules."))
-            name_column = "index"
-            return name_column
+            break
+    if name_column == "":
+        print(("Unable to find a column with molecule names."
+                " Using the index to name the molecules."))
+        name_column = "index"
+    return name_column
 
 
 def read_df_smiles(df, write_log, drop_errors):
@@ -94,7 +94,6 @@ def read_df_smiles(df, write_log, drop_errors):
     smi_name_column = find_smiles_column(columns)
     name_name_column = find_name_column(columns)
 
-    # name_name_column = "index"
     columns.remove(smi_name_column)
     columns.remove(name_name_column)
 
@@ -132,13 +131,13 @@ def read_df_smiles(df, write_log, drop_errors):
     return mols
 
 
-def read_EXCEL_smiles(file, write_log):
+def read_EXCEL_smiles(file, write_log, drop_errors):
     df_supplier = pd.read_excel(file)
     mols_sanitized = read_df_smiles(df_supplier, write_log, drop_errors)
     return mols_sanitized
 
 
-def read_CSV_smiles(file, write_log):
+def read_CSV_smiles(file, write_log, drop_errors):
     df_supplier = pd.read_csv(file, sep=",")
     mols_sanitized = read_df_smiles(df_supplier, write_log, drop_errors)
     return mols_sanitized
@@ -281,18 +280,18 @@ def read_molecules(file, write_log, drop_errors):
     elif file.endswith(".sdf") or file.endswith(".mol"):
         molecules = read_SDF(file, write_log, drop_errors)
     elif file.endswith(".xlsx") or file.endswith(".xls"):
-        molecules = read_EXCEL_smiles(file, write_log)
+        molecules = read_EXCEL_smiles(file, write_log, drop_errors)
     elif file.endswith(".csv"):
-        molecules = read_CSV_smiles(file, write_log)
+        molecules = read_CSV_smiles(file, write_log, drop_errors)
     return molecules
 
 
 def hydrogen_add(file):
     molsH = []
     for i in file:
+        # Add hydrogens keeping 3D coordenates.
         i = AllChem.AddHs(i, addCoords=True)
         molsH.append(i)
-        # Add hydrogens keeping 3D coordenates.
     return molsH
 
 

MASSA_Algorithm/MASSApreparation.py

@@ -46,16 +46,13 @@ def pca_maker(file, nPCS, svd_parameter):
 def organize_df_clusterization(file, HCAdict, ident):
     if ident == 'all':
         file['Cluster_General'] = pd.Series(HCAdict)
-        return file
     elif ident == 'bio':
         file['Cluster_Biological'] = pd.Series(HCAdict)
-        return file
     elif ident == 'PhCh':
         file['Cluster_Physicochemical'] = pd.Series(HCAdict)
-        return file
     else:
         file['Cluster_Structural'] = pd.Series(HCAdict)
-        return file
+    return file
 
 
 # Create a matrix with cluster identifications for each of the three domains, in order to prepare for Kmodes.

MASSA_Algorithm/MASSAsplit.py

@@ -19,6 +19,7 @@ def split_train_test_sets(file, training_percent, splitting_strategy):
         test_or_val_molecules: An identification of which molecules are on the validation set.
 
     """
+    file["start_index"] = range(len(file))
     if splitting_strategy == "tt":
         # Split the set of molecules into training set and test set,
         # preserving the cluster diversity of the total set according
@@ -68,6 +69,7 @@ def split_train_test_sets(file, training_percent, splitting_strategy):
         dataset = pd.concat([training, test, validation])
         # Define the output sets for the algorithm.
         test_or_val_molecules = [test_molecules, validation_molecules]
+    dataset = dataset.sort_values(by="start_index")
     return dataset, test_or_val_molecules
 
 

MASSA_Algorithm/pyMASSA.py

@@ -0,0 +1,353 @@
+from MASSA_Algorithm import MASSAlogos
+from MASSA_Algorithm import MASSAargs
+from MASSA_Algorithm import MASSAod
+from MASSA_Algorithm import MASSAopen_files
+from MASSA_Algorithm import MASSAextraction
+from MASSA_Algorithm import MASSAdescriptors
+from MASSA_Algorithm import MASSApreparation
+from MASSA_Algorithm import MASSAcluster
+from MASSA_Algorithm import MASSAsplit
+from MASSA_Algorithm import MASSAmoloutput
+import time
+
+
+def returns_zero(total, test, validation):
+    """
+    Description:
+        It evaluates whether the distribution is inadequate. That is,
+        when the iterated cluster has a percentage greater than 0.5%
+        in the complete dataset but less than 0.5% in the test set.
+
+    Args:
+        total (dict):
+        Percentage of molecules in each cluster for the whole dataset.
+
+        test (dict):
+        Percentage of molecules in each cluster for the test subset.
+
+        validation (dict):
+        Percentage of molecules in each cluster for the validation subset.
+
+    Returns:
+        definer (boolean): Returns True if the distribution is
+                           inadequate, and False if it is adequate.
+    """
+    definer = False
+    for i in total.keys():
+        if (total[i] > 0.5) and (test[i] <= 0.5):
+            # Definer = True (Distribution was not done properly).
+            definer = True
+        elif validation != None:
+            if (total[i] > 0.5) and (validation[i] <= 0.5):
+                definer = True
+    return definer
+
+
+def py_massa(
+    file_input=str(),
+    working_directory=str(),
+    job_name="MASSAoutput.sdf",
+    extension_type="svg",
+    dendrogram_xfont_size=5,
+    barplot_xfont_size=9,
+    training_percent=round(float(0.8), 3),
+    bioactivities_as_args=None,
+    npcs=0.85,
+    svd_parameter="full",
+    linkage_method="complete",
+    flag_dendrogram=True,
+    splitting_strategy="tt",
+    drop_errors=True,
+    large_library="auto"
+):
+    # Initializing from Python.
+    # Print the program logo:
+    MASSAlogos.python_logo()
+    start_time = time.time()
+
+    # Defining the working_directory alias:
+    working_directory = f"{working_directory}/"
+    directoryfile_output = working_directory
+
+    # It creates the output directories:
+    MASSAod.output_directory(directoryfile_output, flag_dendrogram)
+
+    # Test nPCs:
+    if npcs > 1:
+        npcs = int(npcs)
+    elif (npcs > 0) and (npcs <= 1):
+        npcs = float(npcs)
+    else:
+        raise ValueError(
+            f"ERROR: The defined number of main components is invalid. npcs = {str(npcs)}")
+
+    # Autodetect if the biological activities are set.
+    if isinstance(bioactivities_as_args, str):
+        number_bioact = 1
+        bioactivities_as_args = [bioactivities_as_args]
+    elif isinstance(bioactivities_as_args, list):
+        number_bioact = len(bioactivities_as_args)
+    elif bioactivities_as_args == None:
+        raise ValueError(
+            "The biological activities are not specified. bioactivities_as_args == None")
+
+    # Create log.txt file in directory:
+    log_path = directoryfile_output+'log.txt'
+    write_log = open(log_path, 'w')
+
+    if isinstance(file_input, str):
+        # Initial file management:
+        # Read molecules.
+        mols = MASSAopen_files.read_molecules(
+            file_input, write_log, drop_errors)
+    else:
+        mols = file_input
+
+    # Test if large_library is set:
+    if isinstance(large_library, str):
+        if large_library.lower() == 'true':
+            large_library = True
+        elif large_library.lower() == 'false':
+            large_library = False
+        elif large_library.lower() == 'auto':
+            if int(len(mols)) > 9999:
+                large_library = True
+            else:
+                large_library = False
+
+    # If auto detection is enable to select the initial cluster algorithm.
+    if large_library == 'auto':
+        if int(len(mols)) > 9999:
+            large_library = True
+        else:
+            large_library = False
+
+    if large_library == True:
+        # Deactivates the HCA dendrogram.
+        flag_dendrogram = False
+
+    # Extracting the property names from the ".sdf" input file.
+    sdf_property_names = MASSAopen_files.get_sdf_property_names(mols)
+    # Structure 3D management - It adds hydrogens keeping 3D coordenates.
+    mols_h = MASSAopen_files.hydrogen_add(mols)
+
+    # Extraction properties from ".sdf":
+    # It extracts the names of the molecules and creates a name:molecule dictionary and a dataframe.
+    names, dataframe = MASSAextraction.name_extraction(mols_h)
+
+    # It defines a list of what biological activities are being extracted.
+    biological_activity = MASSAextraction.the_biological_handler(
+        sdf_property_names, number_bioact, bioactivities_as_args)
+    # It adds the biological activities to the dataframe.
+    dataframe = MASSAextraction.list_activities(dataframe, biological_activity)
+
+    # Get fingeprint and other descriptors:
+    # Get physicochemical descriptors.
+    dataframe = MASSAdescriptors.physicochemical_descriptors(dataframe)
+    # Get AtomPairs fingerprint.
+    dataframe = MASSAdescriptors.atompairs_fingerprint(dataframe)
+
+    # Normalizes physicochemical and biological properties.
+    # Creates matrices for the three domains (struc, phys-chem, bio):
+    bio_matrix, phch_matrix, fp_matrix = MASSApreparation.normalizer_or_matrix(
+        dataframe, biological_activity)
+
+    # PCA:
+    # PCA for the biological domain.
+    bio_pca = MASSApreparation.pca_maker(bio_matrix, npcs, svd_parameter)
+    # PCA for the physicochemical domain.
+    phch_pca = MASSApreparation.pca_maker(phch_matrix, npcs, svd_parameter)
+    # PCA for the structural domain.
+    fp_pca = MASSApreparation.pca_maker(fp_matrix, npcs, svd_parameter)
+
+    if large_library == True:
+        # First clustering (MiniBatch-KMeans):
+        # It performs KMeans clustering for the biological domain.
+        bio_hca = MASSAcluster.kmeans_clusters(
+            bio_pca, names, 'bio', directoryfile_output, extension_type)
+        # It performs KMeans clustering for the physicochemical domain.
+        phch_hca = MASSAcluster.kmeans_clusters(
+            phch_pca, names, 'PhCh', directoryfile_output, extension_type)
+        # It performs KMeans clustering for the structural domain.
+        fp_hca = MASSAcluster.kmeans_clusters(
+            fp_pca, names, 'FP', directoryfile_output, extension_type)
+    else:
+        # First clustering (HCA):
+        # It performs HCA clustering without generating the dendrogram for the biological domain.
+        leaves_cluster_bio, bio_hca, linkage_bio, cutoff_bio = MASSAcluster.hca_clusters(
+            bio_pca, names, 'bio', directoryfile_output, extension_type, linkage_method)
+        # It performs HCA clustering without generating the dendrogram for the physicochemical domain.
+        leaves_cluster_phch, phch_hca, linkage_phch, cutoff_phch = MASSAcluster.hca_clusters(
+            phch_pca, names, 'PhCh', directoryfile_output, extension_type, linkage_method)
+        # It performs HCA clustering without generating the dendrogram for the structural domain.
+        leaves_cluster_fp, fp_hca, linkage_fp, cutoff_fp = MASSAcluster.hca_clusters(
+            fp_pca, names, 'FP', directoryfile_output, extension_type, linkage_method)
+
+    # It adds the biological cluster identification to the spreadsheet.
+    dataframe = MASSApreparation.organize_df_clusterization(
+        dataframe, bio_hca, 'bio')
+    # It adds the physicochemical cluster identification to the spreadsheet.
+    dataframe = MASSApreparation.organize_df_clusterization(
+        dataframe, phch_hca, 'PhCh')
+    # It adds the structural cluster identification to the spreadsheet.
+    dataframe = MASSApreparation.organize_df_clusterization(
+        dataframe, fp_hca, 'FP')
+
+    # Second clustering (Kmodes):
+    # It creates a matrix with cluster identifications for each of the three domains for Kmodes.
+    matrix_for_kmodes = MASSApreparation.organize_for_kmodes(dataframe)
+    # It performs Kmodes clustering for the general domain.
+    all_hca = MASSAcluster.kmodes_clusters(matrix_for_kmodes, names,
+                                           directoryfile_output, extension_type)
+    # It adds the general cluster identification to the spreadsheet.
+    dataframe = MASSApreparation.organize_df_clusterization(
+        dataframe, all_hca, 'all')
+
+    # Split into training, test:
+    dataframe, test_or_val_molecules = MASSAsplit.split_train_test_sets(
+        dataframe, training_percent, splitting_strategy)
+
+    # Bar plot of frequencies
+    # (Calculates the percentages of molecules in each cluster for each
+    #  dataset and generates a bar graph for each domain):
+
+    # Biological Bar Plot
+    bio_total, bio_training, bio_test, bio_val = MASSAsplit.freq_clusters(
+        dataframe,
+        directoryfile_output,
+        extension_type,
+        'Cluster_Biological',
+        barplot_xfont_size,
+        splitting_strategy)
+    # Physicochemical Bar Plot
+    phch_total, phch_training, phch_test, phch_val = MASSAsplit.freq_clusters(
+        dataframe,
+        directoryfile_output,
+        extension_type,
+        'Cluster_Physicochemical',
+        barplot_xfont_size,
+        splitting_strategy)
+    # Structural Bar Plot
+    fp_total, fp_training, fp_test, fp_val = MASSAsplit.freq_clusters(
+        dataframe,
+        directoryfile_output,
+        extension_type,
+        'Cluster_Structural',
+        barplot_xfont_size,
+        splitting_strategy)
+    # General Bar Plot
+    all_total, all_training, all_test, all_val = MASSAsplit.freq_clusters(
+        dataframe,
+        directoryfile_output,
+        extension_type,
+        'Cluster_General',
+        barplot_xfont_size,
+        splitting_strategy)
+
+    # Verifying percentages:
+    # For biological domain:
+    bio_ok = returns_zero(bio_total, bio_test, bio_val)
+    # For physicochemical domain:
+    phch_ok = returns_zero(phch_total, phch_test, phch_val)
+    # For structural domain:
+    fp_ok = returns_zero(fp_total, fp_test, fp_val)
+    ok = [bio_ok, phch_ok, fp_ok]
+    max_iters = 0
+
+    # Redo the distribution in case of errors (up to 10 times):
+    while (True in ok) and (max_iters < 10):
+        # Split into training, test:
+        dataframe, test_or_val_molecules = MASSAsplit.split_train_test_sets(
+            dataframe, training_percent, splitting_strategy)
+
+        # Bar plot of frequencies (Calculates the percentages of molecules in each
+        # cluster for each dataset and generates a bar graph for each domain):
+
+        # Biological Bar Plot:
+        bio_total, bio_training, bio_test, bio_val = MASSAsplit.freq_clusters(
+            dataframe, directoryfile_output, extension_type,
+            'Cluster_Biological', barplot_xfont_size, splitting_strategy
+        )
+        # Physicochemical Bar Plot
+        phch_total, phch_training, phch_test, phch_val = MASSAsplit.freq_clusters(
+            dataframe, directoryfile_output, extension_type,
+            'Cluster_Physicochemical', barplot_xfont_size, splitting_strategy
+        )
+        # Structural Bar Plot
+        fp_total, fp_training, fp_test, fp_val = MASSAsplit.freq_clusters(
+            dataframe, directoryfile_output, extension_type,
+            'Cluster_Structural', barplot_xfont_size, splitting_strategy
+        )
+        # General Bar Plot
+        all_total, all_training, all_test, all_val = MASSAsplit.freq_clusters(
+            dataframe, directoryfile_output, extension_type,
+            'Cluster_General', barplot_xfont_size, splitting_strategy
+        )
+
+        # Verifying percentages:
+
+        # For biological domain:
+        bio_ok = returns_zero(bio_total, bio_test, bio_val)
+        # For physicochemical domain:
+        phch_ok = returns_zero(phch_total, phch_test, phch_val)
+        # For structural domain:
+        fp_ok = returns_zero(fp_total, fp_test, fp_val)
+        ok = [bio_ok, phch_ok, fp_ok]
+        max_iters += 1
+
+    # Write distribution information to log file:
+    bio_distr = 'Biological Distribution'
+    MASSAsplit.log_of_distributions(
+        bio_distr, bio_total, bio_training,
+        bio_test, bio_val, splitting_strategy,
+        write_log
+    )
+    phch_distr = 'Physicochemical Distribution'
+    MASSAsplit.log_of_distributions(
+        phch_distr, phch_total, phch_training,
+        phch_test, phch_val, splitting_strategy,
+        write_log
+    )
+    fp_distr = 'Structural (FP) Distribution'
+    MASSAsplit.log_of_distributions(
+        fp_distr, fp_total, fp_training,
+        fp_test, fp_val, splitting_strategy,
+        write_log
+    )
+    all_distr = 'General Distribution'
+    MASSAsplit.log_of_distributions(
+        all_distr, all_total, all_training,
+        all_test, all_val, splitting_strategy,
+        write_log
+    )
+
+    # Output management:
+    # It adds, for each molecule, the values of the calculated properties, the identifications of each cluster and which set the molecule belongs to.
+    out_name = working_directory + job_name
+    out_mols = MASSAmoloutput.output_file_mols(dataframe, out_name)
+
+    # Plot HCAs:
+    if flag_dendrogram == True:
+        print('\nGenerating dendrogram images. Please wait...')
+        MASSAcluster.hca_plot(
+            linkage_bio, names, leaves_cluster_bio,
+            cutoff_bio, 'bio', directoryfile_output,
+            extension_type, dendrogram_xfont_size, test_or_val_molecules
+        )  # Bio_Plot: Plot the HCA dendrogram
+        MASSAcluster.hca_plot(
+            linkage_phch, names, leaves_cluster_phch,
+            cutoff_phch, 'PhCh', directoryfile_output,
+            extension_type, dendrogram_xfont_size, test_or_val_molecules
+        )  # phch_Plot: Plot the HCA dendrogram
+        MASSAcluster.hca_plot(
+            linkage_fp, names, leaves_cluster_fp,
+            cutoff_fp, 'FP', directoryfile_output,
+            extension_type, dendrogram_xfont_size, test_or_val_molecules
+        )  # fp_Plot: Plot the HCA dendrogram
+
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    write_log.write(f'Completed! Elapsed time = {elapsed_time} s.')
+    write_log.close()
+    print(f'Completed! Elapsed time = {elapsed_time} s.')
+    return out_mols

{massa_algorithm-1.0.0.dist-info → massa_algorithm-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
-Name: MASSA-Algorithm
-Version: 1.0.0
+Name: MASSA_Algorithm
+Version: 2.0.1
 Summary: MASSA Algorithm is a Python package to separate data sets of molecules into training and test sets, considering the diversity of structural, physicochemical and biological characteristics of these molecules.
 Home-page: https://github.com/gcverissimo/MASSA_Algorithm
 Author: Gabriel Corrêa Veríssimo
@@ -43,7 +43,16 @@ MASSA Algorithm: A tool for separating data sets of molecules into training and
 
 
 ## Version 1.0.0
-Version 1.0.0 includes a code refactoring and adds the ability to split data into training, test, and validation subsets.
+- Version 1.0.0 includes a code refactoring and adds the ability to split data into training, test, and validation subsets.
+
+## Version 2.0.0
+- Version 2.0.0 introduces algorithm changes to better handle large datasets. Specifically, for datasets with 10,000 molecules or more, Hierarchical Clustering Analysis (HCA) is automatically replaced by MiniBatch K-Means. This is the new default behavior, but it can be controlled using the flag -a / --large-datasets. Since dendrograms are generated from HCA, dendrogram plotting is disabled for large datasets. In such cases, the flag -f / --dendrogram-plot is automatically disabled, regardless of user input.
+
+- This version introduces the ability to call the MASSA Algorithm from any Python script using MASSA_Algorithm.pyMASSA.py_massa(). However, instructions and documentation for doing so will be provided in future updates.
+
+- Version 2.0.0 also addresses the "NaN/None values in y" error, which was caused by duplicate molecule names. In this version, molecules with identical names are detected and renamed by appending their original index as a suffix to ensure uniqueness.
+
+- MASSA now preserves the input order of molecules in its output. However, molecules with chemical errors are skipped and excluded from the process. 
 
 ## Instalation
 MASSA Algorithm can be installed using pip:
@@ -69,6 +78,7 @@ python setup.py install
 * scipy: >= 1.6;
 * scikit-learn: > 0.24;
 * kmodes:¹ >= 0.10.
+
 Newer versions of the packages may also work, but they need to be tested.
     NOTE: Also tested on: scikit-learn: 1.7.0, scipy: 1.16.1, numpy: 2.0.2, rdkit: 2025.03.5.
 
@@ -135,7 +145,11 @@ Optional arguments include:
 * **Ignore Errors**: ```-e``` or ```--drop_errors```.
     * Ignore chemistry errors, saving only molecules without any errors.
 	* Options = true (ignore molecule errors and log them in the log file), false (treat molecule errors as fatal and fail the execution).
-    * Default = false.
+    * Default = true.
+* **Large Dataset**: ```-a``` or ```--large_dataset```.
+    * Switch the MASSA algorithm from HCA to MiniBatch-KMeans to handle large datasets.
+    * Options = auto (switches to KMeans if ≥ 10,000 molecules), false = use HCA (for smaller datasets), true = use KMeans (for large datasets).
+    * Default = auto.
 
 #### Command line help
 A full description of the arguments can also be viewed directly from the command line using the command:
@@ -164,3 +178,4 @@ Veríssimo, G. C.; Panteleão, S. Q.; Fernandes, P. O.; Gertrudes, J. C.; Kronen
 
 ## References
 [1]: DE VOS, N. J. kmodes categorical clustering library. https://github.com/nicodv/kmodes. 2015-2021.
+

massa_algorithm-2.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+MASSA_Algorithm/MASSA.py,sha256=2CxEnm4DokqHVQqJvLFd0Z33EsOGA5lS7kERwCYAkj0,13333
+MASSA_Algorithm/MASSAargs.py,sha256=rMlV-8ty-Cup7zufVaDY1QQv41azusgH_AwLJgxtEwc,12088
+MASSA_Algorithm/MASSAcluster.py,sha256=aHYRHeuHxzGyiW3KIT4K3cCBddgnjKZj1U63cNCTv6U,21316
+MASSA_Algorithm/MASSAdescriptors.py,sha256=g34_1CCJLwacj9qEfEyGe4Ci-5EKZc-DAHiFuEE8IC4,3066
+MASSA_Algorithm/MASSAextraction.py,sha256=S5v9MqwLmVrw6Pke7d_gvaKgIvt8tT3U5w-Y_6q6lKw,7084
+MASSA_Algorithm/MASSAlogos.py,sha256=c9EOJTAKTohUdSnYl30u2gogofUKtaTp02ZZls_5KaA,3629
+MASSA_Algorithm/MASSAmoloutput.py,sha256=X-gMvIQ7oEkpdXdPEI5FevncDgnM02X4C-oQrOoaejI,3643
+MASSA_Algorithm/MASSAod.py,sha256=C2pkFMo5icH9tKZxxsEuqjFMl8FyP7HlSaDqqKHYWHw,657
+MASSA_Algorithm/MASSAopen_files.py,sha256=DDPA-zKmxxsRPkaAz8pKG_j3LK3acyXQAGdL2Mxhc5Q,10708
+MASSA_Algorithm/MASSApreparation.py,sha256=PxKyZxvfZKt5lwrB2RtohwqWFLMzDPpscINZObYWqws,3476
+MASSA_Algorithm/MASSAsplit.py,sha256=Gdch0jZY_bLmKWFWNeZ-b-Zmt_HkrdpN1ej2fU_u5gQ,16460
+MASSA_Algorithm/__init__.py,sha256=yY3Tbs-t4HSl4I0Ev0RcHMnHU7SwljlWRveiRJkeCB8,10
+MASSA_Algorithm/pyMASSA.py,sha256=Ow1ykPhFhYzttwuunbyf7Sxfayn0aUr6vwdE2hTAcNU,14154
+massa_algorithm-2.0.1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+massa_algorithm-2.0.1.dist-info/METADATA,sha256=CH99grh3pyZJUQGkqcwTTKlc7dQLH7GIMXiEKJkGMHw,10496
+massa_algorithm-2.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+massa_algorithm-2.0.1.dist-info/entry_points.txt,sha256=oMtqswy07Di-w2uIYAEvenBKl0ovsr9AYm_yxn6LGtU,63
+massa_algorithm-2.0.1.dist-info/top_level.txt,sha256=IZyttJ20RSD8w9nAcaTHWAvkvxHV5FGaVGB7mDrw9Cc,16
+massa_algorithm-2.0.1.dist-info/RECORD,,

massa_algorithm-1.0.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-MASSA_Algorithm/MASSA.py,sha256=AKFJWuV43hrdFgNPSQjcg4J7NxEnu0Q0l67bxs_qDWo,11847
-MASSA_Algorithm/MASSAargs.py,sha256=5aq7Ne0v1xZmH59Pb5n_YiyErIT6Y0rd7fS6MnY_2jk,11163
-MASSA_Algorithm/MASSAcluster.py,sha256=yfZw1QE21NbDPv5pEeSzgCPMpOTPDQ2ZajvKrsBWDfA,13754
-MASSA_Algorithm/MASSAdescriptors.py,sha256=g34_1CCJLwacj9qEfEyGe4Ci-5EKZc-DAHiFuEE8IC4,3066
-MASSA_Algorithm/MASSAextraction.py,sha256=Xosjqwccbr1nXrgBXtRlUZrDFc05lFTtDUHWggbAC1k,5864
-MASSA_Algorithm/MASSAlogos.py,sha256=tlM8S91KBJNqZZHjVJ2UmQFARclIw7VgZR7c-YdAYPw,3532
-MASSA_Algorithm/MASSAmoloutput.py,sha256=41CvWOseca-LCUYn-tCITMY_RAmWd1f7z_9IX8c1jJo,3010
-MASSA_Algorithm/MASSAod.py,sha256=By50oZurFH7HJGtyRuvAhgxKNPATI15pRLVm0MYh9ww,595
-MASSA_Algorithm/MASSAopen_files.py,sha256=-naQ_m-p3ofZY2nZRNR2KsPxgS7vRqltma1Jp6W8raM,10729
-MASSA_Algorithm/MASSApreparation.py,sha256=Bck0TV-l_x2POGekqeXTRkQ4GvIXZ53iResBvSjbMrY,3543
-MASSA_Algorithm/MASSAsplit.py,sha256=_9i6g3y1NUurJQi9gKszowVeTFRYbhVntUu4EFkchsA,16363
-MASSA_Algorithm/__init__.py,sha256=yY3Tbs-t4HSl4I0Ev0RcHMnHU7SwljlWRveiRJkeCB8,10
-massa_algorithm-1.0.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-massa_algorithm-1.0.0.dist-info/METADATA,sha256=gY3NKENHoticjapmsz-Tb0vCwfWxR6nEysxAshzrGoY,9023
-massa_algorithm-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-massa_algorithm-1.0.0.dist-info/entry_points.txt,sha256=oMtqswy07Di-w2uIYAEvenBKl0ovsr9AYm_yxn6LGtU,63
-massa_algorithm-1.0.0.dist-info/top_level.txt,sha256=IZyttJ20RSD8w9nAcaTHWAvkvxHV5FGaVGB7mDrw9Cc,16
-massa_algorithm-1.0.0.dist-info/RECORD,,