मैं आपको एनाकोंडा के साथ हैंड्स-ऑन डेटा साइंस की पुस्तक के एक अध्याय का अनुवाद प्रस्तुत करता हूं
"भविष्यवाणी डेटा विश्लेषण - मॉडलिंग और सत्यापन"



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

इसलिए, हम निम्नलिखित विषयों पर विचार करेंगे:

• भविष्यवाणी डेटा विश्लेषण को समझना
• उपयोगी डेटासेट
• भविष्य की घटनाओं का पूर्वानुमान
• मॉडल चयन
• ग्रेंजर कॉजेलिटी टेस्ट

भविष्यवाणी डेटा विश्लेषण को समझना

लोगों को भविष्य की घटनाओं के बारे में कई सवाल हो सकते हैं।

• एक निवेशक, अगर वह स्टॉक की कीमतों के भविष्य के आंदोलन की भविष्यवाणी कर सकता है, तो वह एक बड़ा लाभ कमा सकता है।
• कंपनियां, यदि वे अपने उत्पादों की प्रवृत्ति की भविष्यवाणी कर सकती हैं, तो वे अपने शेयर की कीमत और बाजार में हिस्सेदारी बढ़ा सकती हैं।
• सरकारें, यदि वे समाज और अर्थव्यवस्था पर एक बढ़ती आबादी के प्रभाव की भविष्यवाणी कर सकती हैं, तो राज्य बजट और अन्य प्रासंगिक रणनीतिक निर्णयों के संदर्भ में बेहतर नीतियों को विकसित करने के लिए उनके पास अधिक प्रोत्साहन होगा।
• विश्वविद्यालयों, अगर वे अपने स्नातकों के लिए गुणवत्ता और कौशल सेट के मामले में बाजार की मांग को अच्छी तरह से समझ सकते हैं, तो वे भविष्य के कार्यबल की जरूरतों को पूरा करने के लिए बेहतर कार्यक्रमों का एक सेट विकसित कर सकते हैं या नए कार्यक्रम लॉन्च कर सकते हैं।

एक बेहतर पूर्वानुमान के लिए, शोधकर्ताओं को कई सवालों पर विचार करना चाहिए। उदाहरण के लिए, नमूना डेटा बहुत छोटा है? लापता चर कैसे निकालें? क्या यह डेटा सेट डेटा संग्रह प्रक्रियाओं के संदर्भ में पक्षपाती है? हम चरम सीमाओं या उत्सर्जन के बारे में कैसा महसूस करते हैं? सीज़नसिटी क्या है और हम इससे कैसे निपटते हैं? हमें किन मॉडलों का उपयोग करना चाहिए? यह अध्याय इन मुद्दों में से कुछ को संबोधित करेगा। चलो एक उपयोगी डेटासेट के साथ शुरू करते हैं।

उपयोगी डेटासेट

सबसे अच्छे डेटा स्रोतों में से एक यूसीआई मशीन लर्निंग रिपॉजिटरी है । साइट देखने के बाद हम निम्नलिखित सूची देखेंगे:



उदाहरण के लिए, यदि आप पहला डेटासेट (Abalone) चुनते हैं, तो हम निम्नलिखित देखेंगे। स्थान बचाने के लिए, केवल शीर्ष प्रदर्शित होता है:



यहाँ से, उपयोगकर्ता डेटासेट डाउनलोड कर सकते हैं और परिवर्तनशील परिभाषाएँ पा सकते हैं। डेटासेट लोड करने के लिए निम्न कोड का उपयोग किया जा सकता है:

dataSet<-"UCIdatasets" path<-"http://canisius.edu/~yany/RData/" con<-paste(path,dataSet,".RData",sep='') load(url(con)) dim(.UCIdatasets) head(.UCIdatasets) 

इसी आउटपुट को यहाँ दिखाया गया है:



पिछले निष्कर्ष से, हम जानते हैं कि डेटा सेट में 427 अवलोकन (डेटा सेट) हैं। उनमें से प्रत्येक के लिए, हमारे 7 संबंधित कार्य हैं, जैसे कि नाम, Data_Types, Default_Task, Attribute_Types, N_Instances (उदाहरणों की संख्या), N_Attributes (विशेषताओं की संख्या) और वर्ष । Default_Task नामक वैरिएबल की व्याख्या प्रत्येक डेटा सेट के मुख्य उपयोग के रूप में की जा सकती है। उदाहरण के लिए, अबालोन नामक पहला डेटासेट वर्गीकरण के लिए इस्तेमाल किया जा सकता है। अद्वितीय () फ़ंक्शन का उपयोग यहां दिखाए गए सभी डिफ़ॉल्ट Default_Task को खोजने के लिए किया जा सकता है:

R पैकेज AppliedPredictiveModeling

इस पैकेज में कई उपयोगी डेटासेट शामिल हैं जिनका उपयोग इस अध्याय और अन्य के लिए किया जा सकता है। इन डेटासेट को खोजने का सबसे आसान तरीका यहां दिखाए गए सहायता () फ़ंक्शन के साथ है:

 library(AppliedPredictiveModeling) help(package=AppliedPredictiveModeling) 

यहां हम इन डेटासेट को लोड करने के कुछ उदाहरण दिखाते हैं। एक डेटा सेट को लोड करने के लिए, हम डेटा () फ़ंक्शन का उपयोग करते हैं। अबालोन नामक पहले डेटासेट के लिए, हमारे पास निम्नलिखित कोड हैं:

 library(AppliedPredictiveModeling) data(abalone) dim(abalone) head(abalone) 

आउटपुट निम्नानुसार है:



कभी-कभी, एक बड़े डेटा सेट में कई उप-डेटा सेट शामिल होते हैं:

 library(AppliedPredictiveModeling) data(solubility) ls(pattern="sol") 

 [1] "solTestX" "solTestXtrans" "solTestY" [4] "solTrainX" "solTrainXtrans" "solTrainY" 

प्रत्येक डेटा सेट को लोड करने के लिए, हम फंक्शन मंद () , हेड () , टेल () और सारांश () का उपयोग कर सकते हैं ।

टाइम सीरीज़ एनालिटिक्स

समय श्रृंखला को समय के लगातार क्षणों में प्राप्त मूल्यों के एक सेट के रूप में परिभाषित किया जा सकता है, अक्सर उनके बीच समान अंतराल के साथ। वार्षिक, त्रैमासिक, मासिक, साप्ताहिक और दैनिक जैसे अलग-अलग समय होते हैं। सकल घरेलू उत्पाद (सकल घरेलू उत्पाद) की समय श्रृंखला के लिए हम आमतौर पर त्रैमासिक या वार्षिक उपयोग करते हैं। उद्धरण के लिए - वार्षिक, मासिक और दैनिक आवृत्तियों। निम्नलिखित कोड का उपयोग करके, हम त्रैमासिक और वार्षिक अवधि के लिए यूएस जीडीपी डेटा प्राप्त कर सकते हैं:

 ath<-"http://canisius.edu/~yany/RData/" dataSet<-"usGDPannual" con<-paste(path,dataSet,".RData",sep='') load(url(con)) head(.usGDPannual) 

 YEAR GDP 1 1930 92.2 2 1931 77.4 3 1932 59.5 4 1933 57.2 5 1934 66.8 6 1935 74.3 

 dataSet<-"usGDPquarterly" con<-paste(path,dataSet,".RData",sep='') load(url(con)) head(.usGDPquarterly) 

  DATE GDP_CURRENT GDP2009DOLLAR 1 1947Q1 243.1 1934.5 2 1947Q2 246.3 1932.3 3 1947Q3 250.1 1930.3 4 1947Q4 260.3 1960.7 5 1948Q1 266.2 1989.5 6 1948Q2 272.9 2021.9 

हालांकि, हमारे पास समय श्रृंखला विश्लेषण के लिए कई प्रश्न हैं। उदाहरण के लिए, मैक्रोइकॉनॉमिक्स के दृष्टिकोण से, हमारे पास व्यवसाय या आर्थिक चक्र हैं। उद्योगों या कंपनियों के पास मौसम हो सकता है। उदाहरण के लिए, कृषि उद्योग का उपयोग करते हुए, किसान वसंत में अधिक और ऋतुओं में और सर्दियों में कम खर्च करेंगे। खुदरा विक्रेताओं के लिए, उनके पास वर्ष के अंत में धन का एक बड़ा प्रवाह होगा।

समय श्रृंखला में हेरफेर करने के लिए, हम आर पैकेज में शामिल कई उपयोगी सुविधाओं का उपयोग कर सकते हैं, जिन्हें टाइमसरीज कहा जाता है। उदाहरण में, हम साप्ताहिक आवृत्ति के साथ दैनिक औसत डेटा लेते हैं:

 library(timeSeries) data(MSFT) x <- MSFT by <- timeSequence(from = start(x), to = end(x), by = "week") y<-aggregate(x,by,mean) 

हम कुछ टिप्पणियों को देखने के लिए सिर () फ़ंक्शन का भी उपयोग कर सकते हैं:

 head(x) 

 GMT Open High Low Close Volume 2000-09-27 63.4375 63.5625 59.8125 60.6250 53077800 2000-09-28 60.8125 61.8750 60.6250 61.3125 26180200 2000-09-29 61.0000 61.3125 58.6250 60.3125 37026800 2000-10-02 60.5000 60.8125 58.2500 59.1250 29281200 2000-10-03 59.5625 59.8125 56.5000 56.5625 42687000 2000-10-04 56.3750 56.5625 54.5000 55.4375 68226700 

 head(y) 

 GMT Open High Low Close Volume 2000-09-27 63.4375 63.5625 59.8125 60.6250 53077800 2000-10-04 59.6500 60.0750 57.7000 58.5500 40680380 2000-10-11 54.9750 56.4500 54.1625 55.0875 36448900 2000-10-18 53.0375 54.2500 50.8375 52.1375 50631280 2000-10-25 61.7875 64.1875 60.0875 62.3875 86457340 2000-11-01 66.1375 68.7875 65.8500 67.9375 53496000 

भविष्य की घटनाओं का पूर्वानुमान

ऐसे कई तरीके हैं जिनका उपयोग हम भविष्य की भविष्यवाणी करने की कोशिश करते समय कर सकते हैं, जैसे कि चलती औसत, प्रतिगमन, आत्मकेंद्रित, आदि। पहले, चल औसत के लिए सबसे सरल के साथ शुरू करें:

 movingAverageFunction<- function(data,n=10){ out= data for(i in n:length(data)){ out[i] = mean(data[(i-n+1):i]) } return(out) } 

पिछले कोड में, अवधियों की संख्या के लिए डिफ़ॉल्ट मान 10. है। हम MSFT नामक एक डेटासेट का उपयोग कर सकते हैं जिसे आर पैकेज में शामिल किया गया है जिसे टाइमसीरीज (निम्नलिखित कोड देखें):

 library(timeSeries) data(MSFT) p<-MSFT$Close # ma<-movingAverageFunction(p,3) head(p) 

 [1] 60.6250 61.3125 60.3125 59.1250 56.5625 55.4375 

 head(ma) 

 [1] 60.62500 61.31250 60.75000 60.25000 58.66667 57.04167 

 mean(p[1:3]) 

 [1] 60.75 

 mean(p[2:4]) 

 [1] 60.25 

मैनुअल मोड में, हम पाते हैं कि x के पहले तीन मानों का औसत y के तीसरे मान से मेल खाता है। एक तरह से, हम भविष्य की भविष्यवाणी करने के लिए एक चलती औसत का उपयोग कर सकते हैं।

अगले उदाहरण में, हम यह दिखाएंगे कि अगले वर्ष के अनुमानित बाजार रिटर्न का मूल्यांकन कैसे करें। यहां हम अपने अपेक्षित मूल्यों के रूप में एस एंड पी 500 इंडेक्स और ऐतिहासिक औसत वार्षिक मूल्य का उपयोग करते हैं। पहले कुछ आदेशों को .sp500monthly नामक संबंधित डेटासेट को लोड करने के लिए उपयोग किया जाता है। कार्यक्रम का उद्देश्य औसत वार्षिक औसत और 90 प्रतिशत आत्मविश्वास अंतराल का आकलन करना है:

 library(data.table) path<-'http://canisius.edu/~yany/RData/' dataSet<-'sp500monthly.RData' link<-paste(path,dataSet,sep='') load(url(link)) #head(.sp500monthly,2) p<-.sp500monthly$ADJ.CLOSE n<-length(p) logRet<-log(p[2:n]/p[1:(n-1)]) years<-format(.sp500monthly$DATE[2:n],"%Y") y<-data.frame(.sp500monthly$DATE[2:n],years,logRet) colnames(y)<-c("DATE","YEAR","LOGRET") y2<- data.table(y) z<-y2[,sum(LOGRET),by=YEAR] z2<-na.omit(z) annualRet<-data.frame(z2$YEAR,exp(z2[,2])-1) n<-nrow(annualRet) std<-sd(annualRet[,2]) stdErr<-std/sqrt(n) ourMean<-mean(annualRet[,2]) min2<-ourMean-2*stdErr max2<-ourMean+2*stdErr cat("[min mean max ]\n") 

 [min mean max ] 

 cat(min2,ourMean,max2,"\n") 

 0.05032956 0.09022369 0.1301178 

जैसा कि आप परिणामों से देख सकते हैं, एस एंड पी 500 के लिए ऐतिहासिक औसत वार्षिक रिटर्न 9% है। लेकिन हम यह नहीं कह सकते कि अगले वर्ष सूचकांक की लाभप्रदता 9% होगी, क्योंकि यह 5% से 13% तक हो सकता है, और ये बड़े उतार-चढ़ाव वाले होते हैं।

मौसम

निम्नलिखित उदाहरण में, हम स्वायत्तता के उपयोग को दिखाते हैं। सबसे पहले, हम एस्टा नामक एक आर पैकेज डाउनलोड करते हैं , जो लागू सांख्यिकीय समय श्रृंखला विश्लेषण के लिए है। फिर हम त्रैमासिक आवृत्ति के साथ US GDP लोड करते हैं:

 library(astsa) path<-"http://canisius.edu/~yany/RData/" dataSet<-"usGDPquarterly" con<-paste(path,dataSet,".RData",sep='') load(url(con)) x<-.usGDPquarterly$DATE y<-.usGDPquarterly$GDP_CURRENT plot(x,y) diff4 = diff(y,4) acf2(diff4,24) 

उपरोक्त कोड में, अंतर () फ़ंक्शन अंतर को स्वीकार करता है, उदाहरण के लिए, वर्तमान मान पिछले मान को घटा देता है। एक दूसरी इनपुट वैल्यू देरी का संकेत देती है। एसीएफ 2 () नामक एक फ़ंक्शन का उपयोग एसीएफ और पीएसीएफ समय श्रृंखला बनाने और प्रिंट करने के लिए किया जाता है। ACF का अर्थ है ऑटोक्लेवेरियन फंक्शन, और PACF का अर्थ है आंशिक ऑटोकैरेलेशन फंक्शन। प्रासंगिक रेखांकन यहां दिखाए गए हैं:

घटक दृश्य

स्पष्ट रूप से, यदि हम ग्राफ़ का उपयोग कर सकते हैं, तो अवधारणाएं और डेटा सेट बहुत अधिक समझ में आएंगे। पिछले पाँच दशकों में अमेरिकी जीडीपी में उतार-चढ़ाव पहला उदाहरण दिखाता है:

 path<-"http://canisius.edu/~yany/RData/" dataSet<-"usGDPannual" con<-paste(path,dataSet,".RData",sep='') load(url(con)) title<-"US GDP" xTitle<-"Year" yTitle<-"US annual GDP" x<-.usGDPannual$YEAR y<-.usGDPannual$GDP plot(x,y,main=title,xlab=xTitle,ylab=yTitle) 

इसी अनुसूची यहाँ दिखाया गया है:



यदि हमने जीडीपी के लिए लघुगणक पैमाने का उपयोग किया है, तो हमारे पास निम्नलिखित कोड और ग्राफ होंगे:

 yTitle<-"Log US annual GDP" plot(x,log(y),main=title,xlab=xTitle,ylab=yTitle) 

निम्नलिखित चार्ट एक सीधी रेखा के करीब है:

आर पैकेज - LiblineaR

यह पैकेज LIBLINEAR C / C ++ लाइब्रेरी पर आधारित एक लीनियर प्रेडिक्टिव मॉडल है। यहाँ आईरिस डेटासेट का उपयोग करने का एक उदाहरण है। कार्यक्रम यह अनुमान लगाने की कोशिश करता है कि प्रशिक्षण डेटा का उपयोग करने के लिए एक संयंत्र किस श्रेणी का है:

 library(LiblineaR) data(iris) attach(iris) x=iris[,1:4] y=factor(iris[,5]) train=sample(1:dim(iris)[1],100) xTrain=x[train,];xTest=x[-train,] yTrain=y[train]; yTest=y[-train] s=scale(xTrain,center=TRUE,scale=TRUE) # tryTypes=c(0:7) tryCosts=c(1000,1,0.001) bestCost=NA bestAcc=0 bestType=NA # for(ty in tryTypes){ for(co in tryCosts){ acc=LiblineaR(data=s,target=yTrain,type=ty,cost=co,bias=1,cross=5,verbose=FALSE) cat("Results for C=",co,": ",acc," accuracy.\n",sep="") if(acc>bestAcc){ bestCost=co bestAcc=acc bestType=ty } } } cat("Best model type is:",bestType,"\n") cat("Best cost is:",bestCost,"\n") cat("Best accuracy is:",bestAcc,"\n") # Re-train best model with best cost value. m=LiblineaR(data=s,target=yTrain,type=bestType,cost=bestCost,bias=1,verbose=FALSE) # Scale the test data s2=scale(xTest,attr(s,"scaled:center"),attr(s,"scaled:scale")) pr=FALSE; # Make prediction if(bestType==0 || bestType==7) pr=TRUE p=predict(m,s2,proba=pr,decisionValues=TRUE) res=table(p$predictions,yTest) # Display confusion matrix print(res) # Compute Balanced Classification Rate BCR=mean(c(res[1,1]/sum(res[,1]),res[2,2]/sum(res[,2]),res[3,3]/sum(res[,3]))) print(BCR) 

निष्कर्ष इस प्रकार है। BCR एक संतुलित वर्गीकरण दर है। इस शर्त के लिए, उच्चतर बेहतर:

 cat("Best model type is:",bestType,"\n") 

 Best model type is: 4 

 cat("Best cost is:",bestCost,"\n") 

 Best cost is: 1 

 cat("Best accuracy is:",bestAcc,"\n") 

 Best accuracy is: 0.98 

 print(res) yTest setosa versicolor virginica setosa 16 0 0 versicolor 0 17 0 virginica 0 3 14 print(BCR) 

 [1] 0.95 

आर पैकेज - ग्रहण

यह पैकेज उच्च-आयामी डेटा में व्याख्या किए गए पूर्वानुमान मॉडल के लिए एक मध्यम-उन्मुख क्लस्टरिंग है। पहले, आइए सिमडाटा नामक एक डेटा सेट को देखें जिसमें एक पैकेज के लिए सिम्युलेटेड डेटा है:

 library(eclust) data("simdata") dim(simdata) 

 [1] 100 502 

 simdata[1:5, 1:6] 

  YE Gene1 Gene2 Gene3 Gene4 [1,] -94.131497 0 -0.4821629 0.1298527 0.4228393 0.36643188 [2,] 7.134990 0 -1.5216289 -0.3304428 -0.4384459 1.57602830 [3,] 1.974194 0 0.7590055 -0.3600983 1.9006443 -1.47250061 [4,] -44.855010 0 0.6833635 1.8051352 0.1527713 -0.06442029 [5,] 23.547378 0 0.4587626 -0.3996984 -0.5727255 -1.75716775 

 table(simdata[,"E"]) 

 0 1 50 50 

पिछले निष्कर्ष से पता चलता है कि डेटा आयाम 50 से 502 है। Y निरंतर प्रतिक्रिया वेक्टर है, और E ECLUST विधि के लिए द्विआधारी पर्यावरण चर है। एक्सपोज़्ड के लिए E = 0 (n = 50) और उजागर के लिए E = 1 ।

निम्नलिखित कार्यक्रम आर फिशर जेड-ट्रांसफॉर्मेशन का मूल्यांकन करता है:

 library(eclust) data("simdata") X = simdata[,c(-1,-2)] firstCorr<-cor(X[1:50,]) secondCorr<-cor(X[51:100,]) score<-u_fisherZ(n0=100,cor0=firstCorr,n1=100,cor1=secondCorr) dim(score) 

 [1] 500 500 

 score[1:5,1:5] 

  Gene1 Gene2 Gene3 Gene4 Gene5 Gene1 1.000000 -8.062020 6.260050 -8.133437 -7.825391 Gene2 -8.062020 1.000000 9.162208 -7.431822 -7.814067 Gene3 6.260050 9.162208 1.000000 8.072412 6.529433 Gene4 -8.133437 -7.431822 8.072412 1.000000 -5.099261 Gene5 -7.825391 -7.814067 6.529433 -5.099261 1.000000 

हम फिशर जेड-ट्रांसफॉर्म को परिभाषित करते हैं। यह मानते हुए कि हमारे पास n जोड़े x i और y i का एक सेट है, हम निम्नलिखित सूत्र का उपयोग करके उनके सहसंबंध का अनुमान लगा सकते हैं:



यहाँ पी दो चर के बीच संबंध है, और और यादृच्छिक चर x और y के लिए नमूना साधन हैं। Z का मान इस प्रकार है:



ln प्राकृतिक लघुगणक फ़ंक्शन है, और arctanh () उलटा हाइपरबोलिक स्पर्शरेखा फ़ंक्शन है।

मॉडल चयन

एक अच्छा मॉडल खोजने पर, कभी-कभी हमें डेटा की कमी / अधिकता का सामना करना पड़ता है। निम्नलिखित उदाहरण यहाँ से उधार लिया गया है । वह इस के साथ काम करने की समस्याओं को प्रदर्शित करता है और हम गैर-रैखिक कार्यों को अनुमानित करने के लिए बहुपद सुविधाओं के साथ रैखिक प्रतिगमन का उपयोग कैसे कर सकते हैं। निर्दिष्ट समारोह:



अगले कार्यक्रम में, हम समीकरण को अनुमानित करने के लिए रैखिक और बहुपद मॉडल का उपयोग करने का प्रयास करते हैं। थोड़ा संशोधित कोड यहां दिखाया गया है। कार्यक्रम डेटा की कमी के प्रभाव को दिखाता है / मॉडल पर ओवरसुप्ली:

 import sklearn import numpy as np import matplotlib.pyplot as plt from sklearn.pipeline import Pipeline from sklearn.preprocessing import PolynomialFeatures from sklearn.linear_model import LinearRegression from sklearn.model_selection import cross_val_score # np.random.seed(123) n= 30 # number of samples degrees = [1, 4, 15] def true_fun(x): return np.cos(1.5*np.pi*x) x = np.sort(np.random.rand(n)) y = true_fun(x) + np.random.randn(n) * 0.1 plt.figure(figsize=(14, 5)) title="Degree {}\nMSE = {:.2e}(+/- {:.2e})" name1="polynomial_features" name2="linear_regression" name3="neg_mean_squared_error" # for i in range(len(degrees)): ax=plt.subplot(1,len(degrees),i+1) plt.setp(ax, xticks=(), yticks=()) pFeatures=PolynomialFeatures(degree=degrees[i],include_bias=False) linear_regression = LinearRegression() pipeline=Pipeline([(name1,pFeatures),(name2,linear_regression)]) pipeline.fit(x[:,np.newaxis],y) scores=cross_val_score(pipeline,x[:,np.newaxis],y,scoring=name3,cv=10) xTest = np.linspace(0, 1, 100) plt.plot(xTest,pipeline.predict(xTest[:,np.newaxis]),label="Model") plt.plot(xTest,true_fun(xTest),label="True function") plt.scatter(x,y,edgecolor='b',s=20,label="Samples") plt.xlabel("x") plt.ylabel("y") plt.xlim((0,1)) plt.ylim((-2,2)) plt.legend(loc="best") plt.title(title.format(degrees[i],-scores.mean(),scores.std())) plt.show() 

परिणामी रेखांकन यहां दिखाए गए हैं:

पायथन पैकेज - मॉडल-कैटवॉक

एक उदाहरण यहां पाया जा सकता है ।

कोड की पहली कुछ पंक्तियाँ यहाँ दिखाई गई हैं:

 import datetime import pandas from sqlalchemy import create_engine from metta import metta_io as metta from catwalk.storage import FSModelStorageEngine, CSVMatrixStore from catwalk.model_trainers import ModelTrainer from catwalk.predictors import Predictor from catwalk.evaluation import ModelEvaluator from catwalk.utils import save_experiment_and_get_hash help(FSModelStorageEngine) 

इसी निष्कर्ष को यहाँ दिखाया गया है। स्थान बचाने के लिए, केवल ऊपरी भाग प्रस्तुत किया गया है:

 Help on class FSModelStorageEngine in module catwalk.storage: class FSModelStorageEngine(ModelStorageEngine) | Method resolution order: | FSModelStorageEngine | ModelStorageEngine | builtins.object | | Methods defined here: | | __init__(self, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | get_store(self, model_hash) | | ---------------------------------------------------------------------- 

 | Data descriptors inherited from ModelStorageEngine: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) 

अजगर पैकेज - स्केलेर

चूँकि sklearn एक बहुत ही उपयोगी पैकेज है, इसलिए यह इस पैकेज का उपयोग करने के और अधिक उदाहरण दिखाने लायक है। यहां दिए गए उदाहरण से पता चलता है कि बैग के शब्दों के दृष्टिकोण का उपयोग करके दस्तावेजों को वर्गीकृत करने के लिए पैकेज का उपयोग कैसे करें।
यह उदाहरण वस्तुओं को संग्रहीत करने के लिए scipy.sparse मैट्रिक्स का उपयोग करता है और विभिन्न वर्गीकरणों को प्रदर्शित करता है जो कुशलता से विरल मैट्रिस को संसाधित कर सकते हैं। यह उदाहरण 20 समाचार समूहों के डेटासेट का उपयोग करता है। इसे स्वचालित रूप से डाउनलोड किया जाएगा और फिर कैश किया जाएगा। जिप फाइल में इनपुट फाइलें होती हैं और इन्हें यहां डाउनलोड किया जा सकता है । यहां कोड उपलब्ध है । अंतरिक्ष को बचाने के लिए, केवल पहली कुछ लाइनें दिखाई जाती हैं:

 import logging import numpy as np from optparse import OptionParser import sys from time import time import matplotlib.pyplot as plt from sklearn.datasets import fetch_20newsgroups from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.feature_extraction.text import HashingVectorizer from sklearn.feature_selection import SelectFromModel 

इसी आउटपुट को यहाँ दिखाया गया है:



प्रत्येक विधि के लिए तीन संकेतक हैं: मूल्यांकन, प्रशिक्षण समय और परीक्षण समय।

जूलिया पैकेज - क्वांटकॉन

उदाहरण के लिए, मार्कोव चेन का उपयोग करें:

 using QuantEcon P = [0.4 0.6; 0.2 0.8]; mc = MarkovChain(P) x = simulate(mc, 100000); mean(x .== 1) # mc2 = MarkovChain(P, ["employed", "unemployed"]) simulate(mc2, 4) 

परिणाम:



उदाहरण का उद्देश्य यह देखना है कि भविष्य में एक आर्थिक स्थिति से एक व्यक्ति दूसरे में कैसे बदल जाता है। सबसे पहले, निम्नलिखित चार्ट को देखें:



आइए "खराब" स्थिति के साथ बाएं अंडाकार को देखें। 0.9 का मतलब है कि इस स्थिति वाले व्यक्ति के पास 90% शेष गरीब होने की संभावना है, और 10% मध्यम वर्ग में जाता है। इसे निम्न मैट्रिक्स द्वारा दर्शाया जा सकता है, शून्य वहां हैं जहां नोड्स के बीच कोई बढ़त नहीं है:



यह कहा जाता है कि दो राज्य, x और y, एक दूसरे से संबंधित हैं यदि सकारात्मक पूर्णांक j और k हैं, जैसे:



यदि सभी राज्य जुड़े हुए हैं, तो एक मार्कोव श्रृंखला पी को अप्रासंगिक कहा जाता है; यदि x और y प्रत्येक (x, y) के लिए रिपोर्ट किए जाते हैं । निम्न कोड इसकी पुष्टि करेगा:

 using QuantEcon P = [0.9 0.1 0.0; 0.4 0.4 0.2; 0.1 0.1 0.8]; mc = MarkovChain(P) is_irreducible(mc) 

निम्नलिखित ग्राफ एक चरम मामले का प्रतिनिधित्व करता है, क्योंकि एक गरीब व्यक्ति के लिए भविष्य की स्थिति 100% खराब होगी:



निम्नलिखित कोड भी इसकी पुष्टि करेगा, क्योंकि परिणाम गलत होगा:

 using QuantEcon P2 = [1.0 0.0 0.0; 0.1 0.8 0.1; 0.0 0.2 0.8]; mc2 = MarkovChain(P2) is_irreducible(mc2) 

ग्रेंजर कॉजेलिटी टेस्ट

ग्रेंजर कारण परीक्षण का उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या एक समय श्रृंखला एक कारक है और दूसरी भविष्यवाणी करने के लिए उपयोगी जानकारी प्रदान करती है। निम्नलिखित कोड एक चित्रण के रूप में ChickEgg नाम के डेटासेट का उपयोग करता है। डेटा सेट में टाइमस्टैम्प के साथ दो कॉलम, मुर्गियों की संख्या और अंडे की संख्या होती है:

 library(lmtest) data(ChickEgg) dim(ChickEgg) 

 [1] 54 2 

 ChickEgg[1:5,] 

 chicken egg [1,] 468491 3581 [2,] 449743 3532 [3,] 436815 3327 [4,] 444523 3255 [5,] 433937 3156 

सवाल यह है कि क्या हम अगले साल मुर्गियों की संख्या का अनुमान लगाने के लिए इस साल अंडों की संख्या का उपयोग कर सकते हैं?

यदि ऐसा है, तो मुर्गियों की संख्या अंडे की संख्या के लिए ग्रेंजर कारण होगी। यदि यह मामला नहीं है, तो हम कहते हैं कि मुर्गियों की संख्या अंडों की संख्या का ग्रेंजर कारण नहीं है। यहाँ प्रासंगिक कोड है:

 library(lmtest) data(ChickEgg) grangertest(chicken~egg, order = 3, data = ChickEgg) 

 Granger causality test Model 1: chicken ~ Lags(chicken, 1:3) + Lags(egg, 1:3) Model 2: chicken ~ Lags(chicken, 1:3) Res.Df Df F Pr(>F) 1 44 2 47 -3 5.405 0.002966 ** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 

मॉडल 1 में, हम चूजों की संख्या समझाने के लिए चिक लैग्स प्लस एग लैग्स का उपयोग करने का प्रयास करते हैं।

क्योंकि पी का मूल्य काफी छोटा है (यह 0.01 पर महत्वपूर्ण है), हम कहते हैं कि अंडों की संख्या मुर्गियों की संख्या के लिए ग्रेंजर कारण है।

निम्नलिखित परीक्षण से पता चलता है कि मुर्गियों के डेटा का उपयोग निम्नलिखित अवधि की भविष्यवाणी करने के लिए नहीं किया जा सकता है:

 grangertest(egg~chicken, order = 3, data = ChickEgg) 

 Granger causality test Model 1: egg ~ Lags(egg, 1:3) + Lags(chicken, 1:3) Model 2: egg ~ Lags(egg, 1:3) Res.Df Df F Pr(>F) 1 44 2 47 -3 0.5916 0.6238 

निम्नलिखित उदाहरण में, हम आईबीएम और एस एंड पी 500 की लाभप्रदता की जांच करते हैं ताकि यह पता लगाया जा सके कि वे दूसरे के लिए ग्रेंजर कारण हैं।

सबसे पहले, हम उपज समारोह को परिभाषित करते हैं:

 ret_f<-function(x,ticker=""){ n<-nrow(x) p<-x[,6] ret<-p[2:n]/p[1:(n-1)]-1 output<-data.frame(x[2:n,1],ret) name<-paste("RET_",toupper(ticker),sep='') colnames(output)<-c("DATE",name) return(output) } 

 >x<-read.csv("http://canisius.edu/~yany/data/ibmDaily.csv",header=T) ibmRet<-ret_f(x,"ibm") x<-read.csv("http://canisius.edu/~yany/data/^gspcDaily.csv",header=T) mktRet<-ret_f(x,"mkt") final<-merge(ibmRet,mktRet) head(final) 

  DATE RET_IBM RET_MKT 1 1962-01-03 0.008742545 0.0023956877 2 1962-01-04 -0.009965497 -0.0068887673 3 1962-01-05 -0.019694350 -0.0138730891 4 1962-01-08 -0.018750380 -0.0077519519 5 1962-01-09 0.011829467 0.0004340133 6 1962-01-10 0.001798526 -0.0027476933 

अब फ़ंक्शन को इनपुट मानों के साथ बुलाया जा सकता है। कार्यक्रम का लक्ष्य यह परीक्षण करना है कि क्या हम आईबीएम की लाभप्रदता की व्याख्या करने के लिए बाजार में उपयोग कर सकते हैं। उसी तरह, हम बाजार के राजस्व में आईबीएम के अंतराल की व्याख्या करने के लिए जाँच करते हैं:

 library(lmtest) grangertest(RET_IBM ~ RET_MKT, order = 1, data =final) 

 Granger causality test Model 1: RET_IBM ~ Lags(RET_IBM, 1:1) + Lags(RET_MKT, 1:1) Model 2: RET_IBM ~ Lags(RET_IBM, 1:1) Res.Df Df F Pr(>F) 1 14149 2 14150 -1 24.002 9.729e-07 *** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 

परिणाम बताते हैं कि S & P500 का उपयोग आईबीएम की अगली अवधि के लिए लाभप्रदता को समझाने के लिए किया जा सकता है, क्योंकि यह 0.1% तक सांख्यिकीय रूप से महत्वपूर्ण है। निम्न कोड यह देखने के लिए जांच करेगा कि क्या IBM का अंतराल S & P500 में परिवर्तन की व्याख्या करता है:

 grangertest(RET_MKT ~ RET_IBM, order = 1, data =final) 

 Granger causality test Model 1: RET_MKT ~ Lags(RET_MKT, 1:1) + Lags(RET_IBM, 1:1) Model 2: RET_MKT ~ Lags(RET_MKT, 1:1) Res.Df Df F Pr(>F) 1 14149 2 14150 -1 7.5378 0.006049 ** --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 

परिणाम बताता है कि इस अवधि के दौरान, आईबीएम के रिटर्न का उपयोग अगली अवधि के लिए एसएंडपी 500 इंडेक्स को समझाने के लिए किया जा सकता है।