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）变量。其余条目表示稀疏向量（例如，＆＃39; 1：15＆＃39;表示在索引1处，X值为15）。

我试图根据kNN估计来计算预测的Y.我是稀疏矩阵的新手。我发现一些文档说我可以使用稀疏矩阵来估计kNN：

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

我不知道如何创建X和Y矩阵，然后如何在给定kNN估计的情况下预测Y.对像我这样的初学者的任何帮助都会非常感激。

Answer 1

简短的说法是你使用的格式会让你感到悲伤。长期以来，仍然绝对有可能进行这种转换，只需要相当数量的goo-code即可。您需要做的第一件事是在第一次出现的空格中拆分每个字符串，并将其余字符串分组为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。我也强烈建议尝试另一种模式。在这种情况下，Logistic回归可能不会给你比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]

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

2 个答案: