introduction

1. La modélisation prédictive est probablement l'un des domaines les plus passionnants de l'analyse de données.
2. Il a attiré beaucoup d'attention ces dernières années en raison de la disponibilité massive de données dans de nombreux secteurs verticaux.
3. Il est très couramment utilisé dans les domaines de l'exploration de données pour prévoir les tendances futures.

1. Dans la modélisation prédictive, nous devons collecter des données avec des réponses connues pour entraîner notre modèle.
2. Une fois que nous avons créé ce modèle, nous le validons à l'aide de certaines métriques, puis nous l'utilisons pour prédire les valeurs futures.
3. Nous pouvons utiliser de nombreux types d'algorithmes différents pour créer un modèle prédictif.
4. Nous utiliserons les SVM pour construire des modèles linéaires et non linéaires.
5. Un modèle prédictif est construit à l'aide d'un certain nombre de fonctionnalités susceptibles d'influencer le comportement du système.
6. Par exemple, pour estimer les conditions météorologiques, nous pouvons utiliser divers types de données, telles que la température, la pression barométrique, les précipitations et d'autres
   processus atmosphériques. De même, lorsque nous traitons avec d'autres types de systèmes, nous devons décider des facteurs susceptibles d'influencer son comportement et les inclure dans le vecteur de caractéristiques avant d'entraîner notre modèle.

1. SVM: modèles d'apprentissage supervisé que nous pouvons utiliser pour créer des classificateurs et des régresseurs.
2. Un SVM résout un système d'équations mathématiques et trouve la meilleure frontière de séparation entre deux ensembles de points.

Se préparer

Visualisons nos données pour comprendre le problème à résoudre. Avant de créer le SVM, comprenons nos données.

Jeu de données utilisé: téléchargez le fichier 'data_multivar' depuis https://github.com/appyavi/Dataset

Voyons comment visualiser les données:

1. Importation des bibliothèques et des données:

import numpy as np
import matplotlib.pyplot as plt
import utilities
# Load input data
input_file = 'data_multivar.txt'
X, y = utilities.load_data(input_file)

# Load multivar data in the input file
def load_data(input_file):
    X = []
    y = []
    with open(input_file, 'r') as f:
        for line in f.readlines():
            data = [float(x) for x in line.split(',')]
            X.append(data[:-1])
            y.append(data[-1])
    X = np.array(X)
    y = np.array(y)
    return X, y

class_0 = np.array([X[i] for i in range(len(X)) if y[i]==0])
class_1 = np.array([X[i] for i in range(len(X)) if y[i]==1])

plt.figure()
plt.scatter(class_0[:,0], class_0[:,1], facecolors='black', edgecolors='black', marker='s')
plt.scatter(class_1[:,0], class_1[:,1], facecolors='None', edgecolors='black', marker='s')
plt.title('Input data')
plt.show()

Comment faire

Voyons comment créer un classificateur linéaire à l'aide de SVM:

1. Nous devons diviser notre ensemble de données en ensembles de données d'entraînement et de test.

from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=5)

params = {'kernel': 'linear'}
classifier = SVC(**params, gamma='auto')

classifier.fit(X_train, y_train)
Out: SVC(gamma='auto', kernel='linear')

utilities.plot_classifier(classifier, X_train, y_train, 'Training dataset')
plt.show()

       

y_test_pred = classifier.predict(X_test)
utilities.plot_classifier(classifier, X_test, y_test, 'Test dataset')
plt.show()

       

        the classifier boundaries on the input data are clearly identified.
       

from sklearn.metrics import classification_report
target_names = ['Class-' + str(int(i)) for i in set(y)]
print("\n" + "#"*30)
print("\nClassifier performance on training dataset\n")
print(classification_report(y_train, classifier.predict(X_train),target_names=target_names))
print("#"*30 + "\n")

       

print("#"*30)
print("\nClassification report on test dataset\n")
print(classification_report(y_test, y_test_pred, target_names=target_names))
print("#"*30 + "\n")

       

1. Les SVM sont un ensemble de méthodes d'apprentissage supervisé qui peuvent être utilisées à la fois pour la classification et la régression.
2. Etant donné deux classes de motifs multidimensionnels linéairement séparables, parmi tous les hyperplans séparateurs possibles, l'algorithme SVM détermine celui capable de séparer les classes avec la plus grande marge possible.
3. La marge est la distance minimale entre les points des deux classes de l'ensemble d'apprentissage et l'hyperplan identifié.
4. La maximisation de la marge est liée à la généralisation.
5. Si les modèles d'ensemble d'apprentissage sont classés avec une grande marge, vous pouvez espérer que même les modèles d'ensemble de test proches de la limite entre les classes sont gérés correctement.
6. Dans ce qui suit, vous pouvez voir trois lignes (l1, l2 et l3). La ligne l1 ne sépare pas les deux classes, la ligne l2 les sépare, mais avec une petite marge, tandis que la ligne l3 maximise la distance entre les deux classes:

8. Les coordonnées des objets sont mappées dans un espace appelé espace de caractéristiques à l'aide de fonctions non linéaires, appelées fonctions caractéristiques.

9. Cet espace est hautement multidimensionnel, dans lequel les deux classes peuvent être séparées avec un classificateur linéaire. Ainsi, l'espace initial est remappé dans le nouvel espace, à quel point le classificateur est identifié puis renvoyé dans l'espace initial.

Il y a plus

Les SVM constituent une classe de machines d'apprentissage récemment introduites dans la littérature. Les SVM dérivent de concepts concernant la théorie statistique de l'apprentissage et présentent des propriétés de généralisation théorique.