Hoppa till innehåll

Support Vector Machine (SVM) klassificering i Python

Jag kommer att implementera en SVM-algoritm (Support Vector Machine) för klassificering i denna handledning. Jag kommer att visualisera datauppsättningen, hitta de bästa hyperparametrarna att använda, träna en modell och utvärdera resultaten. Support Vector Machine är en snabb algoritm som kan användas för att klassificera datauppsättningar med linjär separation, SVM:s kan vara hjälpfulla vid textkategorisering.

Support Vector Machine kan användas för binära klassificeringsproblem och för flerklassproblem. Support Vector Machine är en linjär metod och fungerar därför inte bra för datauppsättningar som har en icke-linjär struktur. Support Vector Machine kan användas med icke-linjär data om man tillämpar kärntricket. Support Vector Machine försöker konstruera centrerade hyperplan mellan klasser, algoritmen vill hitta hyperplan som har den högsta marginalen mellan grupper av datapunkter. Datapunkterna närmast hyperplanet kallas supportvektorer.

SVM, hyperplan och supportvektorer

Support Vector Machine-algoritmen är enkel att använda, den är snabb och den resulterande modellen tar inte mycket hårddiskutrymme i anspråk. Scikit-learn har tre modeller för SVM som skiljer sig åt i implementeringen: SVC, NuSVC och LinearSVC. SVC är baserad på libsvm, passningstiden skalas åtminstone kvadratiskt med antalet datapunkter. NuSVC, liknar SVC men använder en parameter för att kontrollera antalet supportvektorer. LinearSVC liknar SVC, men den använder en linjär kärna och implementeras i termer av liblinear snarare än libsvm. Jag kommer att använda LinearSVC eftersom den skalar bäst till ett stora datauppsättningar.

Datauppsättning och bibliotek

Jag kommer att använda datauppsättningen Iris (ladda ner) i den här handledningen. Iris-uppsättningen består av 150 blommor, varje blomma har fyra indatavärden och ett målvärde. Jag använder också följande bibliotek: pandas, joblib, numpy, matplotlib och scikit-learn.

Python-modul

Jag har inkluderat all kod i en fil, ett projekt består normalt av många filer (moduler). Du kan skapa namnområden genom att placera filer i mappar och du importerar en fil med dess namnområden plus dess filnamn. En fil med namnet common.py i mappen annytab/learning importeras som import annytab.learn.common. Jag kommer att förklara mer om koden i avsnitten nedan.

  1. # Import libraries
  2. import pandas
  3. import joblib
  4. import numpy as np
  5. import matplotlib.pyplot as plt
  6. import sklearn.model_selection
  7. import sklearn.svm
  8. import sklearn.metrics
  9. import sklearn.pipeline
  11. # Visualize data set
  12. def visualize_dataset(ds):
  13.     
  14.     # Print first 5 rows in data set
  15.     print('--- First 5 rows ---\n')
  16.     print(ds.head())
  18.     # Print the shape
  19.     print('\n--- Shape of data set ---\n')
  20.     print(ds.shape)
  22.     # Print class distribution
  23.     print('\n--- Class distribution ---\n')
  24.     print(ds.groupby('species').size())
  26.     # Box plots
  27.     plt.figure(figsize = (12, 8))
  28.     ds.boxplot()
  29.     #plt.show()
  30.     plt.savefig('plots\\iris-boxplots.png')
  31.     plt.close()
  33.     # Scatter plots (4 subplots in 1 figure)
  34.     figure = plt.figure(figsize = (12, 8))
  35.     grouped_dataset = ds.groupby('species')
  36.     values = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
  37.     for i, value in enumerate(values):
  38.         plt.subplot(2, 2, i + 1) # 2 rows and 2 columns
  39.         for name, group in grouped_dataset:
  40.             plt.scatter(group.index, ds[value][group.index], label=name)
  41.         plt.ylabel(value)
  42.         plt.xlabel('index')
  43.         plt.legend()
  44.     #plt.show()
  45.     plt.savefig('plots\\iris-scatterplots.png')
  46.     
  47. # Train and evaluate
  48. def train_and_evaluate(X, Y):
  49.     
  50.     # Create a model
  51.     model = sklearn.svm.LinearSVC(penalty='l1', loss='squared_hinge', dual=False, tol=0.0001, C=0.4, multi_class='ovr', 
  52.                                   fit_intercept=True, intercept_scaling=1, class_weight=None, verbose=0, random_state=None, max_iter=10000)
  54.     # Train the model on the whole data set
  55.     model.fit(X, Y)
  57.     # Save the model (Make sure that the folder exists)
  58.     joblib.dump(model, 'models\\svm.jbl')
  60.     # Evaluate on training data
  61.     print('\n-- Training data --\n')
  62.     predictions = model.predict(X)
  63.     accuracy = sklearn.metrics.accuracy_score(Y, predictions)
  64.     print('Accuracy: {0:.2f}'.format(accuracy * 100.0))
  65.     print('Classification Report:')
  66.     print(sklearn.metrics.classification_report(Y, predictions))
  67.     print('Confusion Matrix:')
  68.     print(sklearn.metrics.confusion_matrix(Y, predictions))
  69.     print('')
  70.     # Evaluate with 10-fold CV
  71.     print('\n-- 10-fold CV --\n')
  72.     predictions = sklearn.model_selection.cross_val_predict(model, X, Y, cv=10)
  73.     accuracy = sklearn.metrics.accuracy_score(Y, predictions)
  74.     print('Accuracy: {0:.2f}'.format(accuracy * 100.0))
  75.     print('Classification Report:')
  76.     print(sklearn.metrics.classification_report(Y, predictions))
  77.     print('Confusion Matrix:')
  78.     print(sklearn.metrics.confusion_matrix(Y, predictions))
  80. # Perform a grid search to find the best hyperparameters
  81. def grid_search(X, Y):
  83.     # Create a pipeline
  84.     clf_pipeline = sklearn.pipeline.Pipeline([
  85.         ('m', sklearn.svm.LinearSVC(loss='squared_hinge', tol=0.0001, multi_class='ovr', dual=False, class_weight=None, verbose=0, random_state=None, max_iter=10000))
  86.         ])
  88.     # Set parameters (name in pipeline + name of parameter)
  89.     parameters = { 
  90.         'm__penalty': ('l1', 'l2'), 
  91.         'm__C': (0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0), 
  92.         'm__fit_intercept': (False, True),
  93.         'm__intercept_scaling': (0.5, 1, 2)
  94.         }
  96.     # Create a grid search classifier
  97.     gs_classifier = sklearn.model_selection.GridSearchCV(clf_pipeline, parameters, cv=10, iid=False, n_jobs=2, scoring='accuracy', verbose=1)
  98.     
  99.     # Start a search (Warning: can take a long time if the whole dataset is used)
  100.     gs_classifier = gs_classifier.fit(X, Y)
  102.     # Print results
  103.     print('---- Results ----')
  104.     print('Best score: ' + str(gs_classifier.best_score_))
  105.     for name in sorted(parameters.keys()):
  106.         print('{0}: {1}'.format(name, gs_classifier.best_params_[name]))
  108. # Predict and evaluate on test data
  109. def predict_and_evaluate(X, Y):
  111.     # Load the model
  112.     model = joblib.load('models\\svm.jbl')
  114.     # Make predictions
  115.     predictions = model.predict(X)
  117.     # Print results
  118.     print('\n---- Results ----')
  119.     for i in range(len(predictions)):
  120.         print('Input: {0}, Predicted: {1}, Actual: {2}'.format(X[i], predictions[i], Y[i]))
  121.     accuracy = sklearn.metrics.accuracy_score(Y, predictions)
  122.     print('\nAccuracy: {0:.2f}'.format(accuracy * 100.0))
  123.     print('\nClassification Report:')
  124.     print(sklearn.metrics.classification_report(Y, predictions))
  125.     print('Confusion Matrix:')
  126.     print(sklearn.metrics.confusion_matrix(Y, predictions))
  128. # The main entry point for this module
  129. def main():
  131.     # Load data set (includes header values)
  132.     dataset = pandas.read_csv('files\\iris.csv')
  134.     # Visualize data set
  135.     visualize_dataset(dataset)
  137.     # Slice data set in values and targets (2D-array)
  138.     X = dataset.values[:,0:4]
  139.     Y = dataset.values[:,4]
  141.     # Split data set in train and test (use random state to get the same split every time, and stratify to keep balance)
  142.     X_train, X_test, Y_train, Y_test = sklearn.model_selection.train_test_split(X, Y, test_size=0.2, random_state=1, stratify=Y)
  144.     # Make sure that data still is balanced
  145.     print('\n--- Class balance ---\n')
  146.     print(np.unique(Y_train, return_counts=True))
  147.     print(np.unique(Y_test, return_counts=True))
  149.     # Perform a grid search
  150.     #grid_search(X, Y)
  152.     # Train and evaluate
  153.     #train_and_evaluate(X_train, Y_train)
  155.     # Predict on test set
  156.     predict_and_evaluate(X_test, Y_test)
  158. # Tell python to run main method
  159. if __name__ == "__main__": main()

Läs in och visualisera datauppsättningen

Datauppsättningen laddas med pandas genom att använda en relativ sökväg, använd en absolut sökväg om dina filer lagras utanför projektet. Vi vill visualisera datauppsättningen för att se till att den är balanserad och vi vill lära oss mer om datauppsättningen. Det är viktigt att ha en balanserad datauppsättning vid klassificering, varje klass tränas lika frekvent med en balanserad träningsuppsättning. Vi kan plotta en datauppsättning för att hitta mönster, ta bort extremvärden och för att besluta om de lämpligaste algoritmerna att använda.

  1. # Load data set (includes header values)
  2. dataset = pandas.read_csv('files\\iris.csv')
  4. # Visualize data set
  5. visualize_dataset(dataset)
  7. --- First 5 rows ---
  8.    sepal_length  sepal_width  petal_length  petal_width      species
  9. 0           5.1          3.5           1.4          0.2  Iris-setosa
  10. 1           4.9          3.0           1.4          0.2  Iris-setosa
  11. 2           4.7          3.2           1.3          0.2  Iris-setosa
  12. 3           4.6          3.1           1.5          0.2  Iris-setosa
  13. 4           5.0          3.6           1.4          0.2  Iris-setosa
  15. --- Shape of dataset ---
  16. (150, 5)
  18. --- Class distribution ---
  19. species
  20. Iris-setosa        50
  21. Iris-versicolor    50
  22. Iris-virginica     50
  23. dtype: int64
Iris spridningsdiagram

Dela upp datauppsättningen

Jag måste först dela upp värden i datauppsättningen för att få indata (X) och utdata (Y), de första 4 kolumnerna är indata och den sista kolumnen utgör målvärdet. Jag delar upp datauppsättningen i en träningsuppsättning och en testuppsättning, 80 % är för träning och 20 % för test. Jag vill se till att datauppsättningarna fortfarande är balanserade efter denna delning och jag använder därför en stratify-parameter. 

  1. # Slice data set in values and targets (2D-array)
  2. X = dataset.values[:,0:4]
  3. Y = dataset.values[:,4]
  5. # Split data set in train and test (use random state to get the same split every time, and stratify to keep balance)
  6. X_train, X_test, Y_train, Y_test = sklearn.model_selection.train_test_split(X, Y, test_size=0.2, random_state=1, stratify=Y)
  8. # Make sure that data still is balanced
  9. print('\n--- Class balance ---\n')
  10. print(np.unique(Y_train, return_counts=True))
  11. print(np.unique(Y_test, return_counts=True))

Baslinjeprestanda

Vår datauppsättning har 150 blommor och 50 blommor i varje klass, vår träningsuppsättning har samma balans. En slumpvis förutsägelse kommer att vara korrekt i 33% (50/150) av alla fall och vår modell måste ha en noggrannhet som är bättre än 33 % för att vara användbar.

Rutnätssökning

Jag gör en rutnätsökning för att hitta de bästa parametrarna för träning. En rutnätsökning kan ta lång tid att utföra på stora datauppsättningar, men det är antagligen snabbare jämfört med en manuell process. Resultatet från denna process visas nedan och jag kommer att använda dessa parametrar när jag tränar modellen.

  1. # Perform a grid search
  2. grid_search(X, Y)
  4. Fitting 10 folds for each of 108 candidates, totalling 1080 fits
  5. [Parallel(n_jobs=2)]: Using backend LokyBackend with 2 concurrent workers.
  6. [Parallel(n_jobs=2)]: Done 968 tasks      | elapsed:    2.9s
  7. [Parallel(n_jobs=2)]: Done 1080 out of 1080 | elapsed:    3.1s finished
  9. ---- Results ----
  10. Best score: 0.9666666666666668
  11. m__C: 0.4
  12. m__fit_intercept: True
  13. m__intercept_scaling: 1
  14. m__penalty: l1

Träning och utvärdering

Jag tränar modellen genom att använda parametrarna från rutnätsökningen och sparar modellen till en fil med joblib. Utvärderingen görs på träningsuppsättningen och med korsvalidering. Korsvalideringsutvärderingen ger en antydan om modellens generaliseringsprestanda. Jag hade 95 % exakthet på träningsdata och 95 % exakthet med tiofaldig korsvalidering.

  1. # Train and evaluate
  2. train_and_evaluate(X_train, Y_train)
  4. -- Training data --
  5. Accuracy: 95.00
  6. Classification Report:
  7.                  precision    recall  f1-score   support
  9.     Iris-setosa       1.00      1.00      1.00        40
  10. Iris-versicolor       0.95      0.90      0.92        40
  11.  Iris-virginica       0.90      0.95      0.93        40
  13.        accuracy                           0.95       120
  14.       macro avg       0.95      0.95      0.95       120
  15.    weighted avg       0.95      0.95      0.95       120
  17. Confusion Matrix:
  18. [[40  0  0]
  19.  [ 0 36  4]
  20.  [ 0  2 38]]
  23. -- 10-fold CV --
  24. Accuracy: 95.00
  25. Classification Report:
  26.                  precision    recall  f1-score   support
  28.     Iris-setosa       1.00      1.00      1.00        40
  29. Iris-versicolor       0.93      0.93      0.93        40
  30.  Iris-virginica       0.93      0.93      0.93        40
  32.        accuracy                           0.95       120
  33.       macro avg       0.95      0.95      0.95       120
  34.    weighted avg       0.95      0.95      0.95       120
  36. Confusion Matrix:
  37. [[40  0  0]
  38.  [ 0 37  3]
  39.  [ 0  3 37]]

Test och utvärdering

Det sista steget i denna process är att göra förutsägelser och utvärdera prestationer avseende testdata. Jag läser in modellen, gör förutsägelser och skriver ut resultaten. X-variabeln är en 2D-array, om du vill göra en förutsägelse för en blomma måste du ange indata så här: X = np.array ([[7.3, 2.9, 6.3, 1.8]]).

  1. # Predict on test set
  2. predict_and_evaluate(X_test, Y_test)
  4. ---- Results ----
  5. Input: [7.3 2.9 6.3 1.8], Predicted: Iris-virginica, Actual: Iris-virginica
  6. Input: [4.9 3.1 1.5 0.1], Predicted: Iris-setosa, Actual: Iris-setosa
  7. Input: [5.1 2.5 3.0 1.1], Predicted: Iris-versicolor, Actual: Iris-versicolor
  8. Input: [4.8 3.4 1.6 0.2], Predicted: Iris-setosa, Actual: Iris-setosa
  9. Input: [5.0 3.5 1.6 0.6], Predicted: Iris-setosa, Actual: Iris-setosa
  10. Input: [5.1 3.5 1.4 0.2], Predicted: Iris-setosa, Actual: Iris-setosa
  11. Input: [6.2 3.4 5.4 2.3], Predicted: Iris-virginica, Actual: Iris-virginica
  12. Input: [6.4 2.7 5.3 1.9], Predicted: Iris-virginica, Actual: Iris-virginica
  13. Input: [5.6 2.8 4.9 2.0], Predicted: Iris-virginica, Actual: Iris-virginica
  14. Input: [6.8 2.8 4.8 1.4], Predicted: Iris-versicolor, Actual: Iris-versicolor
  15. Input: [5.4 3.9 1.3 0.4], Predicted: Iris-setosa, Actual: Iris-setosa
  16. Input: [5.5 2.3 4.0 1.3], Predicted: Iris-versicolor, Actual: Iris-versicolor
  17. Input: [6.8 3.0 5.5 2.1], Predicted: Iris-virginica, Actual: Iris-virginica
  18. Input: [6.0 2.2 4.0 1.0], Predicted: Iris-versicolor, Actual: Iris-versicolor
  19. Input: [5.7 2.5 5.0 2.0], Predicted: Iris-virginica, Actual: Iris-virginica
  20. Input: [5.7 4.4 1.5 0.4], Predicted: Iris-setosa, Actual: Iris-setosa
  21. Input: [7.1 3.0 5.9 2.1], Predicted: Iris-virginica, Actual: Iris-virginica
  22. Input: [6.1 2.8 4.0 1.3], Predicted: Iris-versicolor, Actual: Iris-versicolor
  23. Input: [4.9 2.4 3.3 1.0], Predicted: Iris-versicolor, Actual: Iris-versicolor
  24. Input: [6.1 3.0 4.9 1.8], Predicted: Iris-virginica, Actual: Iris-virginica
  25. Input: [6.4 2.9 4.3 1.3], Predicted: Iris-versicolor, Actual: Iris-versicolor
  26. Input: [5.6 3.0 4.5 1.5], Predicted: Iris-versicolor, Actual: Iris-versicolor
  27. Input: [4.9 3.1 1.5 0.1], Predicted: Iris-setosa, Actual: Iris-setosa
  28. Input: [4.4 2.9 1.4 0.2], Predicted: Iris-setosa, Actual: Iris-setosa
  29. Input: [6.5 3.0 5.2 2.0], Predicted: Iris-virginica, Actual: Iris-virginica
  30. Input: [4.9 2.5 4.5 1.7], Predicted: Iris-virginica, Actual: Iris-virginica
  31. Input: [5.4 3.9 1.7 0.4], Predicted: Iris-setosa, Actual: Iris-setosa
  32. Input: [4.8 3.0 1.4 0.1], Predicted: Iris-setosa, Actual: Iris-setosa
  33. Input: [6.3 3.3 4.7 1.6], Predicted: Iris-versicolor, Actual: Iris-versicolor
  34. Input: [6.5 2.8 4.6 1.5], Predicted: Iris-versicolor, Actual: Iris-versicolor
  36. Accuracy: 100.00
  38. Classification Report:
  39.                  precision    recall  f1-score   support
  41.     Iris-setosa       1.00      1.00      1.00        10
  42. Iris-versicolor       1.00      1.00      1.00        10
  43.  Iris-virginica       1.00      1.00      1.00        10
  45.        accuracy                           1.00        30
  46.       macro avg       1.00      1.00      1.00        30
  47.    weighted avg       1.00      1.00      1.00        30
  49. Confusion Matrix:
  50. [[10  0  0]
  51.  [ 0 10  0]
  52.  [ 0  0 10]]
Etiketter:

Lämna ett svar

Din e-postadress kommer inte publiceras. Obligatoriska fält är märkta *