def f(model, normal_signal, N_train, N, alpha, norm_params, mean, variance,
an_params, anomal_mean, anomal_variance, n_comp, launch):
np.random.seed(launch)
an_sequence = generator.Sequence(N,
alpha,
type='continue',
params=an_params,
mean=anomal_mean,
variance=anomal_variance)
anormal_signal = an_sequence.sequence
# print(model.states)
print('Параметры {}, {}, {}'.format(N, mean, variance))
m, sc1, sc2 = experiment(model, normal_signal, anormal_signal,
['a', 'b', 'c'], norm_params, mean, variance,
an_params, anomal_mean, anomal_variance, N,
launch)
print(sc1)
print(len(sc1))
print(len(sc2))
with open('score.txt', 'w') as file:
file.write('Норма Аномальный\n')
for x, y in zip(sc1, sc2):
file.write('{} {}\n'.format(x, y))
return m
def run_test(arg, k):
np.random.seed(k)
exp_type = arg['type']
N = arg['N']
alpha = arg['alpha']
n_comp = arg['n_comp']
norm_params = arg['norm_params']
save_dir = arg['dir']
sequence = generator.Sequence(N, alpha, type=exp_type, params=norm_params)
labels = list(map(myutils.rename_state, sequence.path))
model = HiddenMarkovModel.from_samples(DiscreteDistribution,
n_components=n_comp,
X=[sequence.sequence],
labels=[labels],
algorithm='labeled')
return model, sequence.sequence
def run(arg, k):
np.random.seed(k)
exp_type = arg['type']
N = arg['N']
alpha = arg['alpha']
n_comp = arg['n_comp']
norm_params = arg['norm_params']
an_params = arg['an_params']
save_dir = arg['dir']
mean = arg['mean']
variance = arg['varience']
anomal_mean = arg['anomal_mean']
anomal_variance = arg['anomal_varience']
norm_gen = generator.Sequence(N,
alpha,
type=exp_type,
params=norm_params,
mean=mean,
variance=variance)
norm_signal = norm_gen.sequence
an_gen = generator.Sequence(N,
alpha,
type=exp_type,
params=an_params,
mean=anomal_mean,
variance=anomal_variance)
an_signal = an_gen.sequence
# an_signal[180:200] = np.random.normal(2,0.02,20)
an_labels = list(map(myutils.rename_state, an_gen.path))
labels = list(map(myutils.rename_state, norm_gen.path))
if exp_type == 'continue':
model = HiddenMarkovModel.from_samples(NormalDistribution,
n_components=n_comp,
X=[norm_signal],
labels=[labels],
algorithm='labeled')
an_model = HiddenMarkovModel.from_samples(NormalDistribution,
n_components=n_comp,
X=[an_signal],
labels=[an_labels],
algorithm='labeled')
else:
model = HiddenMarkovModel.from_samples(DiscreteDistribution,
n_components=n_comp,
X=[norm_signal],
labels=[labels],
algorithm='labeled')
an_model = HiddenMarkovModel.from_samples(DiscreteDistribution,
n_components=n_comp,
X=[an_signal])
# model = HiddenMarkovModel.from_samples(DiscreteDistribution, n_components = n_comp, X = [norm_signal])
# an_model = HiddenMarkovModel.from_samples(DiscreteDistribution, n_components = n_comp, X = [an_signal])
l1 = model.log_probability(norm_signal)
l2 = model.log_probability(an_signal)
cdir = os.getcwd()
path = cdir + '/' + arg['dir']
try:
os.mkdir(path)
except:
pass
with open(path + '/log_' + str(k) + '.txt', 'w') as file:
out = myutils.print_model_distribution(model)
file.write(out)
out = myutils.print_model_distribution(an_model)
file.write(out)
file.write('l_normal = {} l_anomal = {}'.format(l1, l2))
# out = myutils.print_model_distribution(model_2)
# file.write(out)
# file.write(str(an_model.to_json()))
# fig_sub = plt.figure(figsize = (18,5.9))
fig_sub = plt.figure(figsize=(16, 5.9))
ax2 = fig_sub.add_axes([0.12, 0.1, 0.07, 0.8])
ax2.plot([1] * len([l1]), l1, 'b.', markersize=12)
ax2.plot([1] * len([l2]), l2, 'r.', markersize=12)
# ax2.plot([1], normal_score, 'g*', markersize=12)
ax2.set_ylabel('log probability')
# ax2.set_xlim(0.9, 1.2)
ax2.set_xticks([0.95, 1, 1.05])
ax2.set_xticklabels(['', '', ''])
ax = fig_sub.add_axes([0.24, 0.1, 0.74, 0.8])
ax.plot(norm_signal, 'b', label='Normal') #Ошибка в цветах
ax.plot(an_signal, 'r', label='Abnormal')
ax.set_xlabel('Time', )
# ax.grid()
plt.legend(loc=1)
plt.tight_layout()
plt.savefig(path + '/plot' + str(k) + '.png', dpi=180)
plt.close()
# ax.set_y
print(' {}, {}'.format(l1, l2))
print('На аномальной')
l1 = an_model.log_probability(norm_signal)
l2 = an_model.log_probability(an_signal)
print(' {}, {}'.format(l1, l2))
print(' Норма\n {}'.format(model.predict_proba(an_signal)))
def experiment(model,
normal_seq,
anomal_seq,
alpha,
norm_params,
mean,
variance,
anomal_params,
anomal_mean,
anomal_var,
N=150,
num_launch=0):
normal_score = []
anomal_score = []
normal_score += [model.log_probability(normal_seq)]
# print(model.distributions[1])
anomal_score += [model.log_probability(anomal_seq)]
print(anomal_score[0])
if anomal_score[0] == float('-inf'):
anomal_score[0] = -1500
# print("Нормальный {}, Аномальный {}".format(normal_score[0],anormal_score[0]))
#Построение графика
# fig_seq = plt.figure(dpi = 150)
# plt.plot(alpha,'w')
# plt.plot(anormal_seq,'r')
# plt.plot(normal_seq,'b')
# plt.plot(normal_seq,'b.')
# plt.grid()
# plt.savefig('Непрерывный'+str(num_launch)+'.png',dpi = 150)
# # plt.show()
log_prob_arr = []
for i in range(100):
sequence = generator.Sequence(N,
alpha,
type='continue',
params=norm_params,
mean=mean,
variance=variance)
seq = sequence.sequence
log_prob_arr += [model.log_probability(seq)]
sequence = generator.Sequence(N,
alpha,
type='continue',
params=anomal_params,
mean=anomal_mean,
variance=anomal_var)
anomal_seq = sequence.sequence
anomal_score += [model.log_probability(anomal_seq)]
# if i%50 == 0:
# fig_sequence = plt.figure(dpi = 140)
# # plt.plot(alpha,'w')
# plt.plot(seq,'b.')
# plt.plot(seq,'b')
# plt.savefig('/home/kirilman/Projects/nir/nir/experiment_continue/Graphs/sequence_graph_l_'+str(num_launch)+str(i)+'.png')
# plt.close()
fig_log = plt.figure(num=num_launch, figsize=(3.5, 10))
plt.plot([1] * len(log_prob_arr), log_prob_arr, '.', markersize=12)
plt.plot([1] * len(anomal_score), anomal_score, 'r.', markersize=12)
# plt.plot([1], normal_score, 'g.',markersize = 15)
plt.ylabel('log probability')
plt.xlim(0.95, 1.05)
# plt.tight_layout()
# plt.savefig('График log_probability'+str(num_launch)+'.png', dpi = 140)
# Совместный график
fig_sub = plt.figure(figsize=(16, 5))
ax2 = fig_sub.add_axes([0.12, 0.1, 0.07, 0.8])
ax2.plot([1] * len(log_prob_arr), log_prob_arr, '.', markersize=10)
ax2.plot([1] * len(anomal_score), anomal_score, 'rx', markersize=10)
# ax2.plot([1], normal_score, 'g*', markersize=12)
ax2.set_ylabel('log probability')
# ax2.set_xlim(0.9, 1.2)
ax2.set_xticks([0.95, 1, 1.05])
ax2.set_xticklabels(['', '1', ''])
ax = fig_sub.add_axes([0.24, 0.1, 0.74, 0.8])
ax.plot(anomal_seq, 'r')
ax.plot(normal_seq, 'b')
ax.grid()
# ax.set_yticks(range(len(alpha)))
# plt.tight_layout()
plt.savefig('Graphs/Log_and_seq/gh_' + str(num_launch) + '.png', dpi=150)
plt.close()
return model, log_prob_arr, anomal_score
}
alpha = ['a', 'b', 'c']
mean = [0, 1, 2]
variance = [0.01, 0.01, 0.01] + np.array([0.15] * 3)
anomal_mean = mean
# anomal_mean = mean + np.array([0,0.5,0])
anomal_variance = variance
write_log(N, N_train, norm_params, mean, variance, an_params, anomal_mean,
anomal_variance)
sequence = generator.Sequence(N_train,
alpha,
type='continue',
params=norm_params,
mean=mean,
variance=variance)
normal_signal = sequence.sequence
labels = list(map(myutils.rename_state, sequence.path))
model = HiddenMarkovModel.from_samples(NormalDistribution,
n_components=n_comp,
X=[normal_signal],
labels=[labels],
algorithm='labeled')
# model = HiddenMarkovModel.from_samples(GeneralMixtureModel, n_components = n_comp, X = [normal_signal],
# labels = [labels], algorithm='labeled')
# fig = plt.figure(num = 1000, figsize=(15,4))
# plt.plot(normal_signal,'b')
# plt.plot([x / 3 for x in sequence.path], 'r')
# plt.savefig('Graphs/path.png')
from pomegranate import *
import sequence_generator as generator
import matplotlib.pyplot as plt
import numpy as np
import myutils
test = generator.Sequence(10000, ['a', 'b'],
type='continue',
params={
'a': {
'len': [1000, 1010],
'depend_on': False
},
'b': {
'len': [25, 35],
'depend_on': False
}
},
mean=[0, 0.2],
variance=[0.03, 0.05])
fig = plt.figure(figsize=(20, 4))
plt.plot(test.sequence)
# plt.plot(test.path)
model = HiddenMarkovModel.from_samples(
NormalDistribution,
2, [test.sequence],
labels=[list(map(lambda x: myutils.rename_state(x), test.path))],
algorithm='labeled')
myutils.print_model_distribution(model)
def experiment_discret(model,
normal_seq,
anormal_seq,
N=150,
alpha=['a', 'b', 'c', 'd', 'e'],
p=0.05,
num_launch=0):
# params = {'a': {'len': [1, 1], 'depend_on': False},
# 'b': {'len': [1, 1], 'depend_on': False},
# 'c': {'len': [0, 1], 'depend_on': False},
# 'd': {'len': [0, 1], 'depend_on': 'c' },
# 'e': {'len': [1, 3], 'depend_on': 'b'}}
normal_score = []
anormal_score = []
normal_score += [model.log_probability(normal_seq)]
# print(model.distributions[1])
anormal_score += [model.log_probability(anormal_seq)]
print(anormal_score[0])
if anormal_score[0] == float('-inf'):
anormal_score[0] = -1500
# print("Нормальный {}, Аномальный {}".format(normal_score[0],anormal_score[0]))
#Построение графика
fig_seq = plt.figure(dpi=150)
plt.plot(alpha, 'w')
plt.plot(anormal_seq, 'r')
plt.plot(normal_seq, 'b')
plt.plot(normal_seq, 'b.')
plt.grid()
plt.savefig('Дискретный с невозможным переходом' + str(num_launch) +
'.png',
dpi=150)
# plt.show()
log_prob_arr = []
for i in range(100):
sequence = generator.Sequence(N,
alpha,
type='test_discret',
p=[0.05, 0.1, 0.4, 0.8])
seq = sequence.sequence
if i % 50 == 0:
fig_sequence = plt.figure(dpi=140)
plt.plot(alpha, 'w')
plt.plot(seq, 'b.')
plt.plot(seq, 'b')
plt.savefig(
'/home/kirilman/Projects/nir/nir/experiment_discret/Graphs/sequence_graph__'
+ str(i) + '.png')
log_prob_arr += [model.log_probability(seq)]
plt.close()
fig_log = plt.figure(figsize=(3.5, 10))
plt.plot([1] * len(log_prob_arr), log_prob_arr, '.', markersize=15)
plt.plot([1], anormal_score, 'r.', markersize=15)
# plt.plot([1], normal_score, 'g.',markersize = 15)
plt.ylabel('log probability')
plt.xlim(0.95, 1.05)
# plt.tight_layout()
plt.savefig('График log_probability' + str(num_launch) + '.png', dpi=140)
# plt.show()
#print(model.to_json())
# with open('experiment1.txt','w') as file:
# table = myutils.table_from_MarkovChain(model)
# for t in table:
# file.write(str(t)+'\n')
# print(model.distributions[1])
# Совместный график
fig_sub = plt.figure(figsize=(10, 6))
ax2 = fig_sub.add_axes([0.12, 0.1, 0.07, 0.8])
ax2.plot([1] * len(log_prob_arr), log_prob_arr, '.', markersize=15)
ax2.plot([1], anormal_score, 'r*', markersize=15)
ax2.plot([1], normal_score, 'g*', markersize=12)
ax2.set_ylabel('log probability')
# ax2.set_xlim(0.9, 1.2)
ax2.set_xticks([0.95, 1, 1.05])
ax2.set_xticklabels(['', '1', ''])
ax = fig_sub.add_axes([0.24, 0.1, 0.74, 0.8])
ax.plot(alpha, 'w')
ax.plot(anormal_seq, 'r.')
ax.plot(anormal_seq, 'r')
ax.plot(normal_seq, 'b')
ax.plot(normal_seq, 'b.')
ax.grid()
ax.set_yticks(range(len(alpha)))
ax2.set_xticklabels(alpha)
# plt.tight_layout()
plt.savefig(
'/home/kirilman/Projects/nir/nir/experiment_discret/Graphs/Log_and_seq/gh_'
+ str(num_launch) + '.png',
dpi=100)
plt.close('all')
return model
dpi=100)
plt.close('all')
return model
if __name__ == "__main__":
N = 150
arr_seqs = []
N_train = 3000
count = 25
file = open('result.txt', 'w')
for i in range(count):
np.random.seed(i) # Для случайной инициализации модели
alpha = ['a', 'b', 'c', 'd', 'e']
sequence = generator.Sequence(N_train,
alpha,
type='test_discret',
p=[0.05, 0.1, 0.4, 0.8])
normal_seq = sequence.sequence.copy()
print(normal_seq[:15])
arr_seqs += [normal_seq]
#Аномальная последовательность
# anormal_seq = sequence.anormal(p)
anormal_seq = normal_seq[:N].copy()
start, stop, simbol = get_slice(normal_seq[:N])
if stop == len(anormal_seq):
# anormal_seq[start:stop] = [normal_seq[start-1]]*(stop - start)
new_s = normal_seq[np.random.choice(range(100))]
while new_s == simbol:
# generator = generator.Sequence(N, alpha, type = exp_type, params=norm_params)
# test_signal = generator.sequence
# plt.plot(test_signal)
# plt.show()
# f_1 = open('signal.txt', 'w')
with open('result.txt', 'w') as file:
for arg in args:
exp_type = arg['type']
N = arg['N']
alpha = arg['alpha']
n_comp = arg['n_comp']
norm_params = arg['norm_params']
for i in range(10):
gen = generator.Sequence(N,
alpha,
type=exp_type,
params=norm_params)
test_signal = gen.sequence
# f_1.write
signals += [test_signal]
log_pr = [
model.log_probability(test_signal) for model in models
]
for x in log_pr:
file.write(str(x) + ' ')
file.write(str(np.argmax(log_pr) + 1) + '\n')
file.write('____\n')
signals = np.array(signals)
# signals.tofile('signal.npy')
np.save('signals.npy', signals)
# f_1.close()
