def __init__(self,
ticker,
chunks=9,
delta=0,
n_hidden_states=5,
n_latency_days=10,
n_steps_frac_change=10,
n_steps_frac_high=30,
n_steps_frac_low=10,
n_iter=100,
verbose=False,
prediction_date=None):
self.total_score = 0
self.verbose = verbose
self.ticker = ticker
self.n_latency_days = n_latency_days
self.hmm = GMMHMM(n_components=n_hidden_states, n_iter=n_iter)
self.chunks = chunks
self.delta = delta
self.prediction_date = prediction_date
self.fetch_training_data()
self._compute_all_possible_outcomes(n_steps_frac_change,
n_steps_frac_high,
n_steps_frac_low)
def trainModelGMM(X, lengths, states, num_gaus):
model = GMMHMM(n_components=states, n_mix=num_gaus,n_iter=1000,verbose=True).fit(X,lengths)
print('Mixture Models + HMM')
print(model.predict(X))
print(model.monitor_.converged)
print(model.monitor_)
print(model.score(X, lengths))
def _defineModelParameters(self):
# Define the model:
#self.model = GaussianHMM(n_components=2,
# covariance_type="full",
# n_iter=200,
# verbose=True)
self.model = GMMHMM(n_components=2,
covariance_type="full",
n_iter=20,
verbose=True)
class HMMStats(Stats):
def __init__(self, stats: Stats = None):
super().__init__()
if stats:
self.__dict__.update(deepcopy(stats.__dict__))
n_iter = 100 # maximum number of iterations
tol = 0.1 # minimum value of log-likelyhood
covariance_type = 'diag'
self.onshmm = GMMHMM(
n_components=20, # the number of gaussian mixtures
n_mix=30, # the number of hidden states
covariance_type=covariance_type,
n_iter=n_iter,
tol=tol,
verbose=True,
random_state=self.seed())
self.durhmm = GMMHMM(n_components=2,
n_mix=3,
covariance_type=covariance_type,
n_iter=n_iter,
tol=tol,
verbose=True,
random_state=self.seed())
def get_random_onset_diff(self, k=1):
x, _state_seq = self.onshmm.sample(k, random_state=self.seed())
return x[:, 0]
def get_random_duration_ratio(self, k=1):
x, _state_seq = self.durhmm.sample(k, random_state=self.seed())
return x[:, 0]
def train_on_filled_stats(self):
super().train_on_filled_stats()
# train the hmms
def train(hmm, data, lengths):
hmm.fit(data, lengths)
if (hmm.monitor_.converged):
print("hmm converged!")
else:
print("hmm did not converge!")
print("Training duration hmm...")
train(self.durhmm, self.dur_ratios, self.dur_lengths)
print("Training onset hmm...")
train(self.onshmm, self.ons_diffs, self.ons_lengths)
def __repr__(self):
return str(type(self))
def __init__(self, _model):
super(GMMHMMTrainer, self).__init__(_model)
hmm_params = _model['hmmParams']
gmm_params = _model['gmmParams']
n_iter = _model.get('nIter', 50)
transmat = np.array(hmm_params['transMat'])
transmat_prior = np.array(hmm_params['transMatPrior'])
n_component = hmm_params['nComponent']
startprob = np.array(hmm_params['startProb'])
startprob_prior = np.array(hmm_params['startProbPrior'])
n_mix = gmm_params['nMix']
covariance_type = gmm_params['covarianceType']
gmms = gmm_params.get('gmms', None)
gmm_obj_list = []
if not gmms:
gmm_obj_list = None
else:
for gmm in gmms:
gmm_obj = GMM(n_components=gmm['nComponent'], covariance_type=gmm['covarianceType'])
gmm_obj.covars_ = np.array(gmm['covars'])
gmm_obj.means_ = np.array(gmm['means'])
gmm_obj.weights_ = np.array(gmm['weights'])
gmm_obj_list.append(gmm_obj)
self.gmmhmm = GMMHMM(n_components=n_component, n_mix=n_mix, gmms=gmm_obj_list,
n_iter=n_iter, covariance_type=covariance_type,
transmat=transmat, transmat_prior=transmat_prior,
startprob=startprob, startprob_prior=startprob_prior)
def __init__(n_components=N_COMPONENTS,
n_mix=N_MIX,
n_iters=N_ITERS,
cov_type=COV_TYPE,
algorithm=ALGORITHM,
tol=TOL,
startpr_prior=STARTPROB_PRIOR,
trans_prior=TRANSMAT_PRIOR,
init_params=INIT_PARAMS,
params=PARAMS,
verbose=VERBOSE,
class_names=CONDITION_CLASSES):
self.model = {}
for class_name in class_names:
self.model[class_name] = GMMHMM(n_components=N_COMPONENTS,
n_mix=N_MIX,
n_iter=N_ITERS,
covariance_type=COV_TYPE,
algorithm=ALGORITHM,
tol=TOL,
transmat_prior=TRANSMAT_PRIOR,
startprob_prior=STARTPROB_PRIOR,
init_params=INIT_PARAMS,
params=PARAMS,
verbose=VERBOSE)
def initialize(phones):
models = {}
start_prob = np.array([1.0, 0.0, 0.0])
transmat = np.zeros((3, 3))
for i in range(3):
for j in range(i, 3):
trans = 1 / (3 - i)
transmat[i][j] = trans
for i in phones.keys():
new_hmm = GMMHMM(n_components=3,
n_mix=5,
params='tmc',
init_params='mc')
new_hmm.startprob_ = start_prob
new_hmm.transmat_ = transmat
models[i] = new_hmm
return models
def classifyByGMMHMM(seq, models, configs):
Y = []
for config in configs:
_rawdata_type = config["logType"]
_event_type = config["eventType"]
_motion_type = config["motionType"]
_sound_type = config["soundType"]
_location_type = config["locationType"]
d = Dataset(
rawdata_type=_rawdata_type,
event_type=_event_type,
motion_type=_motion_type,
sound_type=_sound_type,
location_type=_location_type
)
# Initiation of data need prediction.
y = np.array(d._convetNumericalSequence(seq))
Y.append(y)
_GMMHMMs = []
for model in models:
_GMMs = []
for gmm in model["gmmParams"]["params"]:
_GMM = GMM(
n_components=model["nMix"],
covariance_type=model["covarianceType"]
)
_GMM.covars_ = np.array(gmm["covars"])
_GMM.means_ = np.array(gmm["means"])
_GMM.weights_ = np.array(gmm["weights"])
_GMMs.append(_GMM)
_GMMHMM = GMMHMM(
n_components=model["nComponent"],
n_mix=model["nMix"],
startprob=np.array(model["hmmParams"]["startProb"]),
transmat=np.array(model["hmmParams"]["transMat"]),
gmms=_GMMs,
covariance_type=model["covarianceType"]
)
_GMMHMMs.append(_GMMHMM)
results = []
# for _GMMHMM in _GMMHMMs:
# res = _GMMHMM.score(Y)
# results.append(res)
for i in range(0, len(models)):
res = _GMMHMMs[i].score(Y[i])
results.append(res)
return results
def __init__(self,
ticker,
n_hidden_states=5,
n_latency_days=10,
n_steps_frac_change=50,
n_steps_frac_high=30,
n_steps_frac_low=10,
n_iter=1000,
verbose=False):
self.verbose = verbose
self.ticker = ticker
self.n_latency_days = n_latency_days
self.hmm = GMMHMM(n_components=n_hidden_states, n_iter=n_iter)
self.fetch_training_data()
self.fetch_latest_data() # to predict
self._compute_allall_possible_outcomes(n_steps_frac_change,
n_steps_frac_high,
n_steps_frac_low)
def __init__(self, _model):
super(GMMHMMTrainer, self).__init__(_model)
hmm_params = _model['hmmParams']
gmm_params = _model['gmmParams']
n_iter = _model.get('nIter', 50)
transmat = np.array(hmm_params['transMat'])
transmat_prior = np.array(hmm_params['transMatPrior'])
n_component = hmm_params['nComponent']
startprob = np.array(hmm_params['startProb'])
startprob_prior = np.array(hmm_params['startProbPrior'])
n_mix = gmm_params['nMix']
covariance_type = gmm_params['covarianceType']
gmms = gmm_params.get('gmms', None)
gmm_obj_list = []
if not gmms:
gmm_obj_list = None
else:
for gmm in gmms:
gmm_obj = GMM(n_components=gmm['nComponent'],
covariance_type=gmm['covarianceType'])
gmm_obj.covars_ = np.array(gmm['covars'])
gmm_obj.means_ = np.array(gmm['means'])
gmm_obj.weights_ = np.array(gmm['weights'])
gmm_obj_list.append(gmm_obj)
self.gmmhmm = GMMHMM(n_components=n_component,
n_mix=n_mix,
gmms=gmm_obj_list,
n_iter=n_iter,
covariance_type=covariance_type,
transmat=transmat,
transmat_prior=transmat_prior,
startprob=startprob,
startprob_prior=startprob_prior)
def __init__(self, stats: Stats = None):
super().__init__()
if stats:
self.__dict__.update(deepcopy(stats.__dict__))
n_iter = 100 # maximum number of iterations
tol = 0.1 # minimum value of log-likelyhood
covariance_type = 'diag'
self.onshmm = GMMHMM(
n_components=20, # the number of gaussian mixtures
n_mix=30, # the number of hidden states
covariance_type=covariance_type,
n_iter=n_iter,
tol=tol,
verbose=True,
random_state=self.seed())
self.durhmm = GMMHMM(n_components=2,
n_mix=3,
covariance_type=covariance_type,
n_iter=n_iter,
tol=tol,
verbose=True,
random_state=self.seed())
def train_GMMs(emotions, trng_data, GMM_config, pickle_path, use_pickle = False):
"""
Utility function to train GMMHMMs based on entered confiuration and training data. Returns a dictionary of trained GMMHMM objects and also pickles them for use without training.
"""
emo_machines = {}
if not use_pickle:
for emo in emotions:
emo_machines[emo] = GMMHMM(n_components=GMM_config[emo]["n_components"],n_mix=GMM_config[emo]["n_mix"])
if trng_data[emo]:
#print np.shape(trng_data[emo])
emo_machines[emo].fit(trng_data[emo])
pickle.dump(emo_machines, open(pickle_path,"wb"))
else:
emo_machines = pickle.load(open(pickle_path,"rb"))
return emo_machines
def hmm_train(features):
gmmhmm = GMMHMM(n_components=30, n_mix=8)
gmmhmm.startprob_ = np.array([
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0
])
l = np.identity(30) * 0.95
for i in range(l.shape[0] - 1):
l[i, i + 1] = 0.05
l[-1, -1] = 1
gmmhmm.transmat_ = l
gmmhmm.fit(features)
preds = gmmhmm.predict(features)
print(preds)
def fit_HMM(feedback, n_components=2, hmm='GaussianHMM'):
assert hmm == 'GaussianHMM' or hmm == 'GMMHMM', "You have to choose between GaussianHMM or GMMHMM"
y = feedback[:, 1]
if hmm == 'GaussianHMM':
model = GaussianHMM(n_components=n_components)
else:
model = GMMHMM(n_components=n_components)
model.fit(y.reshape(len(y), 1))
states = model.predict(y.reshape(len(y), 1))
mus = np.array(model.means_)
sigmas = np.array(np.sqrt(np.array([np.diag(model.covars_[0]), np.diag(model.covars_[1])])))
P = np.array(model.transmat_)
return y, states, mus, sigmas, P
def get_GMMs(labels, trng_data=None, GMM_config=None,
model_path="models/gmmhmm.pkl",
from_file=False):
"""
Utility function to train or load GMMHMMs based on entered
configuration and training data.
Returns a dictionary of trained GMMHMM objects.
"""
gmms = {}
if not from_file:
for label in labels:
gmms[label] = GMMHMM(
n_components=GMM_config[label]["n_components"],
n_mix=GMM_config[label]["n_mix"])
if trng_data[label]:
# print np.shape(trng_data[wav_file])
gmms[label].fit(np.vstack(trng_data[label]))
# emo_machines[wav_file].fit(trng_data[wav_file])
pickle.dump(gmms, open(model_path, "wb"))
else:
gmms = pickle.load(open(model_path, "rb"))
return gmms
def __init__(self, _models):
super(GMMHMMClassifier, self).__init__(_models)
self.gmmhmms = {}
self.predict_data_ = None
for label, value in _models.iteritems():
_model = value['param']
hmm_params = _model['hmmParams']
gmm_params = _model['gmmParams']
n_iter = _model.get('nIter', 50)
transmat = np.array(hmm_params['transMat'])
transmat_prior = np.array(hmm_params['transMatPrior'])
n_component = hmm_params['nComponent']
startprob = np.array(hmm_params['startProb'])
startprob_prior = np.array(hmm_params['startProbPrior'])
n_mix = gmm_params['nMix']
covariance_type = gmm_params['covarianceType']
gmms = gmm_params.get('gmms', None)
gmm_obj_list = []
if not gmms:
gmm_obj_list = None
else:
for gmm in gmms:
gmm_obj = GMM(n_components=gmm['nComponent'], covariance_type=gmm['covarianceType'])
gmm_obj.covars_ = np.array(gmm['covars'])
gmm_obj.means_ = np.array(gmm['means'])
gmm_obj.weights_ = np.array(gmm['weights'])
gmm_obj_list.append(gmm_obj)
gmmhmm = GMMHMM(n_components=n_component, n_mix=n_mix, gmms=gmm_obj_list,
n_iter=n_iter, covariance_type=covariance_type,
transmat=transmat, transmat_prior=transmat_prior,
startprob=startprob, startprob_prior=startprob_prior)
self.gmmhmms[label] = {'gmmhmm': gmmhmm, 'status_set': value['status_set']}
def get_trained_pipelines(train):
train_dfs = np.array_split(train, n_subsets)
int_name = 0
pipelines = []
for train_subset in train_dfs:
try:
pipe_pca = make_pipeline(StandardScaler(),
PrincipalComponentAnalysis(n_components=n_components),
GMMHMM(n_components=n_components, covariance_type='full', n_iter=150, random_state=7),
)
pipe_pca.fit(train_subset[ features ])
train['state'] = pipe_pca.predict(train[ features ])
results = pd.DataFrame(train.groupby(by=['state'])['return'].mean().sort_values())
results['new_state'] = list(range(n_components))
results.columns = ['mean', 'new_state']
results = results.reset_index()
results['name'] = int_name
int_name = int_name + 1
pipelines.append( [pipe_pca, results] )
except Exception as e:
#print('make trained pipelines exception', e)
pass
return pipelines
samples_raw_2, labels_2, _ = FileReader.read(FILE_PATH_2)
samples_raw_2 = samples_raw_2[(labels_2.ravel() == 0) | (labels_2.ravel() == 1), :]
labels_2 = labels_2[(labels_2.ravel() == 0) | (labels_2.ravel() == 1)]
samples_raw_3, labels_3, _ = FileReader.read(FILE_PATH_3)
samples_raw_3 = samples_raw_3[:, 0:6]
window_size = 100
X_train, X_test, y_train, y_test = train_test_split(np.vstack([samples_raw_1, samples_raw_2, samples_raw_3]),
np.vstack([labels_1, labels_2, labels_3]), train_size=0.6)
samples_healthy = X_train[y_train.ravel() == 0, :]
samples_unhealthy = X_train[y_train.ravel() == 1, :]
model_healthy = GMMHMM()
model_unhealthy = GMMHMM()
seqs, lengths = PreProcessor.split2sequences(samples_healthy, window_size)
model_healthy.fit(seqs, lengths)
seqs, lengths = PreProcessor.split2sequences(samples_unhealthy, window_size)
model_unhealthy.fit(seqs, lengths)
seqs, lengths = PreProcessor.split2sequences(X_test, window_size)
accuracy = 0
for i in range(0, len(lengths)):
ll_healthy, post_healthy = model_healthy.score_samples(seqs[i*window_size:(i+1)*window_size,:])
ll_unhealthy, post_unhealthy = model_unhealthy.score_samples(seqs[i*window_size:(i+1)*window_size,:])
print("[" + str(ll_unhealthy) + "|" + str(ll_unhealthy) + "]")
def fit(self, X, Y):
'''
creates a separate hmm for each label in Y
'''
labels = []
for l in Y:
if l not in labels:
labels.append(l)
labels = sorted(labels)
self.n_class = len(labels)
print(' doing something ')
# try:
# X = np.load('X_mfcc.npy')
#
# except
X = self.extract_features(X)
np.save('X_mfcc.npy', X)
print(' * finished extracting features * ')
self.hmm_set = []
self.hmm_set.append(GMMHMM(n_components=self.n_states,
n_mix=self.n_mixtures,
verbose=True,
n_iter=100) )
self.hmm_set.append(GMMHMM(n_components=self.n_states,
n_mix=self.n_mixtures,
verbose=True,
n_iter=100) )
self.hmm_set.append(GMMHMM(n_components=self.n_states,
n_mix=self.n_mixtures,
verbose=True,
n_iter=100) )
self.hmm_set.append(GMMHMM(n_components=self.n_states,
n_mix=self.n_mixtures,
verbose=True,
n_iter=100) )
print(self.hmm_set)
class_data = [[] for _ in range(self.n_class)]
lengths = [[] for _ in range(self.n_class)]
print(' * preprocessing * ')
for i, data in enumerate(X):
class_data[int(Y[i])].append(data)
lengths[int(Y[i])].append(data.shape[0])
print(' * finished preprocessing * ')
for ci in range(self.n_class):
print('fitting {}'.format(ci))
to_fit = np.concatenate(class_data[ci])
print(to_fit[0].shape)
print(to_fit.shape)
self.hmm_set[ci].fit(to_fit, lengths[ci])
if np.any(self.hmm_set[ci].covars_ <= 0):
print('some covariances are 0. model might be a poor fit')
self.hmm_set[ci].covars_ = np.abs(self.hmm_set[ci].covars_) + 1e-10
if np.any(self.hmm_set[ci].transmat_ == np.nan):
raise ArithmeticError('transition probabilities are unndefined. '
'Try reducing the number of states')
class GMMHMMTrainer(BaseTrainer):
'''A wrapper to GMMHMM
Attributes
----------
_model: init params
gmmhmm: hmmlearn GMMHMM instance
params_: params after fit
train_data_: current train datas
'''
def __init__(self, _model):
super(GMMHMMTrainer, self).__init__(_model)
hmm_params = _model['hmmParams']
gmm_params = _model['gmmParams']
n_iter = _model.get('nIter', 50)
transmat = np.array(hmm_params['transMat'])
transmat_prior = np.array(hmm_params['transMatPrior'])
n_component = hmm_params['nComponent']
startprob = np.array(hmm_params['startProb'])
startprob_prior = np.array(hmm_params['startProbPrior'])
n_mix = gmm_params['nMix']
covariance_type = gmm_params['covarianceType']
gmms = gmm_params.get('gmms', None)
gmm_obj_list = []
if not gmms:
gmm_obj_list = None
else:
for gmm in gmms:
gmm_obj = GMM(n_components=gmm['nComponent'],
covariance_type=gmm['covarianceType'])
gmm_obj.covars_ = np.array(gmm['covars'])
gmm_obj.means_ = np.array(gmm['means'])
gmm_obj.weights_ = np.array(gmm['weights'])
gmm_obj_list.append(gmm_obj)
self.gmmhmm = GMMHMM(n_components=n_component,
n_mix=n_mix,
gmms=gmm_obj_list,
n_iter=n_iter,
covariance_type=covariance_type,
transmat=transmat,
transmat_prior=transmat_prior,
startprob=startprob,
startprob_prior=startprob_prior)
def __repr__(self):
return '<GMMHMMTrainer instance>\n\tinit_models:%s\n\tparams:%s\n\ttrain_data:%s' % (
self._model, self.params_, self.train_data_)
def fit(self, train_data):
train_data = np.array(train_data)
self.gmmhmm.fit(train_data)
gmms_ = []
for gmm in self.gmmhmm.gmms_:
gmms_.append({
'nComponent': gmm.n_components,
'nIter': gmm.n_iter,
'means': gmm.means_.tolist(),
'covars': gmm.covars_.tolist(),
'weights': gmm.weights_.tolist(),
'covarianceType': gmm.covariance_type,
})
self.train_data_ += train_data.tolist()
self.params_ = {
'nIter': self.gmmhmm.n_iter,
'hmmParams': {
'nComponent': self.gmmhmm.n_components,
'transMat': self.gmmhmm.transmat_.tolist(),
'transMatPrior': self.gmmhmm.transmat_prior.tolist(),
'startProb': self.gmmhmm.startprob_.tolist(),
'startProbPrior': self.gmmhmm.startprob_prior.tolist(),
},
'gmmParams': {
'nMix': self.gmmhmm.n_mix,
'covarianceType': self.gmmhmm.covariance_type,
'gmms': gmms_,
}
}
class_vectors = dataset[cname]
# use Multinominal HMM
# dataset[cname] = list([kmeans.predict(v).reshape(-1,1) for v in dataset[cname]])
# hmm = hmmlearn.hmm.MultinomialHMM(
# n_components=20, random_state=0, n_iter=1000, verbose=True
# )
hmm = GMMHMM(
n_components=5,
n_mix=1,
random_state=42,
n_iter=1000,
verbose=True,
params='mctw',
init_params='mc',
# startprob_prior = np.array([1.0,0.0,0.0,0.0,0.0]),
# transmat_prior = np.array([
# [0.7,0.3,0.0,0.0,0.0],
# [0.0,0.7,0.3,0.0,0.0],
# [0.0,0.0,0.7,0.3,0.0],
# [0.0,0.0,0.0,0.7,0.3],
# [0.0,0.0,0.0,0.0,1.0],
# ])
)
hmm.startprob_ = np.array([1.0, 0.0, 0.0, 0.0, 0.0])
# hmm.transmat_ = np.array([
# [0.7,0.3,0.0,0.0,0.0],
# [0.0,0.7,0.3,0.0,0.0],
# [0.0,0.0,0.7,0.3,0.0],
# [0.0,0.0,0.0,0.7,0.3],
# [0.0,0.0,0.0,0.0,1.0],
def newtrain(speakers, name):
#folder="C:/Anaconda codes/speaker reco/something new/for hack/add new people/"
folder = "C:/Anaconda codes/Hackverse/servermodel/clientfiles/"
s = list(speakers)
l = len(speakers)
#name= input("enter your name")
speakers.append(name)
new_person = speakers[l]
#rint(new_person)
try:
os.makedirs("clientfiles/dataset/" + name)
except:
print("already exists")
return (s)
#os.mkdir(folder+"dataset/"+ name)
x = "clientfiles/dataset/" + name + "/"
samples(x)
training_speaker_name = name
file_path = x
file_names = os.listdir(file_path)
#print((len(file_names)))
lengths = np.empty(len(file_names))
#print(np.shape(lengths))
feature_vectors = np.empty([20, 0])
for i in range(len(file_names)):
x, rate = librosa.load(file_path + file_names[i]) #loads the file
#rate, x = wavfile.read(file_names[i])
x = librosa.feature.mfcc(y=x[0:int(len(x) / 1.25)],
sr=rate) #extracts mfcc
#x = mfcc(x[0:len(x)/1.25], samplerate=rate)
lengths[i] = int(len(x.transpose()))
#print(np.shape(x))
feature_vectors = np.concatenate((feature_vectors, x), axis=1)
#feature_vectors = np.vstack((feature_vectors, x.transpose()))
#print(((lengths)))
#print(np.shape(feature_vectors))
#TRAINING A MODEL
N = 3 # Number of States of HMM
Mixtures = 64 # Number of Gaussian Mixtures.
model = GMMHMM(n_components=N, n_mix=Mixtures, covariance_type='diag')
startprob = np.ones(N) * (10**(-30)) # Left to Right Model
startprob[0] = 1.0 - (N - 1) * (10**(-30))
transmat = np.zeros([N, N]) # Initial Transmat for Left to Right Model
#print(startprob,'\n',transmat)
for i in range(N):
for j in range(N):
transmat[i, j] = 1 / (N - i)
transmat = np.triu(transmat, k=0)
transmat[transmat == 0] = (10**(-30))
model = GMMHMM(n_components=N,
n_mix=Mixtures,
covariance_type='diag',
init_params="mcw",
n_iter=100)
model.startprob_ = startprob
model.transmat_ = transmat
#print(startprob,'\n',transmat)
feature = feature_vectors.transpose()
#print(np.shape(feature))
lengths = [int(x) for x in lengths]
#print(type(lengths[0]))
model.fit(feature, lengths)
joblib.dump(model, folder + "/models/" + name + ".pkl")
return (speakers)
class StockPredictor(object):
def __init__(self,
ticker,
chunks=9,
delta=0,
n_hidden_states=5,
n_latency_days=10,
n_steps_frac_change=10,
n_steps_frac_high=30,
n_steps_frac_low=10,
n_iter=100,
verbose=False,
prediction_date=None):
self.total_score = 0
self.verbose = verbose
self.ticker = ticker
self.n_latency_days = n_latency_days
self.hmm = GMMHMM(n_components=n_hidden_states, n_iter=n_iter)
self.chunks = chunks
self.delta = delta
self.prediction_date = prediction_date
self.fetch_training_data()
self._compute_all_possible_outcomes(n_steps_frac_change,
n_steps_frac_high,
n_steps_frac_low)
def fetch_training_data(self):
print("Fetching training data ...")
res = es.search(index="market",
doc_type="quote",
size=10000,
body={"query": {
"match": {
"ticker": self.ticker
}
}})
self.training_data = json_normalize(res['hits']['hits'])
self.chunked_training_data = self.training_data
#vectors = []
#chunked_training_data_lengths = []
#start_index = 0
#end_index = start_index + self.chunks
#delta_date_index = end_index + self.delta
#while delta_date_index <= len(self.training_data):
#training_chunk = self.training_data[start_index:end_index]
# delta_chunk = self.training_data.iloc[delta_date_index]
# total_chunk = training_chunk.append(delta_chunk)
# #print("%s training_chunk to train %s" % (total_chunk, self.ticker))
# start_index = end_index + 1
# end_index = start_index + self.chunks
# delta_date_index = end_index + self.delta
# vectors.append(total_chunk)
# chunked_training_data_lengths.append(len(total_chunk))
# if self.verbose: print(total_chunk)
#self.chunked_training_data = pd.DataFrame(np.concatenate(vectors), columns = self.training_data.columns)
#self.chunked_training_data_lengths = chunked_training_data_lengths
if self.verbose:
print("Latest record for training:\n%s" %
self.chunked_training_data.tail(1))
latest_date = self.chunked_training_data.tail(1)['_source.timestamp']
datetime_object = datetime.datetime.strptime(latest_date.values[0],
'%Y-%m-%dT%H:%M:%S')
if self.prediction_date == None:
prediction_date = datetime_object + timedelta(days=self.delta + 1)
self.prediction_date = datetime.datetime.strftime(
prediction_date, '%Y-%m-%dT%H:%M:%S')
@staticmethod
def _extract_features(data):
frac_change = np.array(
data['_source.change']) #(close_price - open_price) / open_price
frac_high = np.array(data['_source.change_high']
) #(high_price - open_price) / open_price
frac_low = np.array(
data['_source.change_low']) #(open_price - low_price) / open_price
return np.column_stack((frac_change, frac_high, frac_low))
def fit(self):
print('Extracting Features')
feature_vector = StockPredictor._extract_features(
self.chunked_training_data)
if self.verbose: print("feature vector %s" % feature_vector)
print('Training Model with %s features' % feature_vector.size)
print(
"Latest date to be used in training is %s" %
self.chunked_training_data.tail(1)['_source.timestamp'].values[0])
#self.hmm.fit(feature_vector, self.chunked_training_data_lengths)
self.hmm.fit(feature_vector)
print('Model trained')
def _compute_all_possible_outcomes(self, n_steps_frac_change,
n_steps_frac_high, n_steps_frac_low):
frac_change_range = np.linspace(-0.1, 0.1, n_steps_frac_change)
frac_high_range = np.linspace(0, 0.05, n_steps_frac_high)
frac_low_range = np.linspace(0, 0.05, n_steps_frac_low)
self.all_possible_outcomes = np.array(
list(
itertools.product(frac_change_range, frac_high_range,
frac_low_range)))
def json_data_for_trade(self):
rows = list()
# meta
ticker = self.ticker
date = self.prediction_date
total_score = self.total_score
id = "%s-%s-%s" % (ticker, date, total_score)
meta = {
"index": {
"_index": TRADE_INDEX_NAME,
"_type": TRADE_TYPE_NAME,
"_id": id
}
}
rows.append(json.dumps(meta))
# data
row = ObjDict()
row.total_score = total_score
row.timestamp = self.prediction_date
row.ticker = self.ticker
rows.append(json.dumps(row))
return rows
def json_data_for_outcome(self, outcome, score):
rows = list()
# meta
ticker = self.ticker
date = self.prediction_date
vector = outcome
id = "%s-%s-%s" % (ticker, date, vector)
meta = {"index": {"_index": INDEX_NAME, "_type": TYPE_NAME, "_id": id}}
rows.append(json.dumps(meta))
# data
row = ObjDict()
row.frac_change = outcome[0]
row.frac_high_range = outcome[1]
row.frac_low_range = outcome[2]
open_price = self.training_data.tail(1)['_source.open'].values[0]
predicted_close = open_price * (1 + outcome[0])
expected_value = outcome[0] * score
row.predicted_close = predicted_close
row.expected_value = expected_value
row.timestamp = self.prediction_date
row.score = score
row.chunks = self.chunks
row.delta = self.delta
row.score = score
row.ticker = self.ticker
rows.append(json.dumps(row))
return rows
def delete_prediction_data(self, ticker):
print("Deleting prediction data for ... %s" % self.ticker)
es.delete_by_query(index=INDEX_NAME,
doc_type=TYPE_NAME,
body={'query': {
'match': {
'ticker': self.ticker
}
}})
def predict_outcomes(self):
print("predicting outcomes for: %s" % self.prediction_date)
previous_testing_data = self.training_data.tail(
self.n_latency_days).index
if self.verbose:
print("previous_testing_data %s" % previous_testing_data)
test_data = self.training_data.iloc[previous_testing_data]
if self.verbose:
print("Using the following slice of data:")
print("[%s]" % previous_testing_data)
print(test_data)
test_data_features = StockPredictor._extract_features(test_data)
# to blow everything away - may need to recreate/refresh indexes in ES!
#self.delete_and_create_index()
bulk_data = list()
trade_data = list()
outcome_score = []
for possible_outcome in self.all_possible_outcomes:
test_feature_vectors = np.row_stack(
(test_data_features, possible_outcome))
score = self.hmm.score(test_feature_vectors)
# ignoring scores <= 0
if score > 0:
rows = self.json_data_for_outcome(possible_outcome, score)
bulk_data.append(rows)
if possible_outcome[0] > 0:
self.total_score = self.total_score + score
if possible_outcome[0] < 0:
self.total_score = self.total_score - score
trade_rows = self.json_data_for_trade()
trade_data.append(trade_rows)
print("Exporting predictions to ES")
es_array = self.format_data_for_es(bulk_data)
res = es.bulk(index=INDEX_NAME, body=es_array, refresh=True)
es_array = self.format_data_for_es(trade_data)
res = es.bulk(index=TRADE_INDEX_NAME, body=es_array, refresh=True)
def format_data_for_es(self, data):
es_array = ""
for row in data:
es_array += row[0]
es_array += "\n"
es_array += row[1]
es_array += "\n"
return es_array
lengths[i] = int(len(x.transpose()))
print(np.shape(x))
feature_vectors = np.concatenate((feature_vectors, x), axis=1)
#feature_vectors = np.vstack((feature_vectors, x.transpose()))
print(((lengths)))
print(np.shape(feature_vectors))
#TRAINING A MODEL
N = 3 # Number of States of HMM
Mixtures = 64 # Number of Gaussian Mixtures.
model = GMMHMM(n_components=N, n_mix=Mixtures, covariance_type='diag')
startprob = np.ones(N) * (10**(-30)) # Left to Right Model
startprob[0] = 1.0 - (N - 1) * (10**(-30))
transmat = np.zeros([N, N]) # Initial Transmat for Left to Right Model
print(startprob, '\n', transmat)
for i in range(N):
for j in range(N):
transmat[i, j] = 1 / (N - i)
transmat = np.triu(transmat, k=0)
transmat[transmat == 0] = (10**(-30))
model = GMMHMM(n_components=N,
n_mix=Mixtures,
covariance_type='diag',
init_params="mcw",
def trainingGMMHMM(
dataset, # training dataset.
n_c, # number of hmm's components (ie. hidden states)
n_m, # number of gmm's mixtures (ie. Gaussian model)
start_prob_prior=None, # prior of start hidden states probabilities.
trans_mat_prior=None, # prior of transition matrix.
start_prob=None, # the start hidden states probabilities.
trans_mat=None, # the transition matrix.
gmms=None, # models' params of gmm
covar_type='full',
n_i=50
):
# Initiation of dataset.
# d = Dataset(dataset)
X = dataset.getDataset()
# Initiation of GMM.
_GMMs = []
if gmms is None:
_GMMs = None
else:
for gmm in gmms:
_GMM = GMM(n_components=n_m, covariance_type=covar_type)
_GMM.covars_ = np.array(gmm["covars"])
_GMM.means_ = np.array(gmm["means"])
_GMM.weights_ = np.array(gmm["weights"])
_GMMs.append(_GMM)
# Initiation of GMMHMM.
model = GMMHMM(
startprob_prior=np.array(start_prob_prior),
transmat_prior=np.array(trans_mat_prior),
startprob=np.array(start_prob),
transmat=np.array(trans_mat),
gmms=_GMMs,
n_components=n_c,
n_mix=n_m,
covariance_type=covar_type,
n_iter=n_i
)
# Training.
model.fit(X)
# The result.
new_gmmhmm = {
"nComponent": n_c,
"nMix": n_m,
"covarianceType": covar_type,
"hmmParams": {
"startProb": model.startprob_.tolist(),
"transMat": model.transmat_.tolist()
},
"gmmParams": {
"nMix": n_m,
"covarianceType": covar_type,
"params": []
}
}
for i in range(0, n_m):
gaussian_model = {
"covars": model.gmms_[i].covars_.tolist(),
"means": model.gmms_[i].means_.tolist(),
"weights": model.gmms_[i].weights_.tolist()
}
new_gmmhmm["gmmParams"]["params"].append(gaussian_model)
return new_gmmhmm
def main():
outdir = r'./training_files/multi'
outdir2 = r'./training_files/arnab'
outdir3 = r'./training_files/kejriwal'
outdir4 = r'./training_files/ravish'
outdir5 = r'./training_files/not-shouting'
outdir6 = r'./training_files/shouting'
outdir7 = r'./training_files/single'
outdir8 = r'./training_files/modi'
outdir9 = r'./training_files/ond_more'
#create 3 hmm one for each case
multi = GMMHMM(5, 2)
discuss = GMMHMM(5, 2)
arnab = GMMHMM(5, 2)
kejriwal = GMMHMM(5, 2)
ravish = GMMHMM(5, 2)
notshouting = GMMHMM(5, 2)
shouting = GMMHMM(5, 2)
single = GMMHMM(5, 2)
#training for multi
l = get_files_list(outdir)
for i in l:
f = open(i, "r")
obs = []
i_sequence = []
count = 0
for line in f:
individual_obs = line.strip().split(",")
individual_obs = [float(i) for i in individual_obs]
i_sequence.append(individual_obs)
count += 1
if count == 10:
obs.append(numpy.array(i_sequence))
count = 0
i_sequence = []
multi.fit(obs)
#training for arnab
l = get_files_list(outdir2)
for i in l:
f = open(i, "r")
obs = []
i_sequence = []
count = 0
for line in f:
individual_obs = line.strip().split(",")
individual_obs = [float(i) for i in individual_obs]
i_sequence.append(individual_obs)
count += 1
if count == 10:
obs.append(numpy.array(i_sequence))
count = 0
i_sequence = []
arnab.fit(obs)
#training for kejriwal
l = get_files_list(outdir3)
for i in l:
f = open(i, "r")
obs = []
i_sequence = []
count = 0
for line in f:
individual_obs = line.strip().split(",")
individual_obs = [float(i) for i in individual_obs]
i_sequence.append(individual_obs)
count += 1
if count == 10:
obs.append(numpy.array(i_sequence))
count = 0
i_sequence = []
kejriwal.fit(obs)
#training for ravish
l = get_files_list(outdir4)
for i in l:
f = open(i, "r")
obs = []
i_sequence = []
count = 0
for line in f:
individual_obs = line.strip().split(",")
individual_obs = [float(i) for i in individual_obs]
i_sequence.append(individual_obs)
count += 1
if count == 10:
obs.append(numpy.array(i_sequence))
count = 0
i_sequence = []
ravish.fit(obs)
#training for notshouting
l = get_files_list(outdir5)
for i in l:
f = open(i, "r")
obs = []
i_sequence = []
count = 0
for line in f:
individual_obs = line.strip().split(",")
individual_obs = [float(i) for i in individual_obs]
i_sequence.append(individual_obs)
count += 1
if count == 10:
obs.append(numpy.array(i_sequence))
count = 0
i_sequence = []
notshouting.fit(obs)
#training for shouting
l = get_files_list(outdir6)
for i in l:
f = open(i, "r")
obs = []
i_sequence = []
count = 0
for line in f:
individual_obs = line.strip().split(",")
individual_obs = [float(i) for i in individual_obs]
i_sequence.append(individual_obs)
count += 1
if count == 10:
obs.append(numpy.array(i_sequence))
count = 0
i_sequence = []
shouting.fit(obs)
#training for single
l = get_files_list(outdir7)
for i in l:
f = open(i, "r")
obs = []
i_sequence = []
count = 0
for line in f:
individual_obs = line.strip().split(",")
individual_obs = [float(i) for i in individual_obs]
i_sequence.append(individual_obs)
count += 1
if count == 10:
obs.append(numpy.array(i_sequence))
count = 0
i_sequence = []
single.fit(obs)
#Its time for some testing
q = []
t = "testcase_output.txt"
out = open(t, "w")
#Read test file and make list of list of sequence 10 for --->1
#te=["test1.txt","test2.txt","test3.txt","test4.txt","test5.txt","test6.txt","test7.txt","test8.txt","test9.txt","test10.txt"]
#f=open("expected.txt")
#d_expected={}
'''
for line in f:
x=line.strip().split()
d_expected[x[0]]={'arnab':float(x[1]),'kejriwal':float(x[2]),'ravish':float(x[3])}
'''
te = get_files_list(r'./testing_files')
#te=["test1.txt","test2.txt","test3.txt"]
for ad in te:
d = {"arnab": 0, "kejriwal": 0, "ravish": 0}
f = open(ad, "r")
obs = []
i_sequence = []
count = 0
for line in f:
individual_obs = line.strip().split(",")
#print individual_obs
individual_obs = [float(i) for i in individual_obs]
i_sequence.append(individual_obs)
count += 1
if count == 10:
obs.append(numpy.array(i_sequence))
count = 0
i_sequence = []
p = []
p_choosen = []
p1_choosen = []
p1 = []
p2 = []
p2_choosen = []
#print obs
for i in obs:
p.append((shouting.score(i), "shouting"))
p.append((notshouting.score(i), "notshouting"))
p_choosen.append(max(p, key=lambda x: x[0]))
p = []
for i in obs:
p1.append((arnab.score(i), "arnab"))
p1.append((kejriwal.score(i), "kejriwal"))
p1.append((ravish.score(i), "ravish"))
p1_choosen.append(max(p1, key=lambda x: x[0]))
p1 = []
for i in obs:
p2.append((multi.score(i), "multi"))
p2.append((single.score(i), "single"))
p2_choosen.append(max(p2, key=lambda x: x[0]))
p2 = []
#print p
p = []
p1 = []
p_choosen = [b for a, b in p_choosen]
p1_choosen = [b for a, b in p1_choosen]
p2_choosen = [b for a, b in p2_choosen]
'''
#print p_choosen
#print the state sequence with the timestamp in the output file
t="testcase_output_9.txt"
out=open(t,"a+")
out.write(str(ad)+"--->")
out.write(p_choosen[0])
out.write("\n")
'''
#calculate the amount per second and append to the same file
#print p_choosen
#print p1_choosen
shouting1 = []
notshouting1 = []
totaltime = len(p_choosen) * 0.05
single_count = 0
for i in range(len(p_choosen)):
if p2_choosen[i] == "single":
single_count += 1
if p_choosen[i] == "shouting":
shouting1.append(p1_choosen[i])
elif p_choosen[i] == "notshouting":
notshouting1.append(p1_choosen[i])
#print d
d_shouting = {"arnab": 0, "kejriwal": 0, "ravish": 0}
d_notshouting = {"arnab": 0, "kejriwal": 0, "ravish": 0}
for i in shouting1:
d_shouting[i] += 1
for i in notshouting1:
d_notshouting[i] += 1
#print p_choosen
out.write("\n*******--> " + str(ad) + " <--*******\n")
#write arnab,ravish and kejri
fn = ad.strip().split("/")
fn = fn[len(fn) - 1]
#out.write("Time predicted for questioning: "+str((d5['question'])*0.05)+" seconds.\n")
#out.write("Time predicted for discussion: "+str((d5['discuss'])*0.05)+" seconds.\n")
out.write("\nChecking single HMM and multi HMM:\n")
out.write("Number of instance of Single: " + str(single_count) + "\n")
out.write(
"\nChecking shouting and non-shouting HMM for all Single instances:\n"
)
out.write("Number of instance of Shouting: " + str(len(shouting1)) +
"\n")
out.write("Number of instance of Not-shouting: " +
str(len(notshouting1)) + "\n")
out.write(
"\nChecking the frequency of each speaker in both both shouting and not shouting instance...\n"
)
out.write("Shouting instance: \n" + str(d_shouting) + "\n")
out.write("Not-Shouting instance: \n" + str(d_notshouting) + "\n")
out.write("\nResult:\n")
for c, d in d_shouting.items():
out.write(
str(c) + " was shouting for " + str(d * 0.05) + " sec.\n")
out.write("\n")
for c, d in d_notshouting.items():
out.write(
str(c) + " was not shouting for " + str(d * 0.05) + " sec.\n")
out.write("\n")
for c, d in d_shouting.items():
out.write(
str(c) + " was shouting for " +
str(((d * 0.05) / totaltime) * 100) + " % of time.\n")
out.write("\n")
for c, d in d_notshouting.items():
out.write(
str(c) + " was not shouting for " +
str(((d * 0.05) / totaltime) * 100) + " sec.\n")
out.write("\n")
print d_shouting
print d_notshouting
def getTMHS(X):
model = GMMHMM(n_components=3, covariance_type="diag", n_iter=1000).fit(X)
hidden_states = model.predict(X)
transmat = model.transmat_
return hidden_states, transmat
import os
from hmmlearn.hmm import GMMHMM
from python_speech_features import mfcc
from scipy.io import wavfile
from sklearn.model_selection import train_test_split
import numpy as np
import sys
input_folder = '/home/sachin/Downloads/cmu_us_awb_arctic-0.95-release/cmu_us_awb_arctic/wav'
hmm_models = []
X = np.array([])
for filename in os.listdir(input_folder):
filepath = os.path.join(input_folder, filename)
sampling_freq, audio = wavfile.read(filepath)
mfcc_features = mfcc(audio, sampling_freq)
if len(X) == 0:
X = mfcc_features
else:
X = np.append(X, mfcc_features, axis=0)
model = GMMHMM(n_components=3, n_mix=45, n_iter=100)
X_train, X_test = train_test_split(X, train_size=0.7)
hmm_models.append(model.fit(X_train))
print(model.score(X_test))
def test(fil):
for f in fil:
dat = pre_process([f])
li = []
w = open(f + '.out2', 'w')
for i in range(len(dat)):
temp = [gmm[j].score(dat[i]) for j in range(2)]
li.append(temp.index(max(temp)))
w.write(str(li))
if __name__ == '__main__':
gmm = [
GMMHMM(n_components=3, n_mix=1, covariance_type='diag')
for i in range(2)
]
path = "./mfcc_files/"
data_path = [
path + 'single/single_1_mfcc.txt', path + 'single/single_3_mfcc.txt',
path + 'single/single_5_mfcc.txt', path + 'single/single_6_mfcc.txt'
]
dat = pre_process(data_path)
gmm[0].fit(dat)
data_path = [
path + 'multi/MULTI_1_mfcc.txt', path + 'multi/MULTI_2_mfcc.txt',
path + 'multi/MULTI_3_mfcc.txt', path + 'multi/MULTI_4_mfcc.txt'
class GMMHMMTrainer(BaseTrainer):
'''A wrapper to GMMHMM
Attributes
----------
_model: init params
gmmhmm: hmmlearn GMMHMM instance
params_: params after fit
train_data_: current train datas
'''
def __init__(self, _model):
super(GMMHMMTrainer, self).__init__(_model)
hmm_params = _model['hmmParams']
gmm_params = _model['gmmParams']
n_iter = _model.get('nIter', 50)
transmat = np.array(hmm_params['transMat'])
transmat_prior = np.array(hmm_params['transMatPrior'])
n_component = hmm_params['nComponent']
startprob = np.array(hmm_params['startProb'])
startprob_prior = np.array(hmm_params['startProbPrior'])
n_mix = gmm_params['nMix']
covariance_type = gmm_params['covarianceType']
gmms = gmm_params.get('gmms', None)
gmm_obj_list = []
if not gmms:
gmm_obj_list = None
else:
for gmm in gmms:
gmm_obj = GMM(n_components=gmm['nComponent'], covariance_type=gmm['covarianceType'])
gmm_obj.covars_ = np.array(gmm['covars'])
gmm_obj.means_ = np.array(gmm['means'])
gmm_obj.weights_ = np.array(gmm['weights'])
gmm_obj_list.append(gmm_obj)
self.gmmhmm = GMMHMM(n_components=n_component, n_mix=n_mix, gmms=gmm_obj_list,
n_iter=n_iter, covariance_type=covariance_type,
transmat=transmat, transmat_prior=transmat_prior,
startprob=startprob, startprob_prior=startprob_prior)
def __repr__(self):
return '<GMMHMMTrainer instance>\n\tinit_models:%s\n\tparams:%s\n\ttrain_data:%s' % (self._model,
self.params_, self.train_data_)
def fit(self, train_data):
train_data = np.array(train_data)
self.gmmhmm.fit(train_data)
gmms_ = []
for gmm in self.gmmhmm.gmms_:
gmms_.append({
'nComponent': gmm.n_components,
'nIter': gmm.n_iter,
'means': gmm.means_.tolist(),
'covars': gmm.covars_.tolist(),
'weights': gmm.weights_.tolist(),
'covarianceType': gmm.covariance_type,
})
self.train_data_ += train_data.tolist()
self.params_ = {
'nIter': self.gmmhmm.n_iter,
'hmmParams': {
'nComponent': self.gmmhmm.n_components,
'transMat': self.gmmhmm.transmat_.tolist(),
'transMatPrior': self.gmmhmm.transmat_prior.tolist(),
'startProb': self.gmmhmm.startprob_.tolist(),
'startProbPrior': self.gmmhmm.startprob_prior.tolist(),
},
'gmmParams': {
'nMix': self.gmmhmm.n_mix,
'covarianceType': self.gmmhmm.covariance_type,
'gmms': gmms_,
}
}
# The transition matrix, note that there are no transitions possible
# between component 1 and 4
trans_mat = np.array([[0.5, 0.2, 0.2, 0.1],
[0.3, 0.4, 0.2, 0.1],
[0.1, 0.2, 0.5, 0.2],
[0.2, 0.1, 0.1, 0.6]])
start_prob_prior = np.array([0.3, 0.3, 0.3, 0.1])
trans_mat_prior = np.array([[0.2, 0.1, 0.3, 0.4],
[0.3, 0.2, 0.2, 0.3],
[0.1, 0.1, 0.1, 0.7],
[0.1, 0.3, 0.4, 0.2]])
# Build an HMM instance and set parameters
model_dining = GMMHMM(startprob_prior=start_prob_prior, transmat_prior=trans_mat_prior, startprob=start_prob, transmat=trans_mat, n_components=4, n_mix=4, covariance_type='spherical', n_iter=50)
model_fitness = GMMHMM(startprob_prior=start_prob_prior, transmat_prior=trans_mat_prior, startprob=start_prob, transmat=trans_mat, n_components=4, n_mix=10, covariance_type='spherical', n_iter=50)
model_work = GMMHMM(startprob_prior=start_prob_prior, transmat_prior=trans_mat_prior, startprob=start_prob, transmat=trans_mat, n_components=4, n_mix=8, covariance_type='spherical', n_iter=50)
model_shop = GMMHMM(startprob_prior=start_prob_prior, transmat_prior=trans_mat_prior, startprob=start_prob, transmat=trans_mat, n_components=4, n_mix=4, covariance_type='spherical', n_iter=50)
# print model_dining.gmms_[0].covars_.tolist()
# print model_dining.gmms_[0].means_.tolist()
# print model_dining.gmms_[0].weights_.tolist()
dataset_dining = Dataset()
dataset_fitness = Dataset()
dataset_work = Dataset()
dataset_shop = Dataset()
# print Dataset().randomObservations('dining_out_in_chinese_restaurant', 10, 10).obs
def trainingGMMHMM(
dataset, # training dataset.
n_c, # number of hmm's components (ie. hidden states)
n_m, # number of gmm's mixtures (ie. Gaussian model)
start_prob_prior=None, # prior of start hidden states probabilities.
trans_mat_prior=None, # prior of transition matrix.
start_prob=None, # the start hidden states probabilities.
trans_mat=None, # the transition matrix.
gmms=None, # models' params of gmm
covar_type='full',
n_i=50):
# Initiation of dataset.
# d = Dataset(dataset)
X = dataset.getDataset()
# Initiation of GMM.
_GMMs = []
if gmms is None:
_GMMs = None
else:
for gmm in gmms:
_GMM = GMM(n_components=n_m, covariance_type=covar_type)
_GMM.covars_ = np.array(gmm["covars"])
_GMM.means_ = np.array(gmm["means"])
_GMM.weights_ = np.array(gmm["weights"])
_GMMs.append(_GMM)
# Initiation of GMMHMM.
model = GMMHMM(startprob_prior=np.array(start_prob_prior),
transmat_prior=np.array(trans_mat_prior),
startprob=np.array(start_prob),
transmat=np.array(trans_mat),
gmms=_GMMs,
n_components=n_c,
n_mix=n_m,
covariance_type=covar_type,
n_iter=n_i)
# Training.
model.fit(X)
# The result.
new_gmmhmm = {
"nComponent": n_c,
"nMix": n_m,
"covarianceType": covar_type,
"hmmParams": {
"startProb": model.startprob_.tolist(),
"transMat": model.transmat_.tolist()
},
"gmmParams": {
"nMix": n_m,
"covarianceType": covar_type,
"params": []
}
}
for i in range(0, n_m):
gaussian_model = {
"covars": model.gmms_[i].covars_.tolist(),
"means": model.gmms_[i].means_.tolist(),
"weights": model.gmms_[i].weights_.tolist()
}
new_gmmhmm["gmmParams"]["params"].append(gaussian_model)
return new_gmmhmm
# prediction sample for every entry of test set
prediction = np.zeros(len(X))
for i in range(len(X)):
prediction[i] = np.argmax(
[model.score(X[i]) for key, model in models.items()])
test_confusion_matrix = sklearn.metrics.confusion_matrix(
y, prediction, labels=range(n_classes))
test_accuracy = np.sum(
np.diagonal(test_confusion_matrix)) / np.sum(test_confusion_matrix)
print("Test Accuracy: ", test_accuracy)
print("Test Confusion Matrix:")
print(test_confusion_matrix)
if __name__ == '__main__':
X_train, X_test, y_train, y_test = prepare_data(augment_iter=4)
# Test Accuracy: 0.7905
models = {}
for i in range(n_classes):
models.update({i: GMMHMM(n_components=8, n_mix=3)})
# train models
train(models, X_train, y_train)
# evaluate models
test(models, X_test, y_test)
obs4 = [newPicObservations[i] for i in range(len(newPicObservations)) if labels[i] == '4']
obs5 = [newPicObservations[i] for i in range(len(newPicObservations)) if labels[i] == '5']
obs6 = [newPicObservations[i] for i in range(len(newPicObservations)) if labels[i] == '6']
#newPicObservations.shape = (48, 48)
model0Gau = GaussianHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs0)
model1Gau = GaussianHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs1)
model2Gau = GaussianHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs2)
model3Gau = GaussianHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs3)
model4Gau = GaussianHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs4)
model5Gau = GaussianHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs5)
model6Gau = GaussianHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs6)
try:
model0GauMix = GMMHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs0)
model1GauMix = GMMHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs1)
model2GauMix = GMMHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs2)
model3GauMix = GMMHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs3)
model4GauMix = GMMHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs4)
model5GauMix = GMMHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs5)
model6GauMix = GMMHMM(n_components=48, covariance_type='full', n_iter=100).fit(obs6)
except ValueError:
print 'err gaumix'
try:
model0Multi = MultinomialHMM(n_components=48, n_iter=100).fit(obs0)
model1Multi = MultinomialHMM(n_components=48, n_iter=100).fit(obs1)
model2Multi = MultinomialHMM(n_components=48, n_iter=100).fit(obs2)
model3Multi = MultinomialHMM(n_components=48, n_iter=100).fit(obs3)
model4Multi = MultinomialHMM(n_components=48, n_iter=100).fit(obs4)