पायथन

Question

में आर के पी। एडजस्ट को कैसे कार्यान्वित करें मेरे पास पी-वैल्यू की एक सूची है और मैं FDR के लिए एकाधिक तुलनाओं के लिए समायोजित पी-मानों की गणना करना चाहता हूं। आर में, मैं उपयोग कर सकता हूं:

pval <- read.csv("my_file.txt",header=F,sep="\t") 
pval <- pval[,1] 
FDR <- p.adjust(pval, method= "BH") 
print(length(pval[FDR<0.1])) 
write.table(cbind(pval, FDR),"pval_FDR.txt",row.names=F,sep="\t",quote=F) 

मैं इस कोड को पायथन में कैसे कार्यान्वित कर सकता हूं?

pvalue_list [2.26717873145e-10, 1.36209234286e-11 , 0.684342083821...] # my pvalues 
pvalue_lst = [v.r['p.value'] for v in pvalue_list] 
p_adjust = R.r['p.adjust'](R.FloatVector(pvalue_lst),method='BH') 
for v in p_adjust: 
    print v 

ऊपर कोड एक AttributeError: 'float' object has no attribute 'r' त्रुटि फेंकता है: यहाँ गूगल की मदद से अजगर में मेरी feable प्रयास किया गया। क्या कोई मेरी समस्या को इंगित करने में मदद कर सकता है? मदद के लिए अग्रिम धन्यवाद!

Answer 1

आप क्या आर से हो रही है के बारे में सुनिश्चित होना चाहते हैं, तो आप भी पता चलता है कि 'आँकड़े' आर पैकेज में समारोह का उपयोग करना चाहते:

from rpy2.robjects.packages import importr 
from rpy2.robjects.vectors import FloatVector 

stats = importr('stats') 

p_adjust = stats.p_adjust(FloatVector(pvalue_list), method = 'BH') 

Answer 2

खैर, अपने कोड काम कर पाने के लिए, मुझे लगता है कि इस तरह कुछ काम करेगा:

import rpy2.robjects as R 

pvalue_list = [2.26717873145e-10, 1.36209234286e-11 , 0.684342083821...] # my pvalues 
p_adjust = R['p.adjust'](R.FloatVector(pvalue_list),method='BH') 
for v in p_adjust: 
    print v 

तो p.adjust काफी सरल है, तो आप अजगर में यह लिख सकता है, ताकि आप में कॉल करने के लिए आवश्यकता से बचने आर और आप इसे एक बहुत उपयोग करना चाहते हैं, तो आप एक साधारण अजगर आवरण बना सकते हैं:

def adjust_pvalues(pvalues, method='BH'): 
    return R['p.adjust'](R.FloatVector(pvalues), method=method) 

Answer 3

(मैं जानता हूँ कि यह जवाब नहीं है ... बस मददगार बनने की कोशिश कर।) आर के दशक में बिहार कोड पी। एडजस्ट बस है:

BH = { 
     i <- lp:1L # lp is the number of p-values 
     o <- order(p, decreasing = TRUE) # "o" will reverse sort the p-values 
     ro <- order(o) 
     pmin(1, cummin(n/i * p[o]))[ro] # n is also the number of p-values 
     } 

Answer 4

यह सवाल थोड़ा पुराना है , लेकिन पाइथन के लिए figuresmodels में कई तुलना सुधार उपलब्ध हैं। हम

http://statsmodels.sourceforge.net/devel/generated/statsmodels.sandbox.stats.multicomp.multipletests.html#statsmodels.sandbox.stats.multicomp.multipletests

Answer 5

पुराना सवाल है, लेकिन यहाँ अजगर में आर एफडीआर कोड का एक अनुवाद (जो शायद काफी अक्षम है):

def FDR(x): 
    """ 
    Assumes a list or numpy array x which contains p-values for multiple tests 
    Copied from p.adjust function from R 
    """ 
    o = [i[0] for i in sorted(enumerate(x), key=lambda v:v[1],reverse=True)] 
    ro = [i[0] for i in sorted(enumerate(o), key=lambda v:v[1])] 
    q = sum([1.0/i for i in xrange(1,len(x)+1)]) 
    l = [q*len(x)/i*x[j] for i,j in zip(reversed(xrange(1,len(x)+1)),o)] 
    l = [l[k] if l[k] < 1.0 else 1.0 for k in ro] 
    return l 

Answer 6

यहाँ एक घर में समारोह मैं उपयोग करते हैं:

def correct_pvalues_for_multiple_testing(pvalues, correction_type = "Benjamini-Hochberg"):     
    """                         
    consistent with R - print correct_pvalues_for_multiple_testing([0.0, 0.01, 0.029, 0.03, 0.031, 0.05, 0.069, 0.07, 0.071, 0.09, 0.1]) 
    """ 
    from numpy import array, empty                   
    pvalues = array(pvalues) 
    n = float(pvalues.shape[0])                   
    new_pvalues = empty(n) 
    if correction_type == "Bonferroni":                 
     new_pvalues = n * pvalues 
    elif correction_type == "Bonferroni-Holm":                
     values = [ (pvalue, i) for i, pvalue in enumerate(pvalues) ]          
     values.sort() 
     for rank, vals in enumerate(values):                
      pvalue, i = vals 
      new_pvalues[i] = (n-rank) * pvalue                
    elif correction_type == "Benjamini-Hochberg":               
     values = [ (pvalue, i) for i, pvalue in enumerate(pvalues) ]          
     values.sort() 
     values.reverse()                     
     new_values = [] 
     for i, vals in enumerate(values):                 
      rank = n - i 
      pvalue, index = vals                   
      new_values.append((n/rank) * pvalue)               
     for i in xrange(0, int(n)-1): 
      if new_values[i] < new_values[i+1]:               
       new_values[i+1] = new_values[i]               
     for i, vals in enumerate(values): 
      pvalue, index = vals 
      new_pvalues[index] = new_values[i]                             
    return new_pvalues 

Answer 7

, पायथन के numpy लाइब्रेरी का उपयोग करना आर के लिए बाहर बुला बिल्कुल, यहां बिहार विधि का एक यथोचित कुशल कार्यान्वयन है बिना:

import numpy as np 

def p_adjust_bh(p): 
    """Benjamini-Hochberg p-value correction for multiple hypothesis testing.""" 
    p = np.asfarray(p) 
    by_descend = p.argsort()[::-1] 
    by_orig = by_descend.argsort() 
    steps = float(len(p))/np.arange(len(p), 0, -1) 
    q = np.minimum(1, np.minimum.accumulate(steps * p[by_descend])) 
    return q[by_orig] 

मदद के लिए