Mercurial > repos > sagun98 > micropita
comparison galaxy_micropita/MicroPITA.py @ 3:8fb4630ab314 draft default tip
Uploaded
author | sagun98 |
---|---|
date | Thu, 03 Jun 2021 17:07:36 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
2:1c5736dc85ab | 3:8fb4630ab314 |
---|---|
1 #!/usr/bin/env python | |
2 """ | |
3 Author: Timothy Tickle | |
4 Description: Class to Run analysis for the microPITA paper | |
5 """ | |
6 | |
7 ##################################################################################### | |
8 #Copyright (C) <2012> | |
9 # | |
10 #Permission is hereby granted, free of charge, to any person obtaining a copy of | |
11 #this software and associated documentation files (the "Software"), to deal in the | |
12 #Software without restriction, including without limitation the rights to use, copy, | |
13 #modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, | |
14 #and to permit persons to whom the Software is furnished to do so, subject to | |
15 #the following conditions: | |
16 # | |
17 #The above copyright notice and this permission notice shall be included in all copies | |
18 #or substantial portions of the Software. | |
19 # | |
20 #THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, | |
21 #INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A | |
22 #PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT | |
23 #HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
24 #OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE | |
25 #SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
26 ##################################################################################### | |
27 | |
28 __author__ = "Timothy Tickle" | |
29 __copyright__ = "Copyright 2012" | |
30 __credits__ = ["Timothy Tickle"] | |
31 __license__ = "MIT" | |
32 __maintainer__ = "Timothy Tickle" | |
33 __email__ = "ttickle@sph.harvard.edu" | |
34 __status__ = "Development" | |
35 | |
36 import sys | |
37 import argparse | |
38 from src.breadcrumbs.src.AbundanceTable import AbundanceTable | |
39 from src.breadcrumbs.src.ConstantsBreadCrumbs import ConstantsBreadCrumbs | |
40 from src.breadcrumbs.src.Metric import Metric | |
41 from src.breadcrumbs.src.KMedoids import Kmedoids | |
42 from src.breadcrumbs.src.MLPYDistanceAdaptor import MLPYDistanceAdaptor | |
43 from src.breadcrumbs.src.SVM import SVM | |
44 from src.breadcrumbs.src.UtilityMath import UtilityMath | |
45 | |
46 from src.ConstantsMicropita import ConstantsMicropita | |
47 import csv | |
48 import logging | |
49 import math | |
50 import mlpy | |
51 import numpy as np | |
52 import operator | |
53 import os | |
54 import random | |
55 import scipy.cluster.hierarchy as hcluster | |
56 import scipy.spatial.distance | |
57 from types import * | |
58 | |
59 class MicroPITA: | |
60 """ | |
61 Selects samples from a first tier of a multi-tiered study to be used in a second tier. | |
62 Different methods can be used for selection. | |
63 The expected input is an abundance table (and potentially a text file of targeted features, | |
64 if using the targeted features option). Output is a list of samples exhibiting the | |
65 characteristics of interest. | |
66 """ | |
67 | |
68 #Constants | |
69 #Diversity metrics Alpha | |
70 c_strInverseSimpsonDiversity = Metric.c_strInvSimpsonDiversity | |
71 c_strChao1Diversity = Metric.c_strChao1Diversity | |
72 | |
73 #Diversity metrics Beta | |
74 c_strBrayCurtisDissimilarity = Metric.c_strBrayCurtisDissimilarity | |
75 | |
76 #Additive inverses of diversity metrics beta | |
77 c_strInvBrayCurtisDissimilarity = Metric.c_strInvBrayCurtisDissimilarity | |
78 | |
79 #Technique Names | |
80 ConstantsMicropita.c_strDiversity2 = ConstantsMicropita.c_strDiversity+"_C" | |
81 | |
82 #Targeted feature settings | |
83 c_strTargetedRanked = ConstantsMicropita.c_strTargetedRanked | |
84 c_strTargetedAbundance = ConstantsMicropita.c_strTargetedAbundance | |
85 | |
86 #Technique groupings | |
87 # c_lsDiversityMethods = [ConstantsMicropita.c_strDiversity,ConstantsMicropita.c_strDiversity2] | |
88 | |
89 #Converts ecology metrics into standardized method selection names | |
90 dictConvertAMetricDiversity = {c_strInverseSimpsonDiversity:ConstantsMicropita.c_strDiversity, c_strChao1Diversity:ConstantsMicropita.c_strDiversity2} | |
91 # dictConvertMicroPITAToAMetric = {ConstantsMicropita.c_strDiversity:c_strInverseSimpsonDiversity, ConstantsMicropita.c_strDiversity2:c_strChao1Diversity} | |
92 dictConvertBMetricToMethod = {c_strBrayCurtisDissimilarity:ConstantsMicropita.c_strRepresentative} | |
93 dictConvertInvBMetricToMethod = {c_strBrayCurtisDissimilarity:ConstantsMicropita.c_strExtreme} | |
94 | |
95 #Linkage used in the Hierarchical clustering | |
96 c_strHierarchicalClusterMethod = 'average' | |
97 | |
98 ####Group 1## Diversity | |
99 #Testing: Happy path Testing (8) | |
100 def funcGetTopRankedSamples(self, lldMatrix = None, lsSampleNames = None, iTopAmount = None): | |
101 """ | |
102 Given a list of lists of measurements, for each list the indices of the highest values are returned. If lsSamplesNames is given | |
103 it is treated as a list of string names that is in the order of the measurements in each list. Indices are returned or the sample | |
104 names associated with the indices. | |
105 | |
106 :param lldMatrix: List of lists [[value,value,value,value],[value,value,value,value]]. | |
107 :type: List of lists List of measurements. Each list is a different measurement. Each measurement in positionally related to a sample. | |
108 :param lsSampleNames: List of sample names positionally related (the same) to each list (Optional). | |
109 :type: List of strings List of strings. | |
110 :param iTopAmount: The amount of top measured samples (assumes the higher measurements are better). | |
111 :type: integer Integer amount of sample names/ indices to return. | |
112 :return List: List of samples to be selected. | |
113 """ | |
114 topRankListRet = [] | |
115 for rowMetrics in lldMatrix: | |
116 #Create 2 d array to hold value and index and sort | |
117 liIndexX = [rowMetrics,range(len(rowMetrics))] | |
118 liIndexX[1].sort(key = liIndexX[0].__getitem__,reverse = True) | |
119 | |
120 if lsSampleNames: | |
121 topRankListRet.append([lsSampleNames[iIndex] for iIndex in liIndexX[1][:iTopAmount]]) | |
122 else: | |
123 topRankListRet.append(liIndexX[1][:iTopAmount]) | |
124 | |
125 return topRankListRet | |
126 | |
127 ####Group 2## Representative Dissimilarity | |
128 #Testing: Happy path tested 1 | |
129 def funcGetCentralSamplesByKMedoids(self, npaMatrix=None, sMetric=None, lsSampleNames=None, iNumberSamplesReturned=0, istmBetaMatrix=None, istrmTree=None, istrmEnvr=None): | |
130 """ | |
131 Gets centroid samples by k-medoids clustering of a given matrix. | |
132 | |
133 :param npaMatrix: Numpy array where row=features and columns=samples | |
134 :type: Numpy array Abundance Data. | |
135 :param sMetric: String name of beta metric used as the distance metric. | |
136 :type: String String name of beta metric. | |
137 :param lsSampleNames: The names of the sample | |
138 :type: List List of strings | |
139 :param iNumberSamplesReturned: Number of samples to return, each will be a centroid of a sample. | |
140 :type: Integer Number of samples to return | |
141 :return List: List of selected samples. | |
142 :param istmBetaMatrix: File with beta-diversity matrix | |
143 :type: File stream or file path string | |
144 """ | |
145 | |
146 #Count of how many rows | |
147 sampleCount = npaMatrix.shape[0] | |
148 if iNumberSamplesReturned > sampleCount: | |
149 logging.error("MicroPITA.funcGetCentralSamplesByKMedoids:: There are not enough samples to return the amount of samples specified. Return sample count = "+str(iNumberSamplesReturned)+". Sample number = "+str(sampleCount)+".") | |
150 return False | |
151 | |
152 #If the cluster count is equal to the sample count return all samples | |
153 if sampleCount == iNumberSamplesReturned: | |
154 return list(lsSampleNames) | |
155 | |
156 #Get distance matrix | |
157 distanceMatrix=scipy.spatial.distance.squareform(Metric.funcReadMatrixFile(istmMatrixFile=istmBetaMatrix,lsSampleOrder=lsSampleNames)[0]) if istmBetaMatrix else Metric.funcGetBetaMetric(npadAbundancies=npaMatrix, sMetric=sMetric, istrmTree=istrmTree, istrmEnvr=istrmEnvr, lsSampleOrder=lsSampleNames) | |
158 if type(distanceMatrix) is BooleanType: | |
159 logging.error("MicroPITA.funcGetCentralSamplesByKMedoids:: Could not read in the supplied distance matrix, returning false.") | |
160 return False | |
161 | |
162 # Handle unifrac output | |
163 if sMetric in [Metric.c_strUnifracUnweighted,Metric.c_strUnifracWeighted]: | |
164 distanceMatrix = distanceMatrix[0] | |
165 | |
166 #Log distance matrix | |
167 logging.debug("MicroPITA.funcGetCentralSamplesByKMedoids:: Distance matrix for representative selection using metric="+str(sMetric)) | |
168 | |
169 distance = MLPYDistanceAdaptor(npaDistanceMatrix=distanceMatrix, fIsCondensedMatrix=True) | |
170 | |
171 #Create object to determine clusters/medoids | |
172 medoidsMaker = Kmedoids(k=iNumberSamplesReturned, dist=distance) | |
173 #medoidsData includes(1d numpy array, medoids indexes; | |
174 # 1d numpy array, non-medoids indexes; | |
175 # 1d numpy array, cluster membership for non-medoids; | |
176 # double, cost of configuration) | |
177 #npaMatrix is samples x rows | |
178 #Build a matrix of lists of indicies to pass to the distance matrix | |
179 lliIndicesMatrix = [[iIndexPosition] for iIndexPosition in xrange(0,len(npaMatrix))] | |
180 medoidsData = medoidsMaker.compute(np.array(lliIndicesMatrix)) | |
181 logging.debug("MicroPITA.funcGetCentralSamplesByKMedoids:: Results from the kmedoid method in representative selection:") | |
182 logging.debug(str(medoidsData)) | |
183 | |
184 #If returning the same amount of clusters and samples | |
185 #Return centroids | |
186 selectedIndexes = medoidsData[0] | |
187 return [lsSampleNames[selectedIndexes[index]] for index in xrange(0,iNumberSamplesReturned)] | |
188 | |
189 ####Group 3## Highest Dissimilarity | |
190 #Testing: Happy path tested | |
191 def funcSelectExtremeSamplesFromHClust(self, strBetaMetric, npaAbundanceMatrix, lsSampleNames, iSelectSampleCount, istmBetaMatrix=None, istrmTree=None, istrmEnvr=None): | |
192 """ | |
193 Select extreme samples from HClustering. | |
194 | |
195 :param strBetaMetric: The beta metric to use for distance matrix generation. | |
196 :type: String The name of the beta metric to use. | |
197 :param npaAbundanceMatrix: Numpy array where row=samples and columns=features. | |
198 :type: Numpy Array Abundance data. | |
199 :param lsSampleNames: The names of the sample. | |
200 :type: List List of strings. | |
201 :param iSelectSampleCount: Number of samples to select (return). | |
202 :type: Integer Integer number of samples returned. | |
203 :return Samples: List of samples. | |
204 :param istmBetaMatrix: File with beta-diversity matrix | |
205 :type: File stream or file path string | |
206 """ | |
207 | |
208 #If they want all the sample count, return all sample names | |
209 iSampleCount=len(npaAbundanceMatrix[:,0]) | |
210 if iSelectSampleCount==iSampleCount: | |
211 return lsSampleNames | |
212 | |
213 #Holds the samples to be returned | |
214 lsReturnSamplesRet = [] | |
215 | |
216 #Generate beta matrix | |
217 #Returns condensed matrix | |
218 tempDistanceMatrix = scipy.spatial.distance.squareform(Metric.funcReadMatrixFile(istmMatrixFile=istmBetaMatrix,lsSampleOrder=lsSampleNames)[0]) if istmBetaMatrix else Metric.funcGetBetaMetric(npadAbundancies=npaAbundanceMatrix, sMetric=strBetaMetric, istrmTree=istrmTree, istrmEnvr=istrmEnvr, lsSampleOrder=lsSampleNames, fAdditiveInverse = True) | |
219 | |
220 if strBetaMetric in [Metric.c_strUnifracUnweighted,Metric.c_strUnifracWeighted]: | |
221 tempDistanceMatrix = tempDistanceMatrix[0] | |
222 | |
223 if type(tempDistanceMatrix) is BooleanType: | |
224 logging.error("MicroPITA.funcSelectExtremeSamplesFromHClust:: Could not read in the supplied distance matrix, returning false.") | |
225 return False | |
226 | |
227 if istmBetaMatrix: | |
228 tempDistanceMatrix = 1-tempDistanceMatrix | |
229 | |
230 #Feed beta matrix to linkage to cluster | |
231 #Send condensed matrix | |
232 linkageMatrix = hcluster.linkage(tempDistanceMatrix, method=self.c_strHierarchicalClusterMethod) | |
233 | |
234 #Extract cluster information from dendrogram | |
235 #The linakge matrix is of the form | |
236 #[[int1 int2 doube int3],...] | |
237 #int1 and int1 are the paired samples indexed at 0 and up. | |
238 #each list is an entry for a branch that is number starting with the first | |
239 #list being sample count index + 1 | |
240 #each list is then named by an increment as they appear | |
241 #this means that if a number is in the list and is = sample count or greater it is not | |
242 #terminal and is instead a branch. | |
243 #This method just takes the lowest metric measurement (highest distance pairs/clusters) | |
244 #Works much better than the original technique | |
245 #get total number of samples | |
246 | |
247 iCurrentSelectCount = 0 | |
248 for row in linkageMatrix: | |
249 #Get nodes ofthe lowest pairing (so the furthest apart pair) | |
250 iNode1 = int(row[0]) | |
251 iNode2 = int(row[1]) | |
252 #Make sure the nodes are a terminal node (sample) and not a branch in the dendrogram | |
253 #The branching in the dendrogram will start at the number of samples and increment higher. | |
254 #Add each of the pair one at a time breaking when enough samples are selected. | |
255 if iNode1<iSampleCount: | |
256 lsReturnSamplesRet.append(lsSampleNames[iNode1]) | |
257 iCurrentSelectCount = iCurrentSelectCount + 1 | |
258 if iCurrentSelectCount == iSelectSampleCount: | |
259 break | |
260 if iNode2<iSampleCount: | |
261 lsReturnSamplesRet.append(lsSampleNames[iNode2]) | |
262 iCurrentSelectCount = iCurrentSelectCount + 1 | |
263 if iCurrentSelectCount == iSelectSampleCount: | |
264 break | |
265 | |
266 #Return selected samples | |
267 return lsReturnSamplesRet | |
268 | |
269 ####Group 4## Rank Average of user Defined Taxa | |
270 #Testing: Happy Path Tested | |
271 def funcGetAverageAbundanceSamples(self, abndTable, lsTargetedFeature, fRank=False): | |
272 """ | |
273 Averages feature abundance or ranked abundance. Expects a column 0 of taxa id that is skipped. | |
274 | |
275 :param abndTable: Abundance Table to analyse | |
276 :type: AbundanceTable Abundance Table | |
277 :param lsTargetedFeature: String names | |
278 :type: list list of string names of features (bugs) which are measured after ranking against the full sample | |
279 :param fRank: Indicates to rank the abundance before getting the average abundance of the features (default false) | |
280 :type: boolean Flag indicating ranking abundance before calculating average feature measurement (false= no ranking) | |
281 :return List of lists or boolean: List of lists or False on error. One internal list per sample indicating the sample, | |
282 feature average abundance or ranked abundance. Lists will already be sorted. | |
283 For not Ranked [[sample,average abundance of selected feature,1]] | |
284 For Ranked [[sample,average ranked abundance, average abundance of selected feature]] | |
285 Error Returns false | |
286 """ | |
287 | |
288 llAbundance = abndTable.funcGetAverageAbundancePerSample(lsTargetedFeature) | |
289 if not llAbundance: | |
290 logging.error("MicroPITA.funcGetAverageAbundanceSamples:: Could not get average abundance, returned false. Make sure the features (bugs) are spelled correctly and in the abundance table.") | |
291 return False | |
292 #Add a space for ranking if needed | |
293 #Not ranked will be [[sSample,average abundance,1]] | |
294 #(where 1 will not discriminant ties if used in later functions, so this generalizes) | |
295 #Ranked will be [[sSample, average rank, average abundance]] | |
296 llRetAbundance = [[llist[0],-1,llist[1]] for llist in llAbundance] | |
297 #Rank if needed | |
298 if fRank: | |
299 abndRanked = abndTable.funcRankAbundance() | |
300 if abndRanked == None: | |
301 logging.error("MicroPITA.funcGetAverageAbundanceSamples:: Could not rank the abundance table, returned false.") | |
302 return False | |
303 llRetRank = abndRanked.funcGetAverageAbundancePerSample(lsTargetedFeature) | |
304 if not llRetRank: | |
305 logging.error("MicroPITA.funcGetAverageAbundanceSamples:: Could not get average ranked abundance, returned false. Make sure the features (bugs) are spelled correctly and in the abundance table.") | |
306 return False | |
307 dictRanks = dict(llRetRank) | |
308 llRetAbundance = [[a[0],dictRanks[a[0]],a[2]] for a in llRetAbundance] | |
309 | |
310 #Sort first for ties and then for the main feature | |
311 if not fRank or ConstantsMicropita.c_fBreakRankTiesByDiversity: | |
312 llRetAbundance = sorted(llRetAbundance, key = lambda sampleData: sampleData[2], reverse = not fRank) | |
313 if fRank: | |
314 llRetAbundance = sorted(llRetAbundance, key = lambda sampleData: sampleData[1], reverse = not fRank) | |
315 return llRetAbundance | |
316 | |
317 #Testing: Happy Path Tested | |
318 def funcSelectTargetedTaxaSamples(self, abndMatrix, lsTargetedTaxa, iSampleSelectionCount, sMethod = ConstantsMicropita.lsTargetedFeatureMethodValues[0]): | |
319 """ | |
320 Selects samples with the highest ranks or abundance of targeted features. | |
321 If ranked, select the highest abundance for tie breaking | |
322 | |
323 :param abndMatrix: Abundance table to analyse | |
324 :type: AbundanceTable Abundance table | |
325 :param lsTargetedTaxa: List of features | |
326 :type: list list of strings | |
327 :param iSampleSelectionCount: Number of samples to select | |
328 :type: integer integer | |
329 :param sMethod: Method to select targeted features | |
330 :type: string String (Can be values found in ConstantsMicropita.lsTargetedFeatureMethodValues) | |
331 :return List of strings: List of sample names which were selected | |
332 List of strings Empty list is returned on an error. | |
333 """ | |
334 | |
335 #Check data | |
336 if(len(lsTargetedTaxa) < 1): | |
337 logging.error("MicroPITA.funcSelectTargetedTaxaSamples. Taxa defined selection was requested but no features were given.") | |
338 return [] | |
339 | |
340 lsTargetedSamples = self.funcGetAverageAbundanceSamples(abndTable=abndMatrix, lsTargetedFeature=lsTargetedTaxa, | |
341 fRank=sMethod.lower() == self.c_strTargetedRanked.lower()) | |
342 #If an error occured or the key word for the method was not recognized | |
343 if lsTargetedSamples == False: | |
344 logging.error("MicroPITA.funcSelectTargetedTaxaSamples:: Was not able to select for the features given. So targeted feature selection was performed. Check to make sure the features are spelled correctly and exist in the abundance file.") | |
345 return [] | |
346 | |
347 #Select from results | |
348 return [sSample[0] for sSample in lsTargetedSamples[:iSampleSelectionCount]] | |
349 | |
350 ####Group 5## Random | |
351 #Testing: Happy path Tested | |
352 def funcGetRandomSamples(self, lsSamples=None, iNumberOfSamplesToReturn=0): | |
353 """ | |
354 Returns random sample names of the number given. No replacement. | |
355 | |
356 :param lsSamples: List of sample names | |
357 :type: list list of strings | |
358 :param iNumberOfSamplesToReturn: Number of samples to select | |
359 :type: integer integer. | |
360 :return List: List of selected samples (strings). | |
361 """ | |
362 | |
363 #Input matrix sample count | |
364 sampleCount = len(lsSamples) | |
365 | |
366 #Return the full matrix if they ask for a return matrix where length == original | |
367 if(iNumberOfSamplesToReturn >= sampleCount): | |
368 return lsSamples | |
369 | |
370 #Get the random indices for the sample (without replacement) | |
371 liRandomIndices = random.sample(range(sampleCount), iNumberOfSamplesToReturn) | |
372 | |
373 #Create a boolean array of if indexes are to be included in the reduced array | |
374 return [sSample for iIndex, sSample in enumerate(lsSamples) if iIndex in liRandomIndices] | |
375 | |
376 #Happy path tested (case 3) | |
377 def funcGetAveragePopulation(self, abndTable, lfCompress): | |
378 """ | |
379 Get the average row per column in the abndtable. | |
380 | |
381 :param abndTable: AbundanceTable of data to be averaged | |
382 :type: AbudanceTable | |
383 :param lfCompress: List of boolean flags (false means to remove sample before averaging | |
384 :type: List of floats | |
385 :return List of doubles: | |
386 """ | |
387 if sum(lfCompress) == 0: | |
388 return [] | |
389 | |
390 #Get the average populations | |
391 lAverageRet = [] | |
392 | |
393 for sFeature in abndTable.funcGetAbundanceCopy(): | |
394 sFeature = list(sFeature)[1:] | |
395 sFeature=np.compress(lfCompress,sFeature,axis=0) | |
396 lAverageRet.append(sum(sFeature)/float(len(sFeature))) | |
397 return lAverageRet | |
398 | |
399 #Happy path tested (2 cases) | |
400 def funcGetDistanceFromAverage(self, abndTable,ldAverage,lsSamples,lfSelected): | |
401 """ | |
402 Given an abundance table and an average sample, this returns the distance of each sample | |
403 (measured using brays-curtis dissimilarity) from the average. | |
404 The distances are reduced by needing to be in the lsSamples and being a true in the lfSelected | |
405 (which is associated with the samples in the order of the samples in the abundance table; | |
406 use abundancetable.funcGetSampleNames() to see the order if needed). | |
407 | |
408 :param abndTable: Abundance table holding the data to be analyzed. | |
409 :type: AbundanceTable | |
410 :param ldAverage: Average population (Average features of the abundance table of samples) | |
411 :type: List of doubles which represent the average population | |
412 :param lsSamples: These are the only samples used in the analysis | |
413 :type: List of strings (sample ids) | |
414 :param lfSelected: Samples to be included in the analysis | |
415 :type: List of boolean (true means include) | |
416 :return: List of distances (doubles) | |
417 """ | |
418 #Get the distance from label 1 of all samples in label0 splitting into selected and not selected lists | |
419 ldSelectedDistances = [] | |
420 | |
421 for sSampleName in [sSample for iindex, sSample in enumerate(lsSamples) if lfSelected[iindex]]: | |
422 #Get the sample measurements | |
423 ldSelectedDistances.append(Metric.funcGetBrayCurtisDissimilarity(np.array([abndTable.funcGetSample(sSampleName),ldAverage]))[0]) | |
424 return ldSelectedDistances | |
425 | |
426 #Happy path tested (1 case) | |
427 def funcMeasureDistanceFromLabelToAverageOtherLabel(self, abndTable, lfGroupOfInterest, lfGroupOther): | |
428 """ | |
429 Get the distance of samples from one label from the average sample of not the label. | |
430 Note: This assumes 2 classes. | |
431 | |
432 :param abndTable: Table of data to work out of. | |
433 :type: Abundace Table | |
434 :param lfGroupOfInterest: Boolean indicator of the sample being in the first group. | |
435 :type: List of floats, true indicating an individual in the group of interest. | |
436 :param lfGroupOther: Boolean indicator of the sample being in the other group. | |
437 :type: List of floats, true indicating an individual in the | |
438 :return List of List of doubles: [list of tuples (string sample name,double distance) for the selected population, list of tuples for the not selected population] | |
439 """ | |
440 #Get all sample names | |
441 lsAllSamples = abndTable.funcGetSampleNames() | |
442 | |
443 #Get average populations | |
444 lAverageOther = self.funcGetAveragePopulation(abndTable=abndTable, lfCompress=lfGroupOther) | |
445 | |
446 #Get the distance from the average of the other label (label 1) | |
447 ldSelectedDistances = self.funcGetDistanceFromAverage(abndTable=abndTable, ldAverage=lAverageOther, | |
448 lsSamples=lsAllSamples, lfSelected=lfGroupOfInterest) | |
449 | |
450 return zip([lsAllSamples[iindex] for iindex, fGroup in enumerate(lfGroupOfInterest) if fGroup],ldSelectedDistances) | |
451 | |
452 #Happy path tested (1 test case) | |
453 def funcPerformDistanceSelection(self, abndTable, iSelectionCount, sLabel, sValueOfInterest): | |
454 """ | |
455 Given metadata, metadata of one value (sValueOfInterest) is measured from the average (centroid) value of another label group. | |
456 An iSelectionCount of samples is selected from the group of interest closest to and furthest from the centroid of the other group. | |
457 | |
458 :params abndTable: Abundance of measurements | |
459 :type: AbundanceTable | |
460 :params iSelectionCount: The number of samples selected per sample. | |
461 :type: Integer Integer greater than 0 | |
462 :params sLabel: ID of the metadata which is the supervised label | |
463 :type: String | |
464 :params sValueOfInterest: Metadata value in the sLabel metadta row of the abundance table which defines the group of interest. | |
465 :type: String found in the abundance table metadata row indicated by sLabel. | |
466 :return list list of tuples (samplename, distance) [[iSelectionCount of tuples closest to the other centroid], [iSelectionCount of tuples farthest from the other centroid], [all tuples of samples not selected]] | |
467 """ | |
468 | |
469 lsMetadata = abndTable.funcGetMetadata(sLabel) | |
470 #Other metadata values | |
471 lsUniqueOtherValues = list(set(lsMetadata)-set(sValueOfInterest)) | |
472 | |
473 #Get boolean indicator of values of interest | |
474 lfLabelsInterested = [sValueOfInterest == sValue for sValue in lsMetadata] | |
475 | |
476 #Get the distances of the items of interest from the other metadata values | |
477 dictDistanceAverages = {} | |
478 for sOtherLabel in lsUniqueOtherValues: | |
479 #Get boolean indicator of labels not of interest | |
480 lfLabelsOther = [sOtherLabel == sValue for sValue in lsMetadata] | |
481 | |
482 #Get the distances of data from two different groups to the average of the other | |
483 ldValueDistances = dict(self.funcMeasureDistanceFromLabelToAverageOtherLabel(abndTable, lfLabelsInterested, lfLabelsOther)) | |
484 | |
485 for sKey in ldValueDistances: | |
486 dictDistanceAverages[sKey] = ldValueDistances[sKey] + dictDistanceAverages[sKey] if sKey in dictDistanceAverages else ldValueDistances[sKey] | |
487 | |
488 #Finish average by dividing by length of lsUniqueOtherValues | |
489 ltpleAverageDistances = [(sKey, dictDistanceAverages[sKey]/float(len(lsUniqueOtherValues))) for sKey in dictDistanceAverages] | |
490 | |
491 #Sort to extract extremes | |
492 ltpleAverageDistances = sorted(ltpleAverageDistances,key=operator.itemgetter(1)) | |
493 | |
494 #Get the closest and farthest distances | |
495 ltupleDiscriminantSamples = ltpleAverageDistances[:iSelectionCount] | |
496 ltupleDistinctSamples = ltpleAverageDistances[iSelectionCount*-1:] | |
497 | |
498 #Remove the selected samples from the larger population of distances (better visualization) | |
499 ldSelected = [tpleSelected[0] for tpleSelected in ltupleDiscriminantSamples+ltupleDistinctSamples] | |
500 | |
501 #Return discriminant tuples, distinct tuples, other tuples | |
502 return [ltupleDiscriminantSamples, ltupleDistinctSamples, | |
503 [tplData for tplData in ltpleAverageDistances if tplData[0] not in ldSelected]] | |
504 | |
505 #Run the supervised method surrounding distance from centroids | |
506 #Happy path tested (3 test cases) | |
507 def funcRunSupervisedDistancesFromCentroids(self, abundanceTable, fRunDistinct, fRunDiscriminant, | |
508 xOutputSupFile, xPredictSupFile, strSupervisedMetadata, | |
509 iSampleSupSelectionCount, lsOriginalSampleNames, lsOriginalLabels, fAppendFiles = False): | |
510 """ | |
511 Runs supervised methods based on measuring distances of one label from the centroid of another. NAs are evaluated as theirown group. | |
512 | |
513 :param abundanceTable: AbundanceTable | |
514 :type: AbudanceTable Data to analyze | |
515 :param fRunDistinct: Run distinct selection method | |
516 :type: Boolean boolean (true runs method) | |
517 :param fRunDiscriminant: Run discriminant method | |
518 :type: Boolean boolean (true runs method) | |
519 :param xOutputSupFile: File output from supervised methods detailing data going into the method. | |
520 :type: String or FileStream | |
521 :param xPredictSupFile: File output from supervised methods distance results from supervised methods. | |
522 :type: String or FileStream | |
523 :param strSupervisedMetadata: The metadata that will be used to group samples. | |
524 :type: String | |
525 :param iSampleSupSelectionCount: Number of samples to select | |
526 :type: Integer int sample selection count | |
527 :param lsOriginalSampleNames: List of the sample names, order is important and should be preserved from the abundanceTable. | |
528 :type: List of samples | |
529 :param fAppendFiles: Indicates that output files already exist and appending is occuring. | |
530 :type: Boolean | |
531 :return Selected Samples: A dictionary of selected samples by selection ID | |
532 Dictionary {"Selection Method":["SampleID","SampleID"...]} | |
533 """ | |
534 #Get labels and run one label against many | |
535 lstrMetadata = abundanceTable.funcGetMetadata(strSupervisedMetadata) | |
536 dictlltpleDistanceMeasurements = {} | |
537 for sMetadataValue in set(lstrMetadata): | |
538 | |
539 #For now perform the selection here for the label of interest against the other labels | |
540 dictlltpleDistanceMeasurements.setdefault(sMetadataValue,[]).extend(self.funcPerformDistanceSelection(abndTable=abundanceTable, | |
541 iSelectionCount=iSampleSupSelectionCount, sLabel=strSupervisedMetadata, sValueOfInterest=sMetadataValue)) | |
542 | |
543 #Make expected output files for supervised methods | |
544 #1. Output file which is similar to an input file for SVMs | |
545 #2. Output file that is similar to the probabilitic output of a SVM (LibSVM) | |
546 #Manly for making output of supervised methods (Distance from Centroid) similar | |
547 #MicropitaVis needs some of these files | |
548 if xOutputSupFile: | |
549 if fAppendFiles: | |
550 SVM.funcUpdateSVMFileWithAbundanceTable(abndAbundanceTable=abundanceTable, xOutputSVMFile=xOutputSupFile, | |
551 lsOriginalLabels=lsOriginalLabels, lsSampleOrdering=lsOriginalSampleNames) | |
552 else: | |
553 SVM.funcConvertAbundanceTableToSVMFile(abndAbundanceTable=abundanceTable, xOutputSVMFile=xOutputSupFile, | |
554 sMetadataLabel=strSupervisedMetadata, lsOriginalLabels=lsOriginalLabels, lsSampleOrdering=lsOriginalSampleNames) | |
555 | |
556 #Will contain the samples selected to return | |
557 #One or more of the methods may be active so this is why I am extending instead of just returning the result of each method type | |
558 dictSelectedSamplesRet = dict() | |
559 for sKey, ltplDistances in dictlltpleDistanceMeasurements.items(): | |
560 if fRunDistinct: | |
561 dictSelectedSamplesRet.setdefault(ConstantsMicropita.c_strDistinct,[]).extend([ltple[0] for ltple in ltplDistances[1]]) | |
562 if fRunDiscriminant: | |
563 dictSelectedSamplesRet.setdefault(ConstantsMicropita.c_strDiscriminant,[]).extend([ltple[0] for ltple in ltplDistances[0]]) | |
564 | |
565 if xPredictSupFile: | |
566 dictFlattenedDistances = dict() | |
567 [dictFlattenedDistances.setdefault(sKey, []).append(tple) | |
568 for sKey, lltple in dictlltpleDistanceMeasurements.items() | |
569 for ltple in lltple for tple in ltple] | |
570 if fAppendFiles: | |
571 self._updatePredictFile(xPredictSupFile=xPredictSupFile, xInputLabelsFile=xOutputSupFile, | |
572 dictltpleDistanceMeasurements=dictFlattenedDistances, abundanceTable=abundanceTable, lsOriginalSampleNames=lsOriginalSampleNames) | |
573 else: | |
574 self._writeToPredictFile(xPredictSupFile=xPredictSupFile, xInputLabelsFile=xOutputSupFile, | |
575 dictltpleDistanceMeasurements=dictFlattenedDistances, abundanceTable=abundanceTable, lsOriginalSampleNames=lsOriginalSampleNames) | |
576 return dictSelectedSamplesRet | |
577 | |
578 #Two happy path test cases | |
579 def _updatePredictFile(self, xPredictSupFile, xInputLabelsFile, dictltpleDistanceMeasurements, abundanceTable, lsOriginalSampleNames): | |
580 """ | |
581 Manages updating the predict file. | |
582 | |
583 :param xPredictSupFile: File that has predictions (distances) from the supervised method. | |
584 :type: FileStream or String file path | |
585 :param xInputLabelsFile: File that as input to the supervised methods. | |
586 :type: FileStream or String file path | |
587 :param dictltpleDistanceMeasurements: | |
588 :type: Dictionary of lists of tuples {"labelgroup":[("SampleName",dDistance)...], "labelgroup":[("SampleName",dDistance)...]} | |
589 """ | |
590 | |
591 if not isinstance(xPredictSupFile, str): | |
592 xPredictSupFile.close() | |
593 xPredictSupFile = xPredictSupFile.name | |
594 csvr = open(xPredictSupFile,'r') | |
595 | |
596 f = csv.reader(csvr,delimiter=ConstantsBreadCrumbs.c_strBreadCrumbsSVMSpace) | |
597 lsHeader = f.next()[1:] | |
598 dictlltpleRead = dict([(sHeader,[]) for sHeader in lsHeader]) | |
599 | |
600 #Read data in | |
601 iSampleIndex = 0 | |
602 for sRow in f: | |
603 sLabel = sRow[0] | |
604 [dictlltpleRead[lsHeader[iDistanceIndex]].append((lsOriginalSampleNames[iSampleIndex],dDistance)) for iDistanceIndex, dDistance in enumerate(sRow[1:]) | |
605 if not dDistance == ConstantsMicropita.c_sEmptyPredictFileValue] | |
606 iSampleIndex += 1 | |
607 | |
608 #Combine dictltpleDistanceMeasurements with new data | |
609 #If they share a key then merge keeping parameter data | |
610 #If they do not share the key, keep the full data | |
611 dictNew = {} | |
612 for sKey in dictltpleDistanceMeasurements.keys(): | |
613 lsSamples = [tple[0] for tple in dictltpleDistanceMeasurements[sKey]] | |
614 dictNew[sKey] = dictltpleDistanceMeasurements[sKey]+[tple for tple in dictlltpleRead[sKey] if tple[0] not in lsSamples] if sKey in dictlltpleRead.keys() else dictltpleDistanceMeasurements[sKey] | |
615 for sKey in dictlltpleRead: | |
616 if sKey not in dictltpleDistanceMeasurements.keys(): | |
617 dictNew[sKey] = dictlltpleRead[sKey] | |
618 | |
619 #Call writer | |
620 self._writeToPredictFile(xPredictSupFile=xPredictSupFile, xInputLabelsFile=xInputLabelsFile, | |
621 dictltpleDistanceMeasurements=dictNew, abundanceTable=abundanceTable, | |
622 lsOriginalSampleNames=lsOriginalSampleNames, fFromUpdate=True) | |
623 | |
624 #2 happy path test cases | |
625 def _writeToPredictFile(self, xPredictSupFile, xInputLabelsFile, dictltpleDistanceMeasurements, abundanceTable, lsOriginalSampleNames, fFromUpdate=False): | |
626 """ | |
627 Write to the predict file. | |
628 | |
629 :param xPredictSupFile: File that has predictions (distances) from the supervised method. | |
630 :type: FileStream or String file path | |
631 :param xInputLabelsFile: File that as input to the supervised methods. | |
632 :type: FileStream or String file path | |
633 :param dictltpleDistanceMeasurements: | |
634 :type: Dictionary of lists of tuples {"labelgroup":[("SampleName",dDistance)...], "labelgroup":[("SampleName",dDistance)...]} | |
635 :param abundanceTable: An abundance table of the sample data. | |
636 :type: AbundanceTable | |
637 :param lsOriginalSampleNames: Used if the file is being updated as the sample names so that it may be passed in and consistent with other writing. | |
638 Otherwise will use the sample names from the abundance table. | |
639 :type: List of strings | |
640 :param fFromUpdate: Indicates if this is part of an update to the file or not. | |
641 :type: Boolean | |
642 """ | |
643 | |
644 xInputLabelsFileName = xInputLabelsFile | |
645 if not isinstance(xInputLabelsFile,str): | |
646 xInputLabelsFileName = xInputLabelsFile.name | |
647 f = csv.writer(open(xPredictSupFile,"w") if isinstance(xPredictSupFile, str) else xPredictSupFile,delimiter=ConstantsBreadCrumbs.c_strBreadCrumbsSVMSpace) | |
648 | |
649 lsAllSampleNames = abundanceTable.funcGetSampleNames() | |
650 lsLabels = SVM.funcReadLabelsFromFile(xSVMFile=xInputLabelsFileName, lsAllSampleNames= lsOriginalSampleNames if fFromUpdate else lsAllSampleNames, | |
651 isPredictFile=False) | |
652 dictLabels = dict([(sSample,sLabel) for sLabel in lsLabels.keys() for sSample in lsLabels[sLabel]]) | |
653 | |
654 #Dictionay keys will be used to order the predict file | |
655 lsMeasurementKeys = dictltpleDistanceMeasurements.keys() | |
656 #Make header | |
657 f.writerow(["labels"]+lsMeasurementKeys) | |
658 | |
659 #Reformat dictionary to make it easier to use | |
660 for sKey in dictltpleDistanceMeasurements: | |
661 dictltpleDistanceMeasurements[sKey] = dict([ltpl for ltpl in dictltpleDistanceMeasurements[sKey]]) | |
662 | |
663 for sSample in lsOriginalSampleNames: | |
664 #Make body of file | |
665 f.writerow([dictLabels.get(sSample,ConstantsMicropita.c_sEmptyPredictFileValue)]+ | |
666 [str(dictltpleDistanceMeasurements[sKey].get(sSample,ConstantsMicropita.c_sEmptyPredictFileValue)) | |
667 for sKey in lsMeasurementKeys]) | |
668 | |
669 def _funcRunNormalizeSensitiveMethods(self, abndData, iSampleSelectionCount, dictSelectedSamples, lsAlphaMetrics, lsBetaMetrics, lsInverseBetaMetrics, | |
670 fRunDiversity, fRunRepresentative, fRunExtreme, strAlphaMetadata=None, | |
671 istmBetaMatrix=None, istrmTree=None, istrmEnvr=None, fInvertDiversity=False): | |
672 """ | |
673 Manages running methods that are sensitive to normalization. This is called twice, once for the set of methods which should not be normalized and the other | |
674 for the set that should be normalized. | |
675 | |
676 :param abndData: Abundance table object holding the samples to be measured. | |
677 :type: AbundanceTable | |
678 :param iSampleSelectionCount The number of samples to select per method. | |
679 :type: Integer | |
680 :param dictSelectedSamples Will be added to as samples are selected {"Method:["strSelectedSampleID","strSelectedSampleID"...]}. | |
681 :type: Dictionary | |
682 :param lsAlphaMetrics: List of alpha metrics to use on alpha metric dependent assays (like highest diversity). | |
683 :type: List of strings | |
684 :param lsBetaMetrics: List of beta metrics to use on beta metric dependent assays (like most representative). | |
685 :type: List of strings | |
686 :param lsInverseBetaMetrics: List of inverse beta metrics to use on inverse beta metric dependent assays (like most dissimilar). | |
687 :type: List of strings | |
688 :param fRunDiversity: Run Diversity based methods (true indicates run). | |
689 :type: Boolean | |
690 :param fRunRepresentative: Run Representative based methods (true indicates run). | |
691 :type: Boolean | |
692 :param fRunExtreme: Run Extreme based methods (true indicates run). | |
693 :type: Boolean | |
694 :param istmBetaMatrix: File that has a precalculated beta matrix | |
695 :type: File stream or File path string | |
696 :return Selected Samples: Samples selected by methods. | |
697 Dictionary {"Selection Method":["SampleID","SampleID","SampleID",...]} | |
698 """ | |
699 | |
700 #Sample ids/names | |
701 lsSampleNames = abndData.funcGetSampleNames() | |
702 | |
703 #Generate alpha metrics and get most diverse | |
704 if fRunDiversity: | |
705 | |
706 #Get Alpha metrics matrix | |
707 internalAlphaMatrix = None | |
708 #Name of technique | |
709 strMethod = [strAlphaMetadata] if strAlphaMetadata else lsAlphaMetrics | |
710 | |
711 #If given an alpha-diversity metadata | |
712 if strAlphaMetadata: | |
713 internalAlphaMatrix = [[float(strNum) for strNum in abndData.funcGetMetadata(strAlphaMetadata)]] | |
714 else: | |
715 #Expects Observations (Taxa (row) x sample (column)) | |
716 #Returns [[metric1-sample1, metric1-sample2, metric1-sample3],[metric1-sample1, metric1-sample2, metric1-sample3]] | |
717 internalAlphaMatrix = Metric.funcBuildAlphaMetricsMatrix(npaSampleAbundance = abndData.funcGetAbundanceCopy() | |
718 if not abndData.funcIsSummed() | |
719 else abndData.funcGetFeatureAbundanceTable(abndData.funcGetTerminalNodes()).funcGetAbundanceCopy(), | |
720 lsSampleNames = lsSampleNames, lsDiversityMetricAlpha = lsAlphaMetrics) | |
721 | |
722 if internalAlphaMatrix: | |
723 #Invert measurments | |
724 if fInvertDiversity: | |
725 lldNewDiversity = [] | |
726 for lsLine in internalAlphaMatrix: | |
727 lldNewDiversity.append([1/max(dValue,ConstantsMicropita.c_smallNumber) for dValue in lsLine]) | |
728 internalAlphaMatrix = lldNewDiversity | |
729 #Get top ranked alpha diversity by most diverse | |
730 #Expects [[sample1,sample2,sample3...],[sample1,sample2,sample3..],...] | |
731 #Returns [[sampleName1, sampleName2, sampleNameN],[sampleName1, sampleName2, sampleNameN]] | |
732 mostDiverseAlphaSamplesIndexes = self.funcGetTopRankedSamples(lldMatrix=internalAlphaMatrix, lsSampleNames=lsSampleNames, iTopAmount=iSampleSelectionCount) | |
733 | |
734 #Add to results | |
735 for index in xrange(0,len(strMethod)): | |
736 strSelectionMethod = self.dictConvertAMetricDiversity.get(strMethod[index],ConstantsMicropita.c_strDiversity+"="+strMethod[index]) | |
737 dictSelectedSamples.setdefault(strSelectionMethod,[]).extend(mostDiverseAlphaSamplesIndexes[index]) | |
738 | |
739 logging.info("MicroPITA.funcRunNormalizeSensitiveMethods:: Selected Samples 1b") | |
740 logging.info(dictSelectedSamples) | |
741 | |
742 #Generate beta metrics and | |
743 if fRunRepresentative or fRunExtreme: | |
744 | |
745 #Abundance matrix transposed | |
746 npaTransposedAbundance = UtilityMath.funcTransposeDataMatrix(abndData.funcGetAbundanceCopy(), fRemoveAdornments=True) | |
747 | |
748 #Get center selection using clusters/tiling | |
749 #This will be for beta metrics in normalized space | |
750 if fRunRepresentative: | |
751 | |
752 if istmBetaMatrix: | |
753 #Get representative dissimilarity samples | |
754 medoidSamples=self.funcGetCentralSamplesByKMedoids(npaMatrix=npaTransposedAbundance, sMetric=ConstantsMicropita.c_custom, lsSampleNames=lsSampleNames, iNumberSamplesReturned=iSampleSelectionCount, istmBetaMatrix=istmBetaMatrix, istrmTree=istrmTree, istrmEnvr=istrmEnvr) | |
755 | |
756 if medoidSamples: | |
757 dictSelectedSamples.setdefault(ConstantsMicropita.c_strRepresentative+"="+ConstantsMicropita.c_custom,[]).extend(medoidSamples) | |
758 else: | |
759 logging.info("MicroPITA.funcRunNormalizeSensitiveMethods:: Performing representative selection on normalized data.") | |
760 for bMetric in lsBetaMetrics: | |
761 | |
762 #Get representative dissimilarity samples | |
763 medoidSamples=self.funcGetCentralSamplesByKMedoids(npaMatrix=npaTransposedAbundance, sMetric=bMetric, lsSampleNames=lsSampleNames, iNumberSamplesReturned=iSampleSelectionCount, istmBetaMatrix=istmBetaMatrix, istrmTree=istrmTree, istrmEnvr=istrmEnvr) | |
764 | |
765 if medoidSamples: | |
766 dictSelectedSamples.setdefault(self.dictConvertBMetricToMethod.get(bMetric,ConstantsMicropita.c_strRepresentative+"="+bMetric),[]).extend(medoidSamples) | |
767 | |
768 #Get extreme selection using clusters, tiling | |
769 if fRunExtreme: | |
770 logging.info("MicroPITA.funcRunNormalizeSensitiveMethods:: Performing extreme selection on normalized data.") | |
771 if istmBetaMatrix: | |
772 | |
773 #Samples for representative dissimilarity | |
774 #This involves inverting the distance metric, | |
775 #Taking the dendrogram level of where the number cluster == the number of samples to select | |
776 #Returning a repersentative sample from each cluster | |
777 extremeSamples = self.funcSelectExtremeSamplesFromHClust(strBetaMetric=ConstantsMicropita.c_custom, npaAbundanceMatrix=npaTransposedAbundance, lsSampleNames=lsSampleNames, iSelectSampleCount=iSampleSelectionCount, istmBetaMatrix=istmBetaMatrix, istrmTree=istrmTree, istrmEnvr=istrmEnvr) | |
778 | |
779 #Add selected samples | |
780 if extremeSamples: | |
781 dictSelectedSamples.setdefault(ConstantsMicropita.c_strExtreme+"="+ConstantsMicropita.c_custom,[]).extend(extremeSamples) | |
782 | |
783 else: | |
784 #Run KMedoids with inverse custom distance metric in normalized space | |
785 for bMetric in lsInverseBetaMetrics: | |
786 | |
787 #Samples for representative dissimilarity | |
788 #This involves inverting the distance metric, | |
789 #Taking the dendrogram level of where the number cluster == the number of samples to select | |
790 #Returning a repersentative sample from each cluster | |
791 extremeSamples = self.funcSelectExtremeSamplesFromHClust(strBetaMetric=bMetric, npaAbundanceMatrix=npaTransposedAbundance, lsSampleNames=lsSampleNames, iSelectSampleCount=iSampleSelectionCount, istmBetaMatrix=istmBetaMatrix, istrmTree=istrmTree, istrmEnvr=istrmEnvr) | |
792 | |
793 #Add selected samples | |
794 if extremeSamples: | |
795 dictSelectedSamples.setdefault(self.dictConvertInvBMetricToMethod.get(bMetric,ConstantsMicropita.c_strExtreme+"="+bMetric),[]).extend(extremeSamples) | |
796 | |
797 logging.info("MicroPITA.funcRunNormalizeSensitiveMethods:: Selected Samples 2,3b") | |
798 logging.info(dictSelectedSamples) | |
799 return dictSelectedSamples | |
800 | |
801 def funcRun(self, strIDName, strLastMetadataName, istmInput, | |
802 ostmInputPredictFile, ostmPredictFile, ostmCheckedFile, ostmOutput, | |
803 cDelimiter, cFeatureNameDelimiter, strFeatureSelection, | |
804 istmFeatures, iCount, lstrMethods, strLastRowMetadata = None, strLabel = None, strStratify = None, | |
805 strCustomAlpha = None, strCustomBeta = None, strAlphaMetadata = None, istmBetaMatrix = None, istrmTree = None, istrmEnvr = None, | |
806 iMinSeqs = ConstantsMicropita.c_liOccurenceFilter[0], iMinSamples = ConstantsMicropita.c_liOccurenceFilter[1], fInvertDiversity = False): | |
807 """ | |
808 Manages the selection of samples given different metrics. | |
809 | |
810 :param strIDName: Sample Id metadata row | |
811 :type: String | |
812 :param strLastMetadataName: The id of the metadata positioned last in the abundance table. | |
813 :type: String String metadata id. | |
814 :param istmInput: File to store input data to supervised methods. | |
815 :type: FileStream of String file path | |
816 :param ostmInputPredictFile: File to store distances from supervised methods. | |
817 :type: FileStream or String file path | |
818 :param ostmCheckedFile: File to store the AbundanceTable data after it is being checked. | |
819 :type: FileStream or String file path | |
820 :param ostmOutPut: File to store sample selection by methods of interest. | |
821 :type: FileStream or String file path | |
822 :param cDelimiter: Delimiter of abundance table. | |
823 :type: Character Char (default TAB). | |
824 :param cFeatureNameDelimiter: Delimiter of the name of features (for instance if they contain consensus lineages indicating clades). | |
825 :type: Character (default |). | |
826 :param stFeatureSelectionMethod: Which method to use to select features in a targeted manner (Using average ranked abundance or average abundance). | |
827 :type: String (specific values indicated in ConstantsMicropita.lsTargetedFeatureMethodValues). | |
828 :param istmFeatures: File which holds the features of interest if using targeted feature methodology. | |
829 :type: FileStream or String file path | |
830 :param iCount: Number of samples to select in each methods, supervised methods select this amount per label if possible. | |
831 :type: Integer integer. | |
832 :param lstrMethods: List of strings indicating selection techniques. | |
833 :type: List of string method names | |
834 :param strLabel: The metadata used for supervised labels. | |
835 :type: String | |
836 :param strStratify: The metadata used to stratify unsupervised data. | |
837 :type: String | |
838 :param strCustomAlpha: Custom alpha diversity metric | |
839 :type: String | |
840 :param strCustomBeta: Custom beta diversity metric | |
841 :type: String | |
842 :param strAlphaMetadata: Metadata id which is a diveristy metric to use in highest diversity sampling | |
843 :type: String | |
844 :param istmBetaMatrix: File containing precalculated beta-diversity matrix for representative sampling | |
845 :type: FileStream or String file path | |
846 :param istrmTree: File containing tree for phylogentic beta-diversity analysis | |
847 :type: FileStream or String file path | |
848 :param istrmEnvr: File containing environment for phylogentic beta-diversity analysis | |
849 :type: FileStream or String file path | |
850 :param iMinSeqs: Minimum sequence in the occurence filter which filters all features not with a minimum number of sequences in each of a minimum number of samples. | |
851 :type: Integer | |
852 :param iMinSamples: Minimum sample count for the occurence filter. | |
853 :type: Integer | |
854 :param fInvertDiversity: When true will invert diversity measurements before using. | |
855 :type: boolean | |
856 :return Selected Samples: Samples selected by methods. | |
857 Dictionary {"Selection Method":["SampleID","SampleID","SampleID",...]} | |
858 """ | |
859 | |
860 #Holds the top ranked samples from different metrics | |
861 #dict[metric name] = [samplename,samplename...] | |
862 selectedSamples = dict() | |
863 | |
864 #If a target feature file is given make sure that targeted feature is in the selection methods, if not add | |
865 if ConstantsMicropita.c_strFeature in lstrMethods: | |
866 if not istmFeatures: | |
867 logging.error("MicroPITA.funcRun:: Did not receive both the Targeted feature file and the feature selection method. MicroPITA did not run.") | |
868 return False | |
869 | |
870 #Diversity metrics to run | |
871 #Use custom metrics if specified | |
872 #Custom beta metrics set to normalized only, custom alpha metrics set to count only | |
873 diversityMetricsAlpha = [] if strCustomAlpha or strAlphaMetadata else [MicroPITA.c_strInverseSimpsonDiversity] | |
874 diversityMetricsBeta = [] if istmBetaMatrix else [strCustomBeta] if strCustomBeta else [MicroPITA.c_strBrayCurtisDissimilarity] | |
875 # inverseDiversityMetricsBeta = [MicroPITA.c_strInvBrayCurtisDissimilarity] | |
876 diversityMetricsAlphaNoNormalize = [strAlphaMetadata] if strAlphaMetadata else [strCustomAlpha] if strCustomAlpha else [] | |
877 diversityMetricsBetaNoNormalize = [] | |
878 # inverseDiversityMetricsBetaNoNormalize = [] | |
879 | |
880 #Targeted taxa | |
881 userDefinedTaxa = [] | |
882 | |
883 #Perform different flows flags | |
884 c_RUN_MAX_DIVERSITY_1 = ConstantsMicropita.c_strDiversity in lstrMethods | |
885 c_RUN_REPRESENTIVE_DISSIMILARITY_2 = ConstantsMicropita.c_strRepresentative in lstrMethods | |
886 c_RUN_MAX_DISSIMILARITY_3 = ConstantsMicropita.c_strExtreme in lstrMethods | |
887 c_RUN_RANK_AVERAGE_USER_4 = False | |
888 if ConstantsMicropita.c_strFeature in lstrMethods: | |
889 c_RUN_RANK_AVERAGE_USER_4 = True | |
890 if not istmFeatures: | |
891 logging.error("MicroPITA.funcRun:: No taxa file was given for taxa selection.") | |
892 return False | |
893 #Read in taxa list, break down to lines and filter out empty strings | |
894 userDefinedTaxa = filter(None,(s.strip( ) for s in istmFeatures.readlines())) | |
895 c_RUN_RANDOM_5 = ConstantsMicropita.c_strRandom in lstrMethods | |
896 c_RUN_DISTINCT = ConstantsMicropita.c_strDistinct in lstrMethods | |
897 c_RUN_DISCRIMINANT = ConstantsMicropita.c_strDiscriminant in lstrMethods | |
898 | |
899 #Read in abundance data | |
900 #Abundance is a structured array. Samples (column) by Taxa (rows) with the taxa id row included as the column index=0 | |
901 #Abundance table object to read in and manage data | |
902 totalAbundanceTable = AbundanceTable.funcMakeFromFile(xInputFile=istmInput, lOccurenceFilter = [iMinSeqs, iMinSamples], | |
903 cDelimiter=cDelimiter, sMetadataID=strIDName, sLastMetadataRow=strLastRowMetadata, | |
904 sLastMetadata=strLastMetadataName, cFeatureNameDelimiter=cFeatureNameDelimiter, xOutputFile=ostmCheckedFile) | |
905 if not totalAbundanceTable: | |
906 logging.error("MicroPITA.funcRun:: Could not read in the abundance table. Analysis was not performed."+ | |
907 " This often occurs when the Last Metadata is not specified correctly."+ | |
908 " Please check to make sure the Last Metadata selection is the row of the last metadata,"+ | |
909 " all values after this selection should be microbial measurements and should be numeric.") | |
910 return False | |
911 | |
912 lsOriginalLabels = SVM.funcMakeLabels(totalAbundanceTable.funcGetMetadata(strLabel)) if strLabel else strLabel | |
913 | |
914 dictTotalMetadata = totalAbundanceTable.funcGetMetadataCopy() | |
915 logging.debug("MicroPITA.funcRun:: Received metadata=" + str(dictTotalMetadata)) | |
916 #If there is only 1 unique value for the labels, do not run the Supervised methods | |
917 if strLabel and ( len(set(dictTotalMetadata.get(strLabel,[]))) < 2 ): | |
918 logging.error("The label " + strLabel + " did not have 2 or more values. Labels found=" + str(dictTotalMetadata.get(strLabel,[]))) | |
919 return False | |
920 | |
921 #Run unsupervised methods### | |
922 #Stratify the data if need be and drop the old data | |
923 lStratifiedAbundanceTables = totalAbundanceTable.funcStratifyByMetadata(strStratify) if strStratify else [totalAbundanceTable] | |
924 | |
925 #For each stratified abundance block or for the unstratfified abundance | |
926 #Run the unsupervised blocks | |
927 fAppendSupFiles = False | |
928 for stratAbundanceTable in lStratifiedAbundanceTables: | |
929 logging.info("MicroPITA.funcRun:: Running abundance block:"+stratAbundanceTable.funcGetName()) | |
930 | |
931 ###NOT SUMMED, NOT NORMALIZED | |
932 #Only perform if the data is not yet normalized | |
933 if not stratAbundanceTable.funcIsNormalized( ): | |
934 #Need to first work with unnormalized data | |
935 if c_RUN_MAX_DIVERSITY_1 or c_RUN_REPRESENTIVE_DISSIMILARITY_2 or c_RUN_MAX_DISSIMILARITY_3: | |
936 | |
937 self._funcRunNormalizeSensitiveMethods(abndData=stratAbundanceTable, iSampleSelectionCount=iCount, | |
938 dictSelectedSamples=selectedSamples, lsAlphaMetrics=diversityMetricsAlphaNoNormalize, | |
939 lsBetaMetrics=diversityMetricsBetaNoNormalize, | |
940 lsInverseBetaMetrics=diversityMetricsBetaNoNormalize, | |
941 fRunDiversity=c_RUN_MAX_DIVERSITY_1,fRunRepresentative=c_RUN_REPRESENTIVE_DISSIMILARITY_2, | |
942 fRunExtreme=c_RUN_MAX_DISSIMILARITY_3, strAlphaMetadata=strAlphaMetadata, | |
943 istrmTree=istrmTree, istrmEnvr=istrmEnvr, fInvertDiversity=fInvertDiversity) | |
944 | |
945 | |
946 #Generate selection by the rank average of user defined taxa | |
947 #Expects (Taxa (row) by Samples (column)) | |
948 #Expects a column 0 of taxa id that is skipped | |
949 #Returns [(sample name,average,rank)] | |
950 #SUMMED AND NORMALIZED | |
951 stratAbundanceTable.funcSumClades() | |
952 #Normalize data at this point | |
953 stratAbundanceTable.funcNormalize() | |
954 if c_RUN_RANK_AVERAGE_USER_4: | |
955 selectedSamples[ConstantsMicropita.c_strFeature] = self.funcSelectTargetedTaxaSamples(abndMatrix=stratAbundanceTable, | |
956 lsTargetedTaxa=userDefinedTaxa, iSampleSelectionCount=iCount, sMethod=strFeatureSelection) | |
957 logging.info("MicroPITA.funcRun:: Selected Samples Rank") | |
958 logging.info(selectedSamples) | |
959 | |
960 ###SUMMED AND NORMALIZED analysis block | |
961 #Diversity based metric will move reduce to terminal taxa as needed | |
962 if c_RUN_MAX_DIVERSITY_1 or c_RUN_REPRESENTIVE_DISSIMILARITY_2 or c_RUN_MAX_DISSIMILARITY_3: | |
963 | |
964 self._funcRunNormalizeSensitiveMethods(abndData=stratAbundanceTable, iSampleSelectionCount=iCount, | |
965 dictSelectedSamples=selectedSamples, lsAlphaMetrics=diversityMetricsAlpha, | |
966 lsBetaMetrics=diversityMetricsBeta, | |
967 lsInverseBetaMetrics=diversityMetricsBeta, | |
968 fRunDiversity=c_RUN_MAX_DIVERSITY_1,fRunRepresentative=c_RUN_REPRESENTIVE_DISSIMILARITY_2, | |
969 fRunExtreme=c_RUN_MAX_DISSIMILARITY_3, | |
970 istmBetaMatrix=istmBetaMatrix, istrmTree=istrmTree, istrmEnvr=istrmEnvr, fInvertDiversity=fInvertDiversity) | |
971 | |
972 #5::Select randomly | |
973 #Expects sampleNames = List of sample names [name, name, name...] | |
974 if(c_RUN_RANDOM_5): | |
975 #Select randomly from sample names | |
976 selectedSamples[ConstantsMicropita.c_strRandom] = self.funcGetRandomSamples(lsSamples=stratAbundanceTable.funcGetSampleNames(), iNumberOfSamplesToReturn=iCount) | |
977 logging.info("MicroPITA.funcRun:: Selected Samples Random") | |
978 logging.info(selectedSamples) | |
979 | |
980 #Perform supervised selection | |
981 if c_RUN_DISTINCT or c_RUN_DISCRIMINANT: | |
982 if strLabel: | |
983 dictSelectionRet = self.funcRunSupervisedDistancesFromCentroids(abundanceTable=stratAbundanceTable, | |
984 fRunDistinct=c_RUN_DISTINCT, fRunDiscriminant=c_RUN_DISCRIMINANT, | |
985 xOutputSupFile=ostmInputPredictFile,xPredictSupFile=ostmPredictFile, | |
986 strSupervisedMetadata=strLabel, iSampleSupSelectionCount=iCount, | |
987 lsOriginalSampleNames = totalAbundanceTable.funcGetSampleNames(), | |
988 lsOriginalLabels = lsOriginalLabels, | |
989 fAppendFiles=fAppendSupFiles) | |
990 | |
991 [selectedSamples.setdefault(sKey,[]).extend(lValue) for sKey,lValue in dictSelectionRet.items()] | |
992 | |
993 if not fAppendSupFiles: | |
994 fAppendSupFiles = True | |
995 logging.info("MicroPITA.funcRun:: Selected Samples Unsupervised") | |
996 logging.info(selectedSamples) | |
997 return selectedSamples | |
998 | |
999 #Testing: Happy path tested | |
1000 @staticmethod | |
1001 def funcWriteSelectionToFile(dictSelection,xOutputFilePath): | |
1002 """ | |
1003 Writes the selection of samples by method to an output file. | |
1004 | |
1005 :param dictSelection: The dictionary of selections by method to be written to a file. | |
1006 :type: Dictionary The dictionary of selections by method {"method":["sample selected","sample selected"...]} | |
1007 :param xOutputFilePath: FileStream or String path to file inwhich the dictionary is written. | |
1008 :type: String FileStream or String path to file | |
1009 """ | |
1010 | |
1011 if not dictSelection: | |
1012 return | |
1013 | |
1014 #Open file | |
1015 f = csv.writer(open(xOutputFilePath,"w") if isinstance(xOutputFilePath, str) else xOutputFilePath, delimiter=ConstantsMicropita.c_outputFileDelim ) | |
1016 | |
1017 #Create output content from dictionary | |
1018 for sKey in dictSelection: | |
1019 f.writerow([sKey]+dictSelection[sKey]) | |
1020 logging.debug("MicroPITA.funcRun:: Selected samples output to file:"+str(dictSelection[sKey])) | |
1021 | |
1022 #Testing: Happy Path tested | |
1023 @staticmethod | |
1024 def funcReadSelectionFileToDictionary(xInputFile): | |
1025 """ | |
1026 Reads in an output selection file from micropita and formats it into a dictionary. | |
1027 | |
1028 :param xInputFile: String path to file or file stream to read and translate into a dictionary. | |
1029 {"method":["sample selected","sample selected"...]} | |
1030 :type: FileStream or String Path to file | |
1031 :return Dictionary: Samples selected by methods. | |
1032 Dictionary {"Selection Method":["SampleID","SampleID","SampleID",...]} | |
1033 """ | |
1034 | |
1035 #Open file | |
1036 istmReader = csv.reader(open(xInputFile,'r') if isinstance(xInputFile, str) else xInputFile, delimiter = ConstantsMicropita.c_outputFileDelim) | |
1037 | |
1038 #Dictionary to hold selection data | |
1039 return dict([(lsLine[0], lsLine[1:]) for lsLine in istmReader]) | |
1040 | |
1041 #Set up arguments reader | |
1042 argp = argparse.ArgumentParser( prog = "MicroPITA.py", | |
1043 description = """Selects samples from abundance tables based on various selection schemes.""" ) | |
1044 | |
1045 args = argp.add_argument_group( "Common", "Commonly modified options" ) | |
1046 args.add_argument(ConstantsMicropita.c_strCountArgument,"--num", dest="iCount", metavar = "samples", default = 10, type = int, help = ConstantsMicropita.c_strCountHelp) | |
1047 args.add_argument("-m","--method", dest = "lstrMethods", metavar = "method", default = [], help = ConstantsMicropita.c_strSelectionTechniquesHelp, | |
1048 choices = ConstantsMicropita.c_lsAllMethods, action = "append") | |
1049 | |
1050 args = argp.add_argument_group( "Custom", "Selecting and inputing custom metrics" ) | |
1051 args.add_argument("-a","--alpha", dest = "strAlphaDiversity", metavar = "AlphaDiversity", default = None, help = ConstantsMicropita.c_strCustomAlphaDiversityHelp, choices = Metric.setAlphaDiversities) | |
1052 args.add_argument("-b","--beta", dest = "strBetaDiversity", metavar = "BetaDiversity", default = None, help = ConstantsMicropita.c_strCustomBetaDiversityHelp, choices = list(Metric.setBetaDiversities)+[Metric.c_strUnifracUnweighted,Metric.c_strUnifracWeighted]) | |
1053 args.add_argument("-q","--alphameta", dest = "strAlphaMetadata", metavar = "AlphaDiversityMetadata", default = None, help = ConstantsMicropita.c_strCustomAlphaDiversityMetadataHelp) | |
1054 args.add_argument("-x","--betamatrix", dest = "istmBetaMatrix", metavar = "BetaDiversityMatrix", default = None, help = ConstantsMicropita.c_strCustomBetaDiversityMatrixHelp) | |
1055 args.add_argument("-o","--tree", dest = "istrmTree", metavar = "PhylogeneticTree", default = None, help = ConstantsMicropita.c_strCustomPhylogeneticTreeHelp) | |
1056 args.add_argument("-i","--envr", dest = "istrmEnvr", metavar = "EnvironmentFile", default = None, help = ConstantsMicropita.c_strCustomEnvironmentFileHelp) | |
1057 args.add_argument("-f","--invertDiversity", dest = "fInvertDiversity", action="store_true", default = False, help = ConstantsMicropita.c_strInvertDiversityHelp) | |
1058 | |
1059 args = argp.add_argument_group( "Miscellaneous", "Row/column identifiers and feature targeting options" ) | |
1060 args.add_argument("-d",ConstantsMicropita.c_strIDNameArgument, dest="strIDName", metavar="sample_id", help= ConstantsMicropita.c_strIDNameHelp) | |
1061 args.add_argument("-l",ConstantsMicropita.c_strLastMetadataNameArgument, dest="strLastMetadataName", metavar = "metadata_id", default = None, | |
1062 help= ConstantsMicropita.c_strLastMetadataNameHelp) | |
1063 args.add_argument("-r",ConstantsMicropita.c_strTargetedFeatureMethodArgument, dest="strFeatureSelection", metavar="targeting_method", default=ConstantsMicropita.lsTargetedFeatureMethodValues[0], | |
1064 choices=ConstantsMicropita.lsTargetedFeatureMethodValues, help= ConstantsMicropita.c_strTargetedFeatureMethodHelp) | |
1065 args.add_argument("-t",ConstantsMicropita.c_strTargetedSelectionFileArgument, dest="istmFeatures", metavar="feature_file", type=argparse.FileType("rU"), help=ConstantsMicropita.c_strTargetedSelectionFileHelp) | |
1066 args.add_argument("-w",ConstantsMicropita.c_strFeatureMetadataArgument, dest="strLastFeatureMetadata", metavar="Last_Feature_Metadata", default=None, help=ConstantsMicropita.c_strFeatureMetadataHelp) | |
1067 | |
1068 args = argp.add_argument_group( "Data labeling", "Metadata IDs for strata and supervised label values" ) | |
1069 args.add_argument("-e",ConstantsMicropita.c_strSupervisedLabelArgument, dest="strLabel", metavar= "supervised_id", help=ConstantsMicropita.c_strSupervisedLabelHelp) | |
1070 args.add_argument("-s",ConstantsMicropita.c_strUnsupervisedStratifyMetadataArgument, dest="strUnsupervisedStratify", metavar="stratify_id", | |
1071 help= ConstantsMicropita.c_strUnsupervisedStratifyMetadataHelp) | |
1072 | |
1073 args = argp.add_argument_group( "File formatting", "Rarely modified file formatting options" ) | |
1074 args.add_argument("-j",ConstantsMicropita.c_strFileDelimiterArgument, dest="cFileDelimiter", metavar="column_delimiter", default="\t", help=ConstantsMicropita.c_strFileDelimiterHelp) | |
1075 args.add_argument("-k",ConstantsMicropita.c_strFeatureNameDelimiterArgument, dest="cFeatureNameDelimiter", metavar="taxonomy_delimiter", default="|", help=ConstantsMicropita.c_strFeatureNameDelimiterHelp) | |
1076 | |
1077 args = argp.add_argument_group( "Debugging", "Debugging options - modify at your own risk!" ) | |
1078 args.add_argument("-v",ConstantsMicropita.c_strLoggingArgument, dest="strLogLevel", metavar = "log_level", default="WARNING", | |
1079 choices=ConstantsMicropita.c_lsLoggingChoices, help= ConstantsMicropita.c_strLoggingHelp) | |
1080 args.add_argument("-c",ConstantsMicropita.c_strCheckedAbundanceFileArgument, dest="ostmCheckedFile", metavar = "output_qc", type = argparse.FileType("w"), help = ConstantsMicropita.c_strCheckedAbundanceFileHelp) | |
1081 args.add_argument("-g",ConstantsMicropita.c_strLoggingFileArgument, dest="ostmLoggingFile", metavar = "output_log", type = argparse.FileType("w"), help = ConstantsMicropita.c_strLoggingFileHelp) | |
1082 args.add_argument("-u",ConstantsMicropita.c_strSupervisedInputFile, dest="ostmInputPredictFile", metavar = "output_scaled", type = argparse.FileType("w"), help = ConstantsMicropita.c_strSupervisedInputFileHelp) | |
1083 args.add_argument("-p",ConstantsMicropita.c_strSupervisedPredictedFile, dest="ostmPredictFile", metavar = "output_labels", type = argparse.FileType("w"), help = ConstantsMicropita.c_strSupervisedPredictedFileHelp) | |
1084 | |
1085 argp.add_argument("istmInput", metavar = "input.pcl/biome", type = argparse.FileType("rU"), help = ConstantsMicropita.c_strAbundanceFileHelp, | |
1086 default = sys.stdin) | |
1087 argp.add_argument("ostmOutput", metavar = "output.txt", type = argparse.FileType("w"), help = ConstantsMicropita.c_strGenericOutputDataFileHelp, | |
1088 default = sys.stdout) | |
1089 | |
1090 __doc__ = "::\n\n\t" + argp.format_help( ).replace( "\n", "\n\t" ) + __doc__ | |
1091 | |
1092 def _main( ): | |
1093 args = argp.parse_args( ) | |
1094 | |
1095 #Set up logger | |
1096 iLogLevel = getattr(logging, args.strLogLevel.upper(), None) | |
1097 logging.basicConfig(stream = args.ostmLoggingFile if args.ostmLoggingFile else sys.stderr, filemode = 'w', level=iLogLevel) | |
1098 | |
1099 #Run micropita | |
1100 logging.info("MicroPITA:: Start microPITA") | |
1101 microPITA = MicroPITA() | |
1102 | |
1103 #Argparse will append to the default but will not remove the default so I do this here | |
1104 if not len(args.lstrMethods): | |
1105 args.lstrMethods = [ConstantsMicropita.c_strRepresentative] | |
1106 | |
1107 dictSelectedSamples = microPITA.funcRun( | |
1108 strIDName = args.strIDName, | |
1109 strLastMetadataName = args.strLastMetadataName, | |
1110 istmInput = args.istmInput, | |
1111 ostmInputPredictFile = args.ostmInputPredictFile, | |
1112 ostmPredictFile = args.ostmPredictFile, | |
1113 ostmCheckedFile = args.ostmCheckedFile, | |
1114 ostmOutput = args.ostmOutput, | |
1115 cDelimiter = args.cFileDelimiter, | |
1116 cFeatureNameDelimiter = args.cFeatureNameDelimiter, | |
1117 istmFeatures = args.istmFeatures, | |
1118 strFeatureSelection = args.strFeatureSelection, | |
1119 iCount = args.iCount, | |
1120 strLastRowMetadata = args.strLastFeatureMetadata, | |
1121 strLabel = args.strLabel, | |
1122 strStratify = args.strUnsupervisedStratify, | |
1123 strCustomAlpha = args.strAlphaDiversity, | |
1124 strCustomBeta = args.strBetaDiversity, | |
1125 strAlphaMetadata = args.strAlphaMetadata, | |
1126 istmBetaMatrix = args.istmBetaMatrix, | |
1127 istrmTree = args.istrmTree, | |
1128 istrmEnvr = args.istrmEnvr, | |
1129 lstrMethods = args.lstrMethods, | |
1130 fInvertDiversity = args.fInvertDiversity | |
1131 ) | |
1132 | |
1133 if not dictSelectedSamples: | |
1134 logging.error("MicroPITA:: Error, did not get a result from analysis.") | |
1135 return -1 | |
1136 logging.info("End microPITA") | |
1137 | |
1138 #Log output for debugging | |
1139 logging.debug("MicroPITA:: Returned the following samples:"+str(dictSelectedSamples)) | |
1140 | |
1141 #Write selection to file | |
1142 microPITA.funcWriteSelectionToFile(dictSelection=dictSelectedSamples, xOutputFilePath=args.ostmOutput) | |
1143 | |
1144 if __name__ == "__main__": | |
1145 _main( ) |