SigProfilerAssignment 0.2.2__tar.gz → 0.2.3__tar.gz

{sigprofilerassignment-0.2.2/SigProfilerAssignment.egg-info → sigprofilerassignment-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SigProfilerAssignment
-Version: 0.2.2
+Version: 0.2.3
 Summary: Mutational signatures attribution and decomposition tool
 Home-page: https://github.com/AlexandrovLab/SigProfilerAssignment.git
 Author: Raviteja Vangara

{sigprofilerassignment-0.2.2 → sigprofilerassignment-0.2.3}/SigProfilerAssignment/decompose_subroutines.py

@@ -822,154 +822,234 @@ def make_final_solution(
         check_rule_negatives = []
         check_rule_penalty = 1.0
     exposureAvg = np.zeros([processAvg.shape[1], allgenomes.shape[1]])
+    
     if cosmic_sigs == True:
         denovo_exposureAvg = denovo_exposureAvg.T
-        with alive_bar(allgenomes.shape[1]) as bar:
+        # with alive_bar(allgenomes.shape[1]) as bar:
             # print("\n")
-            for r in range(allgenomes.shape[1]):
-                # print("Analyzing Sample => " , str(r+1))
-                bar()
-                if verbose == True:
-                    print(
-                        "\n\n\n\n\n                                        ################ Sample "
-                        + str(r + 1)
-                        + " #################"
-                    )
-
-                # Record information to lognote
-                lognote = open(
-                    layer_directory
-                    + "/Solution_Stats/"
-                    + solution_prefix
-                    + "_Signature_Assignment_log.txt",
-                    "a",
-                )
-                lognote.write(
-                    "\n\n\n\n\n                    ################ Sample "
+        for r in range(allgenomes.shape[1]):
+            # print("Analyzing Sample => " , str(r+1))
+            # bar()
+            if verbose == True:
+                print(
+                    "\n\n\n\n\n                                        ################ Sample "
                     + str(r + 1)
-                    + " #################\n"
+                    + " #################"
                 )
 
-                sample_exposure = np.array(denovo_exposureAvg.iloc[:, r])
-
-                init_sig_idx = np.nonzero(sample_exposure)[0]
-                init_sigs = denovo_exposureAvg.index[init_sig_idx]
+            # Record information to lognote
+            lognote = open(
+                layer_directory
+                + "/Solution_Stats/"
+                + solution_prefix
+                + "_Signature_Assignment_log.txt",
+                "a",
+            )
+            lognote.write(
+                "\n\n\n\n\n                    ################ Sample "
+                + str(r + 1)
+                + " #################\n"
+            )
 
-                init_decomposed_sigs = []
-                for de_novo_sig in init_sigs:
-                    init_decomposed_sigs = union(
-                        init_decomposed_sigs, list(attribution[de_novo_sig])
-                    )
+            sample_exposure = np.array(denovo_exposureAvg.iloc[:, r])
 
-                # print(init_decomposed_sigs)
-                init_decomposed_sigs_idx = get_indeces(allsigids, init_decomposed_sigs)
-                init_decomposed_sigs_idx.sort()
-                init_decomposed_sigs_idx = list(
-                    set().union(init_decomposed_sigs_idx, background_sigs)
-                )
-                # print(init_decomposed_sigs_idx)
+            init_sig_idx = np.nonzero(sample_exposure)[0]
+            init_sigs = denovo_exposureAvg.index[init_sig_idx]
 
-                # get the indices of the background sigs in the initial signatures
-                background_sig_idx = get_indeces(
-                    init_decomposed_sigs_idx, background_sigs
+            init_decomposed_sigs = []
+            for de_novo_sig in init_sigs:
+                init_decomposed_sigs = union(
+                    init_decomposed_sigs, list(attribution[de_novo_sig])
                 )
 
-                fit_signatures = processAvg[:, init_decomposed_sigs_idx]
-                # fit signatures
-                newExposure, newSimilarity = ss.fit_signatures(
-                    fit_signatures, allgenomes[:, r]
-                )
+            # print(init_decomposed_sigs)
+            init_decomposed_sigs_idx = get_indeces(allsigids, init_decomposed_sigs)
+            init_decomposed_sigs_idx.sort()
+            init_decomposed_sigs_idx = list(
+                set().union(init_decomposed_sigs_idx, background_sigs)
+            )
+            # print(init_decomposed_sigs_idx)
 
-                # create the exposureAvg vector
-                # print(init_decomposed_sigs_idx)
-                # print(newExposure)
-                for nonzero_idx, nozero_exp in zip(
-                    init_decomposed_sigs_idx, newExposure
-                ):
-                    exposureAvg[nonzero_idx, r] = nozero_exp
+            # get the indices of the background sigs in the initial signatures
+            background_sig_idx = get_indeces(
+                init_decomposed_sigs_idx, background_sigs
+            )
 
-                if pcawg_rule == True:
-                    maxmutation = np.sum(allgenomes[:, r])
-                    (
-                        exposureAvg[:, r],
-                        remove_distance,
-                        _,
-                    ) = ss.remove_all_single_signatures(
-                        processAvg,
-                        exposureAvg[:, r],
-                        allgenomes[:, r],
-                        metric="l2",
-                        verbose=False,
-                        cutoff=0.02,
-                    )
-                    # get the maximum value of the new Exposure
-                    maxcoef = max(list(exposureAvg[:, r]))
-                    idxmaxcoef = list(exposureAvg[:, r]).index(maxcoef)
-
-                    exposureAvg[:, r] = np.round(exposureAvg[:, r])
-
-                    # We may need to tweak the maximum value of the new exposure to keep the total number of mutation equal to the original mutations in a genome
-                    if np.sum(exposureAvg[:, r]) != maxmutation:
-                        exposureAvg[:, r][idxmaxcoef] = (
-                            round(exposureAvg[:, r][idxmaxcoef])
-                            + maxmutation
-                            - sum(exposureAvg[:, r])
-                        )
-                    # print(exposureAvg[:, r])
-                    # print("\n")
+            fit_signatures = processAvg[:, init_decomposed_sigs_idx]
+            # fit signatures
+            newExposure, newSimilarity = ss.fit_signatures(
+                fit_signatures, allgenomes[:, r]
+            )
 
-                else:
-                    if verbose == True:
-                        print(
-                            "############################# Initial Composition #################################### "
-                        )
-                        print(pd.DataFrame(exposureAvg[:, r], index=allsigids).T)
-                        print("L2%: ", newSimilarity)
+            # create the exposureAvg vector
+            # print(init_decomposed_sigs_idx)
+            # print(newExposure)
+            for nonzero_idx, nozero_exp in zip(
+                init_decomposed_sigs_idx, newExposure
+            ):
+                exposureAvg[nonzero_idx, r] = nozero_exp
+            
+            if pcawg_rule == True:
+                maxmutation = np.sum(allgenomes[:, r])
+                (
+                    exposureAvg[:, r],
+                    remove_distance,
+                    _,
+                ) = ss.remove_all_single_signatures(
+                    processAvg,
+                    exposureAvg[:, r],
+                    allgenomes[:, r],
+                    metric="l2",
+                    verbose=False,
+                    cutoff=0.02,
+                )
+                # get the maximum value of the new Exposure
+                # maxcoef = max(list(exposureAvg[:, r]))
+                # idxmaxcoef = list(exposureAvg[:, r]).index(maxcoef)
+
+                # exposureAvg[:, r] = np.round(exposureAvg[:, r])
+                exposureAvg[:, r] = ss.roundConserveSum(exposureAvg[:, r])
+
+                # We may need to tweak the maximum value of the new exposure to keep the total number of mutation equal to the original mutations in a genome
+                # if np.sum(exposureAvg[:, r]) != maxmutation:
+                #     exposureAvg[:, r][idxmaxcoef] = (
+                #         round(exposureAvg[:, r][idxmaxcoef])
+                #         + maxmutation
+                #         - sum(exposureAvg[:, r])
+                #     )
+                # print(exposureAvg[:, r])
+                # print("\n")
+                if np.sum(exposureAvg[:, r])!=round(maxmutation): raise ValueError("Mutation count not conserved")
 
-                    lognote.write(
-                        "############################# Initial Composition ####################################\n"
+            else:
+                if verbose == True:
+                    print(
+                        "############################# Initial Composition #################################### "
                     )
-                    exposures = pd.DataFrame(exposureAvg[:, r], index=allsigids).T
-                    lognote.write(
-                        "{}\n".format(
-                            exposures.iloc[:, exposures.to_numpy().nonzero()[1]]
-                        )
+                    print(pd.DataFrame(exposureAvg[:, r], index=allsigids).T)
+                    print("L2%: ", newSimilarity)
+
+                lognote.write(
+                    "############################# Initial Composition ####################################\n"
+                )
+                exposures = pd.DataFrame(exposureAvg[:, r], index=allsigids).T
+                lognote.write(
+                    "{}\n".format(
+                        exposures.iloc[:, exposures.to_numpy().nonzero()[1]]
                     )
-                    lognote.write(
-                        "L2 Error %: {}\nCosine Similarity: {}\n".format(
-                            round(newSimilarity, 2),
-                            round(
-                                cos_sim(
-                                    allgenomes[:, r],
-                                    np.dot(processAvg, exposureAvg[:, r]),
-                                ),
-                                2,
+                )
+                lognote.write(
+                    "L2 Error %: {}\nCosine Similarity: {}\n".format(
+                        round(newSimilarity, 2),
+                        round(
+                            cos_sim(
+                                allgenomes[:, r],
+                                np.dot(processAvg, exposureAvg[:, r]),
                             ),
-                        )
+                            2,
+                        ),
+                    )
+                )
+                # remove signatures
+                
+                (
+                    exposureAvg[:, r],
+                    L2dist,
+                    cosine_sim,
+                ) = ss.remove_all_single_signatures(
+                    processAvg,
+                    exposureAvg[:, r],
+                    allgenomes[:, r],
+                    metric="l2",
+                    solver="nnls",
+                    cutoff=initial_remove_penalty,
+                    background_sigs=[],
+                    verbose=False,
+                )
+                if verbose == True:
+                    print(
+                        "############################## Composition After Initial Remove ############################### "
+                    )
+                    print(pd.DataFrame(exposureAvg[:, r], index=allsigids).T)
+                    print("L2%: ", L2dist)
+                lognote.write(
+                    "############################## Composition After Initial Remove ###############################\n"
+                )
+                exposures = pd.DataFrame(exposureAvg[:, r], index=allsigids).T
+                lognote.write(
+                    "{}\n".format(
+                        exposures.iloc[:, exposures.to_numpy().nonzero()[1]]
+                    )
+                )
+                lognote.write(
+                    "L2 Error %: {}\nCosine Similarity: {}\n".format(
+                        round(L2dist, 2), round(cosine_sim, 2)
                     )
-                    # remove signatures
+                )
+                lognote.write(
+                    "\n############################## Performing Add-Remove Step ##############################\n"
+                )
+                # Close the Lognote file
+                lognote.close()
+
+                init_add_sig_idx = list(
+                    set().union(
+                        list(np.nonzero(exposureAvg[:, r])[0]), background_sigs
+                    )
+                )
+                # print(init_add_sig_idx)
+
+                # get the background_sig_idx for the add_remove function only for the decomposed solution:
+                if background_sigs != 0:  # in the decomposed solution only
+                    background_sig_idx = get_indeces(allsigids, ["SBS1", "SBS5"])
+
+                # if the there is no other signatures to be added on top the existing signatures
+                try:
                     (
+                        _,
                         exposureAvg[:, r],
                         L2dist,
-                        cosine_sim,
-                    ) = ss.remove_all_single_signatures(
+                        similarity,
+                        kldiv,
+                        correlation,
+                        cosine_similarity_with_four_signatures,
+                    ) = ss.add_remove_signatures(
                         processAvg,
-                        exposureAvg[:, r],
                         allgenomes[:, r],
                         metric="l2",
                         solver="nnls",
-                        cutoff=initial_remove_penalty,
-                        background_sigs=[],
+                        background_sigs=init_add_sig_idx,
+                        permanent_sigs=background_sig_idx,
+                        candidate_sigs="all",
+                        allsigids=allsigids,
+                        add_penalty=add_penalty,
+                        remove_penalty=remove_penalty,
+                        check_rule_negatives=check_rule_negatives,
+                        checkrule_penalty=check_rule_penalty,
+                        connected_sigs=connected_sigs,
+                        directory=layer_directory
+                        + "/Solution_Stats/"
+                        + solution_prefix
+                        + "_Signature_Assignment_log.txt",
                         verbose=False,
                     )
+
                     if verbose == True:
                         print(
-                            "############################## Composition After Initial Remove ############################### "
+                            "####################################### Composition After Add-Remove #######################################\n"
                         )
-                        print(pd.DataFrame(exposureAvg[:, r], index=allsigids).T)
+                        print(exposureAvg[:, r])
                         print("L2%: ", L2dist)
+                    # Recond the information in the log file
+                    lognote = open(
+                        layer_directory
+                        + "/Solution_Stats/"
+                        + solution_prefix
+                        + "_Signature_Assignment_log.txt",
+                        "a",
+                    )
                     lognote.write(
-                        "############################## Composition After Initial Remove ###############################\n"
+                        "####################################### Composition After Add-Remove #######################################\n"
                     )
                     exposures = pd.DataFrame(exposureAvg[:, r], index=allsigids).T
                     lognote.write(
@@ -979,88 +1059,12 @@ def make_final_solution(
                     )
                     lognote.write(
                         "L2 Error %: {}\nCosine Similarity: {}\n".format(
-                            round(L2dist, 2), round(cosine_sim, 2)
+                            round(L2dist, 2), round(similarity, 2)
                         )
                     )
-                    lognote.write(
-                        "\n############################## Performing Add-Remove Step ##############################\n"
-                    )
-                    # Close the Lognote file
                     lognote.close()
-
-                    init_add_sig_idx = list(
-                        set().union(
-                            list(np.nonzero(exposureAvg[:, r])[0]), background_sigs
-                        )
-                    )
-                    # print(init_add_sig_idx)
-
-                    # get the background_sig_idx for the add_remove function only for the decomposed solution:
-                    if background_sigs != 0:  # in the decomposed solution only
-                        background_sig_idx = get_indeces(allsigids, ["SBS1", "SBS5"])
-
-                    # if the there is no other signatures to be added on top the existing signatures
-                    try:
-                        (
-                            _,
-                            exposureAvg[:, r],
-                            L2dist,
-                            similarity,
-                            kldiv,
-                            correlation,
-                            cosine_similarity_with_four_signatures,
-                        ) = ss.add_remove_signatures(
-                            processAvg,
-                            allgenomes[:, r],
-                            metric="l2",
-                            solver="nnls",
-                            background_sigs=init_add_sig_idx,
-                            permanent_sigs=background_sig_idx,
-                            candidate_sigs="all",
-                            allsigids=allsigids,
-                            add_penalty=add_penalty,
-                            remove_penalty=remove_penalty,
-                            check_rule_negatives=check_rule_negatives,
-                            checkrule_penalty=check_rule_penalty,
-                            connected_sigs=connected_sigs,
-                            directory=layer_directory
-                            + "/Solution_Stats/"
-                            + solution_prefix
-                            + "_Signature_Assignment_log.txt",
-                            verbose=False,
-                        )
-
-                        if verbose == True:
-                            print(
-                                "####################################### Composition After Add-Remove #######################################\n"
-                            )
-                            print(exposureAvg[:, r])
-                            print("L2%: ", L2dist)
-                        # Recond the information in the log file
-                        lognote = open(
-                            layer_directory
-                            + "/Solution_Stats/"
-                            + solution_prefix
-                            + "_Signature_Assignment_log.txt",
-                            "a",
-                        )
-                        lognote.write(
-                            "####################################### Composition After Add-Remove #######################################\n"
-                        )
-                        exposures = pd.DataFrame(exposureAvg[:, r], index=allsigids).T
-                        lognote.write(
-                            "{}\n".format(
-                                exposures.iloc[:, exposures.to_numpy().nonzero()[1]]
-                            )
-                        )
-                        lognote.write(
-                            "L2 Error %: {}\nCosine Similarity: {}\n".format(
-                                round(L2dist, 2), round(similarity, 2)
-                            )
-                        )
-                        lognote.close()
-                    except:
-                        pass
+                except:
+                    pass
 
     else:
         # when refilt de_novo_signatures

{sigprofilerassignment-0.2.2 → sigprofilerassignment-0.2.3}/SigProfilerAssignment/decomposition.py

@@ -963,8 +963,10 @@ def spa_analyze(
             cosmic_sig_ref = processAvg.copy(deep=True)
             cosmic_sig_ref.reset_index(inplace=True)
         else:
+            
             try:
                 processAvg = pd.read_csv(signature_database, sep="\t", index_col=0)
+                
             except:
                 sys.exit(
                     "Something is wrong with the format of signature database, Pass a text file of signatures in the format of COSMIC sig database"

{sigprofilerassignment-0.2.2 → sigprofilerassignment-0.2.3}/SigProfilerAssignment/single_sample.py

@@ -102,6 +102,21 @@ def get_changed_background_sig_idx(exposures, background_sigs):
 
     return background_sigs
 
+def roundConserveSum(x):
+
+    # Total to be conserved
+    total = np.round(np.sum(x))
+
+    # Round to nearest integer above
+    x_out = np.ceil(x)
+
+    # Order integer residuals
+    order = np.argsort(x-x_out)
+
+    # Take one off first n residuals to correct total
+    x_out[order[:int(np.sum(x_out)-total+1e-10)]] -= 1
+
+    return x_out
 
 # Fit signatures
 def fit_signatures(W, genome, metric="l2"):
@@ -132,16 +147,21 @@ def fit_signatures(W, genome, metric="l2"):
     newExposure = list(solution)
 
     # get the maximum value of the new Exposure
-    maxcoef = max(newExposure)
-    idxmaxcoef = newExposure.index(maxcoef)
+    # maxcoef = max(newExposure)
+    # idxmaxcoef = newExposure.index(maxcoef)
 
-    newExposure = np.round(newExposure)
+    # newExposure = np.round(newExposure)
 
     # We may need to tweak the maximum value of the new exposure to keep the total number of mutation equal to the original mutations in a genome
-    if np.sum(newExposure) != maxmutation:
-        newExposure[idxmaxcoef] = (
-            round(newExposure[idxmaxcoef]) + maxmutation - sum(newExposure)
-        )
+    # import pdb; pdb.set_trace()
+    newExposure = roundConserveSum(newExposure)
+    # # if np.sum(newExposure) <= maxmutation:
+    # newExposure[idxmaxcoef] = (
+    #     round(newExposure[idxmaxcoef]) + maxmutation - sum(newExposure)
+    #     )
+    # # else:
+    # #     newExposure = np.round()
+    if np.sum(newExposure)!=maxmutation: raise ValueError("Mutation count not conserved")
 
     if metric == "cosine":
         newSimilarity = cos_sim(genome, est_genome)
@@ -492,8 +512,9 @@ def remove_all_single_signatures(
         if verbose == True:
             print("originalSimilarity", originalSimilarity)
     # make the original exposures of specific sample round
-    oldExposures = np.round(H)
-
+    # oldExposures = np.round(H)
+    oldExposures = roundConserveSum(H)
+    # import pdb; pdb.set_trace()
     # set the flag for the while loop
     if len(oldExposures[np.nonzero(oldExposures)]) > 1:
         Flag = True
@@ -606,6 +627,8 @@ def remove_all_single_signatures(
             # newExposure[idxmaxcoef] = round(newExposure[idxmaxcoef])+maxmutation-sum(newExposure)
 
             newExposure = np.array(newExposure)
+            
+
 
             if verbose == True:
                 # print(newExposure)
@@ -667,6 +690,7 @@ def remove_all_single_signatures(
 
     # print ("The final selection is {}".format(successList))
 
+
     if len(successList[1]) == 0:
         successList = [0.0, oldExposures, originalSimilarity]
 
@@ -696,7 +720,7 @@ def remove_all_single_signatures_pool(indices, W, exposures, totoalgenomes):
     originalSimilarity = cos_sim(genomes, np.dot(W, H))
     # make the original exposures of specific sample round
     oldExposures = np.round(H)
-
+    oldExposures = roundConserveSum(H)
     # set the flag for the while loop
     if len(oldExposures[np.nonzero(oldExposures)]) > 1:
         Flag = True
@@ -774,11 +798,13 @@ def remove_all_single_signatures_pool(indices, W, exposures, totoalgenomes):
             idxmaxcoef = newExposure.index(maxcoef)
 
             newExposure = np.round(newExposure)
+            newExposure = roundConserveSum(newExposure)
+            if np.sum(newExposure)!=maxmutation: raise ValueError("Mutation count not conserved")
 
-            if np.sum(newExposure) != maxmutation:
-                newExposure[idxmaxcoef] = (
-                    round(newExposure[idxmaxcoef]) + maxmutation - sum(newExposure)
-                )
+            # if np.sum(newExposure) != maxmutation:
+            #     newExposure[idxmaxcoef] = (
+            #         round(newExposure[idxmaxcoef]) + maxmutation - sum(newExposure)
+            #     )
 
             newSample = np.dot(W, newExposure)
             newSimilarity = cos_sim(genomes, newSample)
@@ -970,17 +996,19 @@ def add_remove_signatures(
             break
 
     # get the maximum value of the new Exposure
-    maxcoef = np.max(finalactivities)
-    idxmaxcoef = list(finalactivities).index(maxcoef)
+    # maxcoef = np.max(finalactivities)
+    # idxmaxcoef = list(finalactivities).index(maxcoef)
 
-    finalactivities = np.round(finalactivities)
+    # finalactivities = np.round(finalactivities)
+    finalactivities = roundConserveSum(finalactivities)
 
     # We may need to tweak the maximum value of the new exposure to keep the total number of mutation equal to the original mutations in a genome
-    if np.sum(finalactivities) != maxmutation:
-        finalactivities[idxmaxcoef] = (
-            round(finalactivities[idxmaxcoef]) + maxmutation - np.sum(finalactivities)
-        )
-
+    # if np.sum(finalactivities) != maxmutation:
+    #     finalactivities[idxmaxcoef] = (
+    #         round(finalactivities[idxmaxcoef]) + maxmutation - np.sum(finalactivities)
+    #     )
+    if np.sum(finalactivities)!=round(maxmutation): raise ValueError("Mutation count not conserved")
+    
     if verbose:
         print("\n########################## Final ###########################")
         print(background_sigs)

sigprofilerassignment-0.2.3/SigProfilerAssignment/version.py

@@ -0,0 +1,7 @@
+
+# THIS FILE IS GENERATED FROM SigProfilerAssignment SETUP.PY
+short_version = '0.2.3'
+version = '0.2.3'
+Update = 'v0.2.3:  Improved rounding strategy for handling low mutation counts'
+
+    

{sigprofilerassignment-0.2.2 → sigprofilerassignment-0.2.3/SigProfilerAssignment.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SigProfilerAssignment
-Version: 0.2.2
+Version: 0.2.3
 Summary: Mutational signatures attribution and decomposition tool
 Home-page: https://github.com/AlexandrovLab/SigProfilerAssignment.git
 Author: Raviteja Vangara

{sigprofilerassignment-0.2.2 → sigprofilerassignment-0.2.3}/setup.py

@@ -6,7 +6,7 @@ import os
 if os.path.exists("dist"):
     shutil.rmtree("dist")
 
-VERSION = "0.2.2"
+VERSION = "0.2.3"
 
 
 def write_version_py(filename="SigProfilerAssignment/version.py"):
@@ -15,9 +15,8 @@ def write_version_py(filename="SigProfilerAssignment/version.py"):
 # THIS FILE IS GENERATED FROM SigProfilerAssignment SETUP.PY
 short_version = '%(version)s'
 version = '%(version)s'
-Update = 'v0.2.2: Fix bug in CLI returning non-zero exit code'
+Update = 'v0.2.3:  Improved rounding strategy for handling low mutation counts'
 
-    
     """
     fh = open(filename, "w")
     fh.write(

sigprofilerassignment-0.2.2/SigProfilerAssignment/version.py

@@ -1,8 +0,0 @@
-
-# THIS FILE IS GENERATED FROM SigProfilerAssignment SETUP.PY
-short_version = '0.2.2'
-version = '0.2.2'
-Update = 'v0.2.2: Fix bug in CLI returning non-zero exit code'
-
-    
-