Un mémorandum de SHOGUN, une bibliothèque d'apprentissage automatique disponible sur ici. La méthode d'installation est décrite ici.
Un exemple d'étiquette binaire qui est une étiquette binaire. Représenté par -1 ou 1. Il peut être créé à partir d'un tableau ou d'un fichier CSV.
from modshogun import BinaryLabels
#Générez au hasard 5 étiquettes
label = BinaryLabels(5)
label.get_num_labels()
→ 5
label.get_values()
→ array([ 2.00000000e+000, 2.00000000e+000, 1.38338381e-322,0.00000000e+000, 0.00000000e+000])
from modshogun import CSVFile
#Peut être créé à partir d'un fichier CSV préparé à l'avance
label_from_csv = BinaryLabels(CSVFile(file_path))
Il peut être créé à partir d'une matrice numpy ou d'un fichier CSV. Notez qu'une quantité de caractéristiques est exprimée dans une colonne et non sur une ligne.
from modshogun import RealFeatures
import numpy as np
#Matrice aléatoire 3x3
feat_arr = np.random.rand(3, 3)
→ array([[ 0.02818103, 0.72093824, 0.92727711],
[ 0.66853622, 0.14594737, 0.90522684],
[ 0.97941639, 0.14188234, 0.80854797]])
#Initialisation des fonctionnalités réelles
features = RealFeatures(feat_arr)
#Affichage du montant de la fonction
features.get_feature_matrix(features)
→ array([[ 0.02818103, 0.72093824, 0.92727711],
[ 0.66853622, 0.14594737, 0.90522684],
[ 0.97941639, 0.14188234, 0.80854797]])
#Obtenir la quantité de fonctionnalités d'une colonne spécifique
features.get_feature_vector(1)
→array([ 0.72093824, 0.14594737, 0.14188234])
#Types de fonctionnalités(Nombre de rangées)
features.get_num_features()
→3
#Nombre de fonctionnalités(Le nombre de colonnes)
features.get_num_vectors()
→3
from modshogun import CSVFile
#Bien sûr, cela peut également être lu à partir d'un fichier CSV.
feats_from_csv = RealFeatures(CSVFile(file_path))
Un exemple avec un noyau chi-carré.
from modshogun import Chi2Kernel, RealFeatures, CSVFile
#Données d'entraînement
feats_train = RealFeatures(CSVFile(file_path))
#Données de test
feats_test = RealFeatures(CSVFile(file_path))
#Largeur du noyau
width = 1.4
#size_paramètres de cache
size_cache = 10
#Génération de noyau
kernel = Chi2Kernel(feats_train, feats_train, width, size_cache)
#Formation du noyau
kernel.init(feats_train, feats_test)
4.SVMLight
Classification par machine vectorielle de support utilisant SVMLight
from modshogun import SVMLight, CSVFile, BinaryLabels, RealFeatures, Chi2Kernel
feats_train = RealFeatures(CSVFile(train_data_file_path))
feats_test = RealFeatures(CSVFile(test_data_file_path))
kernel = Chi2Kernel(feats_train, feats_train, 1.4, 10)
labels = BinaryLabels(CSVFile(label_traindat_path))
C = 1.2
epsilon = 1e-5
num_threads = 1
svm = SVMLight(C, kernel, labels)
svm.set_epsilon(epsilon)
svm.parallel.set_num_threads(num_threads)
svm.train()
kernel.init(feats_train, feats_test)
res = svm.apply().get_labels()
res
→array(Libellé de résultat)
Importez la classe CrossValidation. Pour initialiser CrossValidation
from modshogun import LibLinear, BinalyLabels, RealFeatures, CrossValidationSplitting, ContingencyTableEvaluation, CSVFile, ACCURACY
#Trieur
classifier = LibLinear(L2R_L2LOSS_SVC)
#Valeur de la fonctionnalité
features = RealFeatures(CSVFile(feature_file_path))
#étiquette
labels = BinalyLabels(CSVFile(label_file_path))
#SplittingStrategy semble être en mesure de spécifier comment fractionner les données. Je n'en sais pas grand-chose. Dans cet exemple, il est divisé en cinq.
splitting_strategy = CrossValidationSplitting(labels, 5)
#Classe de critères d'évaluation. ACCURACY est simplement une constante déclarée dans EContingencyTableMeasureType.
evaluation_criterium = ContingencyTableEvaluation(ACCURACY)
#Classe de validation croisée.
cross_validation = CrossValidation(classifier, features, labels. splitting_strategy, evaluation_criterium)
cross_validation.set_autolock(False)
#Réglage du nombre de répétitions
cross_validation.set_num_runs(10)
#95%Définition de l'intervalle de confiance? je ne suis pas sûr
cross_validation.set_conf_int_alpha(0.05)
#La valeur de retour est la classe CEvaluationResult
result = cross_validation.evaluate()
#Vous pouvez obtenir la valeur moyenne des résultats des tests croisés.
print result.mean
#Cliquez ici si vous souhaitez afficher tout le reste
print result.print_result()
Si vous pouvez le faire jusqu'à présent, la recherche par grille peut être effectuée assez facilement. GridSearchModelSelection de la classe CModelSelection
Si vous le passez et l'initialisez, vous pouvez déjà rechercher la grille.
---Omettre jusqu'au point d'initialiser la classe CrossValidation avec LibLinear---
from modshogun import ModelSelectionParameters, R_EXP
from modsghoun import GridSearchModelSelection
#Un objet qui stocke les paramètres à modifier
param_tree_root = ModelSelectionParameters()
#Paramètre C1
C1 = ModelSelectionParameters("C1")
param_tree_root.append_child(c1)
build_values()Valeur minimale, valeur maximale, pas(Augmentation des paramètres)Mettre en place. R_EXP(indice),R_LOG(Journal),R_LINEAR(linéaire)Il existe trois types, mais les détails sont inconnus.
c1.build_values(-1.0, 0.0, R_EXP)
c2 = ModelSelectionParameters("C2")
param_tree_root.append_child(c2)
c2.build_values(-1.0, 0.0, R_EXP)
#Imprimez ici_tree()Lorsque vous exécutez param_tree_Vous pouvez voir que la racine a une structure arborescente.
param_tree_root.print_tree()
→root with
with values: vector=[0.5,1]
with values: vector=[0.5,1]
#Générer une classe de recherche de grille
model_selection = GridSearchModelSelection(cross_validation, param_tree_root)
#Cela déterminera automatiquement les meilleurs paramètres et retournera un objet de la classe CParameterCombination. De plus, si vous passez True comme argument, la combinaison de chaque paramètre et du résultat sera sortie.
best_parameters = model_selection.select_model()
#Il est également possible d'appliquer les meilleurs paramètres renvoyés en tant que paramètres de classificateur ou de modèle.
best_parameters.apply_to_machine(classifier)
result = cross_validation.evaluate()
Les objets peuvent être sauvegardés et chargés en utilisant les fonctions save_serializable () et load_serializable () de CSGObject, qui est la base de presque toutes les classes.
from modshogun import SerializableAsciiFile
from modshogun import MulticlassLabels
from numpy import array
save_labels = MulticlassLabels(array([1.0, 2, 3]))
#Paramètre de nom de fichier Prend en charge csv et asc
save_file = SerializableAsciiFile("foo.csv", "w")
#Enregistrer le fichier
save_labels.save_serializable(save_file)
load_file = SerializableAsciiFile("foo.csv", "r")
load_labels = MulticlassLabels()
load_labels.load_serializable(load_file)
→[ 1. 2. 3.]
Vous pouvez cracher des journaux pour chaque objet. Transmettez MSG_DEBUG pour le journal de débogage et MSG_ERROR pour le journal des erreurs uniquement. Déclaré avec EMessageType.
from modshogun import MSG_DEBUG, MSG_ERROR
from modshogun import Chi2Kernel
from modshogun import LibSVM
kernel = Chi2Kernel()
svm = LibSVM()
kernel.io.set_loglevel(MSG_DEBUG)
svm.io.set_loglevel(MSG_ERROR)
C'est un peu compliqué, donc si vous avez des demandes, veuillez commenter.
Recommended Posts