[PYTHON] Comment utiliser le shogun

Un mémorandum de SHOGUN, une bibliothèque d'apprentissage automatique disponible sur ici. La méthode d'installation est décrite ici.

1. Étiquette


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))

2. Caractéristiques


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))

3. Noyau


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)

5. Test croisé


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()

6. Recherche de grille


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()

7. Enregistrez et chargez le modèle créé


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.]

8. Journal des crachats


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)

en conclusion


C'est un peu compliqué, donc si vous avez des demandes, veuillez commenter.

Recommended Posts

Comment utiliser le shogun
Comment utiliser xml.etree.ElementTree
Comment utiliser Python-shell
Remarques sur l'utilisation de tf.data
Comment utiliser virtualenv
Comment utiliser Seaboan
Comment utiliser la correspondance d'image
Comment utiliser Pandas 2
Comment utiliser Virtualenv
Comment utiliser numpy.vectorize
Comment utiliser pytest_report_header
Comment utiliser partiel
Comment utiliser Bio.Phylo
Comment utiliser SymPy
Comment utiliser x-means
Comment utiliser WikiExtractor.py
Comment utiliser IPython
Comment utiliser virtualenv
Comment utiliser Matplotlib
Comment utiliser iptables
Comment utiliser numpy
Comment utiliser TokyoTechFes2015
Comment utiliser venv
Comment utiliser le dictionnaire {}
Comment utiliser Pyenv
Comment utiliser la liste []
Comment utiliser python-kabusapi
Comment utiliser OptParse
Comment utiliser le retour
Comment utiliser pyenv-virtualenv
Comment utiliser imutils
Comment utiliser Qt Designer
Comment utiliser la recherche triée
[gensim] Comment utiliser Doc2Vec
python3: Comment utiliser la bouteille (2)
Comprendre comment utiliser django-filter
Comment utiliser le générateur
[Python] Comment utiliser la liste 1
Comment utiliser FastAPI ③ OpenAPI
Comment utiliser Python Argparse
Comment utiliser IPython Notebook
Comment utiliser Pandas Rolling
[Note] Comment utiliser virtualenv
Comment utiliser les dictionnaires redis-py
Python: comment utiliser pydub
[Python] Comment utiliser checkio
[Aller] Comment utiliser "... (3 périodes)"
Comment faire fonctionner GeoIp2 de Django
[Python] Comment utiliser input ()
Comment utiliser le décorateur
[Introduction] Comment utiliser open3d
Comment utiliser Python lambda
Comment utiliser Jupyter Notebook
[Python] Comment utiliser virtualenv
python3: Comment utiliser la bouteille (3)
python3: Comment utiliser la bouteille
Comment utiliser Google Colaboratory
Comment utiliser les octets Python