उच्च आयाम डेटा

Question

के लिए निर्णय सीमा प्लॉटिंग मैं बाइनरी वर्गीकरण समस्या के लिए एक मॉडल तैयार कर रहा हूं जहां मेरा प्रत्येक डेटा पॉइंट 300 आयाम (मैं 300 सुविधाओं का उपयोग कर रहा हूं)। मैं PassiveAggressiveClassifiersklearn से उपयोग कर रहा हूं। मॉडल वास्तव में अच्छा प्रदर्शन कर रहा है।

मैं मॉडल की निर्णय सीमा को साजिश करना चाहता हूं। ऐसा मैं किस प्रकार करूं ?

डेटा की समझ प्राप्त करने के लिए, मैं इसे टीएसएनई का उपयोग करके 2 डी में प्लॉट कर रहा हूं। मैंने डेटा के आयामों को 2 चरणों में घटा दिया - 300 से 50 तक, फिर 50 से 2 तक (यह एक आम सिफारिश है)।

from sklearn.manifold import TSNE 
from sklearn.decomposition import TruncatedSVD 

X_Train_reduced = TruncatedSVD(n_components=50, random_state=0).fit_transform(X_train) 
X_Train_embedded = TSNE(n_components=2, perplexity=40, verbose=2).fit_transform(X_Train_reduced) 

#some convert lists of lists to 2 dataframes (df_train_neg, df_train_pos) depending on the label - 

#plot the negative points and positive points 
scatter(df_train_neg.val1, df_train_neg.val2, marker='o', c='red') 
scatter(df_train_pos.val1, df_train_pos.val2, marker='x', c='green') 

मैं एक सभ्य ग्राफ मिलती है: नीचे उसी के लिए कोड का टुकड़ा है।

क्या कोई तरीका है कि मैं इस साजिश में निर्णय सीमा जोड़ सकता हूं जो 300 मीटर अंतरिक्ष में मेरे मॉडल की वास्तविक निर्णय सीमा का प्रतिनिधित्व करता है?

Answer 1

एक तरीका है कि आप अपने 2 डी प्लॉट पर वोरोनोई टेस्सेलेशन लगाएं, यानी इसे 2 डी डेटा पॉइंट्स (प्रत्येक अनुमानित वर्ग लेबल के लिए अलग-अलग रंग) के निकटता के आधार पर रंग दें। Migut et al., 2015 द्वारा हालिया पेपर देखें।

यह एक बहुत आसान की तुलना में यह एक meshgrid और scikit के KNeighborsClassifier का उपयोग कर लगता है (यह एक अंत आइरिस डाटासेट के साथ उदाहरण के समाप्त करने के लिए है, अपने मॉडल/कोड के साथ पहली कुछ पंक्तियों की जगह):

import numpy as np, matplotlib.pyplot as plt 
from sklearn.neighbors.classification import KNeighborsClassifier 
from sklearn.datasets.base import load_iris 
from sklearn.manifold.t_sne import TSNE 
from sklearn.linear_model.logistic import LogisticRegression 

# replace the below by your data and model 
iris = load_iris() 
X,y = iris.data, iris.target 
X_Train_embedded = TSNE(n_components=2).fit_transform(X) 
print X_Train_embedded.shape 
model = LogisticRegression().fit(X,y) 
y_predicted = model.predict(X) 
# replace the above by your data and model 

# create meshgrid 
resolution = 100 # 100x100 background pixels 
X2d_xmin, X2d_xmax = np.min(X_Train_embedded[:,0]), np.max(X_Train_embedded[:,0]) 
X2d_ymin, X2d_ymax = np.min(X_Train_embedded[:,1]), np.max(X_Train_embedded[:,1]) 
xx, yy = np.meshgrid(np.linspace(X2d_xmin, X2d_xmax, resolution), np.linspace(X2d_ymin, X2d_ymax, resolution)) 

# approximate Voronoi tesselation on resolution x resolution grid using 1-NN 
background_model = KNeighborsClassifier(n_neighbors=1).fit(X_Train_embedded, y_predicted) 
voronoiBackground = background_model.predict(np.c_[xx.ravel(), yy.ravel()]) 
voronoiBackground = voronoiBackground.reshape((resolution, resolution)) 

#plot 
plt.contourf(xx, yy, voronoiBackground) 
plt.scatter(X_Train_embedded[:,0], X_Train_embedded[:,1], c=y) 
plt.show() 

ध्यान दें कि आपकी निर्णय सीमा को सही तरीके से साजिश करने के बजाय, यह आपको मोटे तौर पर अनुमान लगाएगा जहां सीमा झूठ बोलनी चाहिए (विशेष रूप से कुछ डेटा बिंदु वाले क्षेत्रों में, वास्तविक सीमा इस से विचलित हो सकती है)। यह विभिन्न वर्गों से संबंधित दो डेटा बिंदुओं के बीच एक रेखा तैयार करेगा, लेकिन इसे बीच में रखेगा (वास्तव में इस मामले में उन बिंदुओं के बीच निर्णय सीमा होने की गारंटी है, लेकिन यह आवश्यक नहीं है कि बीच में हो) ।

सही निर्णय सीमा का बेहतर अनुमान लगाने के लिए कुछ प्रयोगात्मक दृष्टिकोण भी हैं, उदाहरण के लिए this one on github