Je n'ai pas trouvé les informations japonaises de hmmlearn, j'ai donc résumé l'utilisation minimale.

Il s'agit de Tutorial + α.

hmmlearn est une bibliothèque Python de type scicit-learn qui réalise HMM (Hidden Markov Model). http://hmmlearn.readthedocs.org

installer

L'installation suivante est requise.

Python a été confirmé pour fonctionner avec 3 séries.
Python >= 2.6
NumPy(tested to work with >= 1.9.3)
SciPy(tested to work with >= 0.16.0)
scikit-learn >= 0.16

Installation

hmmlearn peut être installé avec pip.

$ pip install -U --user hmmlearn

Comment utiliser

Cette fois, nous utiliserons le HMM gaussien.

Qu'est-ce que le HMM gaussien?

Il s'agit d'un modèle de Markov caché dans lequel la sortie du modèle est une valeur continue.

Paramètres requis

Créez une instance de modèle par la méthode suivante.

from hmmlearn import hmm

model = hmm.GaussianHMM(n_components=3, covariance_type="full")

L'argument n_componets spécifie le nombre d'états et covariance_type spécifie le type de covariance.

Les attributs qui doivent être spécifiés sont les suivants.

startprob_
Spécifiez la probabilité de transition de l'état initial. (Nombre d'états * 1)
transmat_
Spécifiez la probabilité de transition d'état. (Nombre d'états * Nombre d'états)
means_
Spécifiez la moyenne de chaque état. (Nombre d'états * Nombre de fonctionnalités)
covars_
Spécifiez la co-distribution. (Selon le type de covariance)

Cette fois, dans l'exemple, le nombre d'états est mis à 5 et les paramètres sont saisis.

import numpy as np
from hmmlearn import hmm


startprob = np.array([0.0, 0.1, 0.8, 0.1, 0.0])
transmat = np.array([[0.9, 0.1, 0.0, 0.0, 0.0],
                     [0.4, 0.3, 0.3, 0.0, 0.0],
                     [0.1, 0.2, 0.4, 0.3, 0.0],
                     [0.0, 0.1, 0.3, 0.3, 0.3],
                     [0.0, 0.0, 0.3, 0.1, 0.6]])

means = np.array([[1.0, 1.0],
                  [2.0, 2.0],
                  [3.0, 3.0],
                  [4.0, 4.0],
                  [5.0, 5.0]])

covars = 0.1 * np.tile(np.identity(2), (5, 1, 1))

model = hmm.GaussianHMM(n_components=5, covariance_type="full")

model.startprob_ = startprob
model.transmat_ = transmat
model.means_ = means
model.covars_ = covars

Prévoir

Prédisons la série d'états avec des exemples de données.

>>> X, Z = model.sample(10)

>>> print(X)
[[ 3.42184743  2.84259768]
 [ 1.83591345  2.60456015]
 [ 3.0610817   3.67242462]
 [ 3.88970955  3.94599461]
 [ 4.99679025  5.21663028]
 [ 5.05294062  4.80691392]
 [ 5.25836686  5.08960965]
 [ 5.49849546  5.00469741]
 [ 5.31740667  4.77140169]
 [ 4.1283215   5.06959465]]

>>> print(Z)
[2 1 2 3 4 4 4 4 4 4]

C'est le résultat que la série d'états est prévue comme Z lorsque les données d'échantillon sont X.

Prédisons la série d'états à partir de données non échantillonnées. Utilisez la méthode prédire pour prédire une série d'états basée sur une série de sortie.

>>> model.predict([[1.3], [2.0], [4.3], [4.2]])
array([1, 2, 3, 3])

Apprentissage

Je vais vous montrer comment estimer les paramètres par apprentissage.

L'entraînement est effectué par la méthode d'ajustement et l'estimation des paramètres est effectuée. Cette fois, X est utilisé comme données d'entraînement.

import numpy as np
from hmmlearn import hmm

model = hmm.GaussianHMM(n_components=5, covariance_type="full")
X = np.array([[1.2], [2.3], [1.1], [4.2], [3.3]])
model.fit(X)

Vous pouvez confirmer que les paramètres ont été saisis par apprentissage.

>>> model.startprob_
array([  2.06946712e-292,   0.00000000e+000,   3.13184994e-003,
         1.27702612e-300,   9.96868150e-001])
        
>>> model.means_
array([[ 2.3       ],
       [ 4.2       ],
       [ 1.10171369],
       [ 3.3       ],
       [ 1.15485602]])
       
>>> model.covars_
array([[[ 0.01      ]],
       [[ 0.01      ]],
       [[ 0.05488646]],
       [[ 0.01      ]],
       [[ 0.00797925]]])
       
>>> model.transmat_
array([[  1.27206138e-223,   1.57268167e-192,   1.79623272e-001,
          9.10036066e-211,   8.20376728e-001],
       [  5.88225536e-075,   2.07494122e-025,   1.88590294e-063,
          1.00000000e+000,   5.18696363e-119],
       [  1.71368655e-002,   9.82863134e-001,   6.65061859e-190,
          9.25847733e-045,   3.48719264e-293],
       [  1.79414943e-074,   2.06495338e-025,   3.28132831e-011,
          1.00000000e+000,   1.50081312e-010],
       [  5.48560165e-001,   4.51439835e-001,   1.32144625e-190,
          6.49028218e-045,   0.00000000e+000]])

Évaluation

Trouvez la probabilité logarithmique pour évaluer le modèle.

La méthode du score évalue le modèle. Spécifiez la série de sortie pour l'évaluation comme X.

>>> X = np.array([[3.2], [2.4], [3.1], [3.2], [3.0], [3.9], [4.0]])
>>> model.score(X)
0.11878179338435844

Exporter et importer

Exporte et importe le modèle.

Vous pouvez exporter le modèle en utilisant joblib de sklearn.

>>> from sklearn.externals import joblib
>>> joblib.dump(remodel, "filename.pkl")
["filename.pkl"]

De même, il peut être lu par la méthode load en utilisant joblib.

>>> from sklearn.externals import joblib
>>> joblib.load('filename.pkl')
GaussianHMM(algorithm='viterbi', covariance_type='full', covars_prior=0.01,
      covars_weight=1, init_params='stmc', means_prior=0, means_weight=0,
      min_covar=0.001, n_components=5, n_iter=10, params='stmc',
      random_state=None, startprob_prior=1.0, tol=0.01, transmat_prior=1.0,
      verbose=False)

Comment utiliser hmmlearn, une bibliothèque Python qui réalise des modèles de Markov cachés