पायथन में इंटरपोलेशन के साथ एक सटीक-याद वक्र कैसे आकर्षित करें?

Question

मैंने sklearnprecision_recall_curve फ़ंक्शन और matplotlib पैकेज का उपयोग करके एक सटीक-याद वक्र खींचा है। आप में से उन लोगों के लिए जो परिशुद्धता-याद वक्र से परिचित हैं, आप जानते हैं कि कुछ वैज्ञानिक समुदाय केवल इसे स्वीकार करते हैं, जब इस इंटरफेलेटेड, उदाहरण के उदाहरण here। अब मेरा सवाल यह है कि यदि आप में से कोई भी पाइथन में इंटरपोलेशन कैसे करना है? मैं थोड़ी देर के लिए समाधान खोज रहा हूं लेकिन बिना किसी सफलता के! किसी भी तरह की सहायता का स्वागत किया जाएगा।

समाधान: @ फ्रैंकिस और @ali_m दोनों समाधान सही हैं और एक साथ मेरी समस्या हल हो गई है। तो, यह सोचते हैं कि आप sklearn में precision_recall_curve समारोह से एक आउटपुट मिलता है, यहाँ है कि मैं क्या लेखाचित्र तैयार करने के लिए किया था है:

 precision["micro"], recall["micro"], _ = precision_recall_curve(y_test.ravel(),scores.ravel()) 
     pr = copy.deepcopy(precision[0]) 
     rec = copy.deepcopy(recall[0]) 
     prInv = np.fliplr([pr])[0] 
     recInv = np.fliplr([rec])[0] 
     j = rec.shape[0]-2 
     while j>=0: 
      if prInv[j+1]>prInv[j]: 
       prInv[j]=prInv[j+1] 
      j=j-1 
     decreasing_max_precision = np.maximum.accumulate(prInv[::-1])[::-1] 
     plt.plot(recInv, decreasing_max_precision, marker= markers[mcounter], label=methodNames[countOfMethods]+': AUC={0:0.2f}'.format(average_precision[0])) 

और इन पंक्तियों के अंतर्वेशित घटता साजिश होगा यदि आप पाश और पारित करने के लिए एक में डाल यह प्रत्येक पुनरावृत्ति पर प्रत्येक विधि का डेटा। ध्यान दें कि यह गैर-अंतरित परिशुद्धता-याद वक्र को साजिश नहीं देगा।

Answer 1

precision में बढ़ते हिस्सों को हटाने के लिए पिछड़ा पुनरावृत्ति किया जा सकता है। फिर, लंबवत और क्षैतिज रेखाओं को बेनेट ब्राउन के उत्तर में vertical & horizontal lines in matplotlib के उत्तर में निर्दिष्ट किया जा सकता है। यहाँ

import numpy as np 
import matplotlib.pyplot as plt 

#just a dummy sample 
recall=np.linspace(0.0,1.0,num=42) 
precision=np.random.rand(42)*(1.-recall) 
precision2=precision.copy() 
i=recall.shape[0]-2 

# interpolation... 
while i>=0: 
    if precision[i+1]>precision[i]: 
     precision[i]=precision[i+1] 
    i=i-1 

# plotting... 
fig, ax = plt.subplots() 
for i in range(recall.shape[0]-1): 
    ax.plot((recall[i],recall[i]),(precision[i],precision[i+1]),'k-',label='',color='red') #vertical 
    ax.plot((recall[i],recall[i+1]),(precision[i+1],precision[i+1]),'k-',label='',color='red') #horizontal 

ax.plot(recall,precision2,'k--',color='blue') 
#ax.legend() 
ax.set_xlabel("recall") 
ax.set_ylabel("precision") 
plt.savefig('fig.jpg') 
fig.show() 

और एक परिणाम है:

यहाँ एक नमूना कोड है

Answer 2

@ फ्रांसिस के समाधान np.maximum.accumulate का उपयोग कर vectorized जा सकता है।

import numpy as np 
import matplotlib.pyplot as plt 

recall = np.linspace(0.0, 1.0, num=42) 
precision = np.random.rand(42)*(1.-recall) 

# take a running maximum over the reversed vector of precision values, reverse the 
# result to match the order of the recall vector 
decreasing_max_precision = np.maximum.accumulate(precision[::-1])[::-1] 

तुम भी की साजिश रचने के लिए इस्तेमाल किया for पाश से छुटकारा पाने के plt.step उपयोग कर सकते हैं:

fig, ax = plt.subplots(1, 1) 
ax.hold(True) 
ax.plot(recall, precision, '--b') 
ax.step(recall, decreasing_max_precision, '-r')