一类 SVM 算法耗时过长

Posted 2023-02-15

【中文标题】一类 SVM 算法耗时过长

【英文标题】：One Class SVM algorithm taking too long

【发布时间】：2020-06-28 15:26:00

【问题描述】：

下面的数据显示了我的数据集的一部分，用于检测异常

    describe_file   data_numbers    index
0   gkivdotqvj      7309.0          0
1   hpwgzodlky      2731.0          1
2   dgaecubawx      0.0             2
3   NaN             0.0             3
4   lnpeyxsrrc      0.0             4

我使用 One Class SVM 算法检测异常

from pyod.models.ocsvm import OCSVM
random_state = np.random.RandomState(42)     
outliers_fraction = 0.05
classifiers = 
        'One Classify SVM (SVM)':OCSVM(kernel='rbf', degree=3, gamma='auto', coef0=0.0, tol=0.001, nu=0.5, shrinking=True, cache_size=200, verbose=False, max_iter=-1, contamination=outliers_fraction)


X = data['data_numbers'].values.reshape(-1,1)   

for i, (clf_name, clf) in enumerate(classifiers.items()):
    clf.fit(X)
    # predict raw anomaly score
    scores_pred = clf.decision_function(X) * -1

    # prediction of a datapoint category outlier or inlier
    y_pred = clf.predict(X)
    n_inliers = len(y_pred) - np.count_nonzero(y_pred)
    n_outliers = np.count_nonzero(y_pred == 1)

    # copy of dataframe
    dfx = data[['index', 'data_numbers']]
    dfx['outlier'] = y_pred.tolist()
    IX1 =  np.array(dfx['data_numbers'][dfx['outlier'] == 0]).reshape(-1,1)
    OX1 =  dfx['data_numbers'][dfx['outlier'] == 1].values.reshape(-1,1)         
    print('OUTLIERS : ',n_outliers,'INLIERS : ',n_inliers, clf_name)    
    # threshold value to consider a datapoint inlier or outlier
    threshold = stats.scoreatpercentile(scores_pred,100 * outliers_fraction) 

tOut = stats.scoreatpercentile(dfx[dfx['outlier'] == 1]['data_numbers'], np.abs(threshold))

y = dfx['outlier'].values.reshape(-1,1)
def severity_validation():
    tOUT10 = tOut+(tOut*0.10)    
    tOUT23 = tOut+(tOut*0.23)
    tOUT45 = tOut+(tOut*0.45)
    dfx['test_severity'] = "None"
    for i, row in dfx.iterrows():
        if row['outlier']==1:
            if row['data_numbers'] <=tOUT10:
                dfx['test_severity'][i] = "Low Severity" 
            elif row['data_numbers'] <=tOUT23:
                dfx['test_severity'][i] = "Medium Severity" 
            elif row['data_numbers'] <=tOUT45:
                dfx['test_severity'][i] = "High Severity" 
            else:
                dfx['test_severity'][i] = "Ultra High Severity" 

severity_validation()

from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(dfx[['index','data_numbers']], dfx.outlier, test_size=0.25, 
                                                    stratify=dfx.outlier, random_state=30)

#Instantiate Classifier
normer = preprocessing.Normalizer()
svm1 = svm.SVC(probability=True, class_weight=1: 10)

cached = mkdtemp()
memory = Memory(cachedir=cached, verbose=3)
pipe_1 = Pipeline(steps=[('normalization', normer), ('svm', svm1)], memory=memory)

cv = skl.model_selection.KFold(n_splits=5, shuffle=True, random_state=42)

param_grid = [ "svm__kernel": ["linear"], "svm__C": [0.5], "svm__kernel": ["rbf"], "svm__C": [0.5], "svm__gamma": [5] ]
grd = GridSearchCV(pipe_1, param_grid, scoring='roc_auc', cv=cv)

#Training
y_pred = grd.fit(X_train, Y_train).predict(X_test)
rmtree(cached)

#Evaluation
confmatrix = skl.metrics.confusion_matrix(Y_test, y_pred)
print(confmatrix)
Y_pred = grd.fit(X_train, Y_train).predict_proba(X_test)[:,1] 
def plot_roc(y_test, y_pred):
    fpr, tpr, thresholds = skl.metrics.roc_curve(y_test, y_pred, pos_label=1)
    roc_auc = skl.metrics.auc(fpr, tpr)
    plt.figure()
    lw = 2
    plt.plot(fpr, tpr, color='darkorange', lw=lw, label='ROC curve (area =0:.2f)'.format(roc_auc))
    plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
    plt.xlim([0.0, 1.0])
    plt.ylim([0.0, 1.05])
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate')
    plt.title('Receiver operating characteristic example')
    plt.legend(loc="lower right")
    plt.show();
plot_roc(Y_test, Y_pred) 

我的数据集非常大，有数百万行。结果我只能运行几十万行。 代码工作得很好，但是它需要的时间太长了，所以我希望得到一些优化的建议，这样我运行得更快。

【问题讨论】：

rbf 内核将永远在大于几万行的任何东西上运行。换内核。改变算法。购买更强大的机器。

看看EllipticEnvelope 或IsolationForest，它们都是用于异常/异常值检测的非常快的算法

@Sergey Bushmanov，我将尝试这两种其他算法。关于这一点，你能告诉我你会改变什么，让它工作得更快一点吗？

我不熟悉pyod（异常值检测的OD？），但sklearn的支持向量机有rbf以外的内核。我将从linear 开始，看看是否满足您的需求，然后继续使用更复杂的内核。关于算法。我将首先尝试了解什么构成一维分布的异常值（它是一维，对吗？）。如果它是正常的，计算 σ，并从平均值中查看比 2-3σ 更远的值就足够了。在这里，即使是一个信封也太过分了。如果它不正常，我会尝试调查该分布类型的异常值。

如果你坚持使用带有rbf内核的一类SVM，出于某种原因，在几十万个样本的代表性样本上训练然后预测异常值也不差。

【参考方案1】：

SVM 训练时间随样本数量的增加而严重下降，通常为 O(n^2) 或更差。因此它不适用于具有数百万样本的数据集。可以在here 找到一些用于探索的示例代码。

我建议您改用 IsolationForest，它既快速又高效。

如果您想使用 SVM，请对您的数据集进行二次抽样，以便拥有 10-100k 个样本。线性核的训练速度也将明显快于 RBF，但在大量样本时的可扩展性仍然很差。