使用scikit-learn在Python中使用稀疏矩阵进行kNN估计

Question

我有这样的数据：

line1 = '-0.9821 1:15 2:20 4:10 8:10'
line2 = '0.1235 1:15 2:20 6:10 10:10'
line3 = '0.2132 1:15 3:20 5:10 9:10'
line4 = '0.328 2:15 4:20 6:10 7:12 8:16 10:10'
line5 = '0.973 2:15 3:20 6:10 8:12 9:10'

每行中的第一个条目是输出（Y）变量。其余条目表示稀疏向量（例如，"1:15"表示在索引1处，X值为15）。

我正在尝试基于kNN估计来计算预测的Y。我是稀疏矩阵的新手。我发现了一些文件，说我可以使用稀疏矩阵来估计kNN:

knn = neighbors.KNeighborsClassifier(n_neighbors=2, weights='distance')
knn.fit(X, Y)

我不知道如何创建X和Y矩阵，以及如何在给定kNN估计的情况下预测Y。对像我这样的初学者有任何帮助都将不胜感激。

Answer 1

简而言之，您使用的格式会给您带来相当大的悲伤。问题是，仍然完全有可能进行这种转换，你只需要相当多的谷歌代码。你需要做的第一件事是在第一次出现空间时拆分每个字符串，并将其余字符串分组到x中。

from scipy import sparse
y, _, x = line1.partition(" ")
y = float(y)
x = convert_to_csc(x, shape)
def convert_to_csc(x, shape):
    sparse_matrix = sparse.csc_matrix(shape)
    for entry in x.split():
        index, value = entry.split(:)
        sparse_matrix[index] = value
    return sparse_matrix

我将把剩下的留给读者练习，但剩下的应该很琐碎。如果以后有机会，我建议您使用更健壮的格式。

为了清楚起见，在本例中聚合x和y将在上面的代码中得到X和Y。至于之后的预测，sklearn使用fit_transform范式，即首先是fit，然后是transform。在你调用上面的fit之后，你可以得到这样的预测：

prediction = knn.transform(example_x)

我仍然认为您应该考虑在本机上使用sklearn的SVR。我还强烈建议尝试另一种模式。在这种情况下，逻辑回归可能不会给你带来比SVR更好的性能（尽管我可能错了），但它将成为你想添加的任何增强或一般数据调整的绝佳试验台，如果不是因为计算效率之外的原因的话。你所说的数据集上的SVR不会很快运行。

Answer 2

使用稀疏数组来存储数据。将字符串值解析为稀疏数组，然后在knn 上进行拟合和预测

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
line1 = '-0.9821 1:15 2:20 4:10 8:10'
line2 = '0.1235 1:15 2:20 6:10 10:10'
line3 = '0.2132 1:15 3:20 5:10 9:10'
line4 = '0.328 2:15 4:20 6:10 7:12 8:16 10:10'
line5 = '0.973 2:15 3:20 6:10 8:12 9:10'
data=[line1,line2,line3,line4,line5]
sparseMatrix = csr_matrix((5, 15), 
                      dtype = np.float).toarray()
row=0
for item in data:
    for entry in item.split(' '):
        if ':' in entry:
            index,value = entry.split(':')
            sparseMatrix[row,int(index)]=value
        else:
            sparseMatrix[row,0]=entry
    row+=1

X=sparseMatrix[:,1:15]
y=(sparseMatrix[:,0]*10).astype(int)
knn=KNeighborsClassifier(algorithm='auto',
                     leaf_size=10,
                     metric='minkowski',
                     metric_params=None,
                     n_jobs=1,
                     n_neighbors=3,
                     p=2,
                     weights='uniform')
 X_train, X_test, y_train, y_test= train_test_split(X,y,test_size=0.2, random_state=21)
knn.fit(X_train,y_train)
train_accuracy = knn.score(X_train, y_train)
test_accuracy=knn.score(X_test,y_test)
print(train_accuracy,test_accuracy)
for item in X:
   prediction=knn.predict([item])
   print(item,prediction)
y_pred=knn.predict(X_test)
print(confusion_matrix(y_test,y_pred))
print(classification_report(y_test,y_pred))  

输出：

 0.25 0.0
 [15. 20.  0. 10.  0.  0.  0. 10.  0.  0.  0.  0.  0.  0.] [-9]
 [15. 20.  0.  0.  0. 10.  0.  0.  0. 10.  0.  0.  0.  0.] [-9]
 [15.  0. 20.  0. 10.  0.  0.  0. 10.  0.  0.  0.  0.  0.] [-9]
 [ 0. 15.  0. 20.  0. 10. 12. 16.  0. 10.  0.  0.  0.  0.] [-9]
 [ 0. 15. 20.  0.  0. 10.  0. 12. 10.  0.  0.  0.  0.  0.] [-9]