def test_distributions_mgd_random_sample():
mu = numpy.array([5., 1.])
cov = numpy.eye(2)
d = MultivariateGaussianDistribution(mu, cov)
x = numpy.array([[5.441227, 0.66913], [7.430771, 0.747908],
[5.10961, 2.582481]])
assert_array_almost_equal(d.sample(3, random_state=5), x)
assert_raises(AssertionError, assert_array_almost_equal, d.sample(5), x)
def test_distributions_mgd_random_sample(): mu = numpy.array([5., 1.]) cov = numpy.eye(2) d = MultivariateGaussianDistribution(mu, cov) x = numpy.array([[5.441227, 0.66913 ], [7.430771, 0.747908], [5.10961 , 2.582481]]) assert_array_almost_equal(d.sample(3, random_state=5), x) assert_raises(AssertionError, assert_array_almost_equal, d.sample(5), x)
def reset(self, n_comp=5):
self.n_comp = n_comp
if self.dim == 2:
self.data = np.array([[], []]).T
else:
self.data = np.array([[], [], []]).T
self.score = np.ones(np.shape(self.data)[0])
self.score = self.score / np.linalg.norm(self.score, ord=1)
if self.dim == 2:
self.model = MultivariateGaussianDistribution(
np.zeros(self.dim), np.diag([1.0, 1.0]))
else:
self.model = MultivariateGaussianDistribution(
np.zeros(self.dim), np.diag([1.0, 1.0, 5.0]))
def get_insert_dist(self, n_features, initial_seq):
if isinstance(initial_seq[0], int) \
or np.issubdtype(initial_seq[0], np.integer): #equal distribution
return DiscreteDistribution.from_samples(range(n_features))
else: #distribution based on initial sequence
return MultivariateGaussianDistribution.from_samples(
np.array(initial_seq))
def randMVG(n=40):
'''
generates random multivariate gaussian
'''
means = np.random.randn(n)
# covs = np.random.rand(n, n)
covs = np.eye(n, n)
# print(covs)
return MultivariateGaussianDistribution(means, covs)
def get_match_dist(self, index, n_features, initial_seq):
if isinstance(initial_seq[index], int):
return DiscreteDistribution.from_samples(range(n_features))
#return DiscreteDistribution.from_samples(np.concatenate(
# (np.repeat(index, INITIAL_EMPHASIS), range(n_features))))
else:
return MultivariateGaussianDistribution.from_samples(
np.concatenate(
(np.tile(index,
(INITIAL_EMPHASIS, 1)), np.array(initial_seq))))
def reset(self, n_comp=5):
self.n_comp = n_comp
# components数量
if self.dim == 2:
self.data = np.array([[], []]).T
else:
self.data = np.array([[], [], []]).T
self.score = np.ones(np.shape(self.data)[0])
self.score = self.score / np.linalg.norm(self.score, ord=1)
if self.dim == 2:
self.model = MultivariateGaussianDistribution(
np.zeros(self.dim), np.diag([1.0, 1.0]))
# self.model是一个类实例
# "class" :"Distribution"
# "name" :"MultivariateGaussianDistribution",
else:
self.model = MultivariateGaussianDistribution(
np.zeros(self.dim), np.diag([1.0, 1.0, 5.0]))
def test_multivariate_log_probability(): X = numpy.random.randn(100, 5) d = MultivariateGaussianDistribution.from_samples(X) logp = d.log_probability(X) for i in range(100): assert_almost_equal(d.log_probability(X[i]), logp[i]) d = IndependentComponentsDistribution.from_samples(X, distributions=NormalDistribution) logp = d.log_probability(X) for i in range(100): assert_almost_equal(d.log_probability(X[i]), logp[i])
def test_multivariate_log_probability(): X = numpy.random.randn(100, 5) d = MultivariateGaussianDistribution.from_samples(X) logp = d.log_probability(X) for i in range(100): assert_almost_equal(d.log_probability(X[i]), logp[i]) d = IndependentComponentsDistribution.from_samples(X, distributions=NormalDistribution) logp = d.log_probability(X) for i in range(100): assert_almost_equal(d.log_probability(X[i]), logp[i])
for train_index, test_index in skf:
cl = HMM(name="Gait")
distros = []
hmm_states = []
state_names = ['swing', 'stance']
positive_data = []
negative_data = []
for i in range(0, len(fl)):
if fl[i] == 1:
positive_data.append(fd[i])
else:
negative_data.append(fd[i])
posdis = MGD.from_samples(positive_data)
st = State(posdis, name='swing')
distros.append(st)
hmm_states.append(st)
negdis = MGD.from_samples(negative_data)
st2 = State(negdis, name='stance')
distros.append(st2)
hmm_states.append(st2)
cl.add_states(hmm_states)
cl.add_transition(cl.start, hmm_states[0], 0.5)
cl.add_transition(cl.start, hmm_states[1], 0.5)
for i in range(0, 2):
for j in range(0, 2):
cl.add_transition(hmm_states[i], hmm_states[j], t[i][j])
def build_dis_classifier(self):
skf = StratifiedKFold(self.full_labels, n_folds=self.folds)
classifier_array = []
stats_array = []
num_class = len(self.full_data[0])
print (num_class)
for cl in range(0, num_class):
lel = -1
tp_total = 0.0
tn_total = 0.0
fp_total = 0.0
fn_total = 0.0
tests = 0
for train_index, test_index in skf:
if lel > 0:
lel -= 1
continue
stats = []
distros = []
hmm_states = []
state_names = ['swing', 'stance']
swings = 0
stances = 0
for i in range(0, 2):
dis = MGD.from_samples(self.class_data[i])
st = State(dis, name=state_names[i])
distros.append(dis)
hmm_states.append(st)
model = HMM()
print(model.states)
model.add_states(hmm_states)
model.add_transition(model.start, hmm_states[0], 0.5)
model.add_transition(model.start, hmm_states[1], 0.5)
model.add_transition(hmm_states[1], model.end, 0.000000000000000001)
model.add_transition(hmm_states[0], model.end, 0.000000000000000001)
for i in range(0, 2):
for j in range(0, 2):
model.add_transition(hmm_states[i], hmm_states[j], self.t[i][j])
model.bake()
tp = 0.0
tn = 0.0
fp = 0.0
fn = 0.0
train_data = self.full_data[train_index, cl]
train_class = self.full_labels[train_index, cl]
test_data = self.full_data[test_index]
test_class = self.full_labels[test_index]
print(np.isfinite(train_data).all())
print(np.isfinite(test_data).all())
print(np.isnan(train_data.any()))
print(np.isinf(train_data.any()))
print(np.isnan(test_data.any()))
print(np.isinf(test_data.any()))
if (not np.isfinite(train_data.any())) or (not np.isfinite(test_data.any())) \
or (not np.isfinite(train_class.any())) or (not np.isfinite(test_data.any())):
rospy.logerr("NaN or Inf Detected")
exit()
try:
rospy.logwarn("Training model #"+str(cl)+", fold #" + str(tests))
seq = np.array(train_data)
model.fit(seq, algorithm='baum-welch', verbose='True', n_jobs=8, max_iterations=150)
except ValueError:
rospy.logwarn("Something went wrong, exiting")
rospy.shutdown()
exit()
seq = []
if self.batch_test == 1:
s = 0
# for s in range(0, len(test_data)):
while s < len(test_data):
k = 0
seq_entry = []
while k < 20 and s < len(test_data):
seq_entry.append(test_data[s])
k += 1
s += 1
seq.append(seq_entry)
else:
seq = np.array(test_data)
if seq == [] or test_data == []:
rospy.logerr("Empty testing sequence")
continue
log, path = model.viterbi(test_data)
if (len(path) - 2) != len(test_data):
rospy.logerr(len(path))
rospy.logerr(path[0][1].name)
rospy.logerr(path[len(path) - 1][1].name)
rospy.logerr(len(test_data))
exit()
tests += 1
for i in range(0, len(path) - 2):
if path[i + 1][1].name != 'Gait-start' and path[i + 1][1].name != 'Gait-end':
if path[i + 1][1].name == 'swing': # prediction is 0
swings += 1
if test_class[i] == 0: # class is 0
tn += 1.0
elif test_class[i] == 1:
fn += 1.0 # class is 1
elif path[i + 1][1].name == 'stance': # prediction is 1
stances += 1
if test_class[i] == 1: # class is 1
tp += 1.0
elif test_class[i] == 0: # class is 0
fp += 1.0
print (swings)
print (stances)
if (tp + fn) != 0.0:
rospy.logwarn("Sensitivity : " + str(tp / (tp + fn)))
# sensitivity = tp / (tp + fn)
else:
rospy.logwarn("Sensitivity : 0.0")
# sensitivity = 0.0
if (tn + fp) != 0.0:
rospy.logwarn("Specificity : " + str(tn / (tn + fp)))
# specificity = tn_total / (tn_total + fp_total)
else:
rospy.logwarn("Specificity : 0.0")
# specificity = 0.0
if (tn + tp + fn + fp) != 0.0:
rospy.logwarn("Accuracy : " + str((tn + tp) / (tn + tp + fn + fp)))
# accuracy = (tn + tp) / (tn + tp + fn + fp)
else:
rospy.logwarn("Accuracy : 0.0")
# accuracy = 0.0
tn_total += tn
tp_total += tp
fn_total += fn
fp_total += fp
tp_total /= tests
tn_total /= tests
fp_total /= tests
fn_total /= tests
rospy.logerr("TP :" + str(tp_total))
rospy.logerr("TN :" + str(tn_total))
rospy.logerr("FP :" + str(fp_total))
rospy.logerr("FN :" + str(fn_total))
rospy.logerr("Tests :" + str(tests))
if (tp_total + fn_total) != 0.0:
sensitivity = tp_total / (tp_total + fn_total)
else:
sensitivity = 0.0
if (tn_total + fp_total) != 0.0:
specificity = tn_total / (tn_total + fp_total)
else:
specificity = 0.0
if (tn_total + tp_total + fn_total + fp_total) != 0.0:
accuracy = (tn_total + tp_total) / (tn_total + tp_total + fn_total + fp_total)
else:
accuracy = 0.0
rospy.logwarn("----------------------------------------------------------")
rospy.logerr("Total accuracy: " + str(accuracy))
rospy.logerr("Total sensitivity: " + str(sensitivity))
rospy.logerr("Total specificity: " + str(specificity))
stats = [tn_total * tests, fn_total * tests, fp_total * tests, fn_total * tests, tests,
accuracy, sensitivity, specificity]
rospy.logwarn("-------------------DONE-------------------------")
classifier_array.append(model)
stats_array.append(stats)
pickle.dump(classifier_array, open(datafile + "distributed_classifiers.p", 'wb'))
pickle.dump(stats_array, open(datafile + "distributed_stats.p", 'wb'))
scio.savemat(datafile + "distributed_stats.mat", {'stats': stats_array})
for i in range(0, len(full_labels)):
if prev == -1:
prev = full_labels[i]
t[prev][full_labels[i]] += 1.0
prev = full_labels[i]
sum_ += 1.0
t = t / sum
print t
distros = []
hmm_states = []
state_names = ['swing', 'stance']
hmm_states = []
for i in range(0, 2):
dis = MGD.from_samples(class_data[i])
st = State(dis, name=state_names[i])
distros.append(dis)
hmm_states.append(st)
skf = StratifiedKFold(full_labels, n_folds=folds)
for train_index, test_index in skf:
model = HMM(name="Gait")
hmm_states = []
for i in range(0, 2):
# dis = MGD(np.array(class_means[i]).flatten(), np.array(class_cov[i]))
dis = MGD.from_samples(class_data[i])
st = State(dis, name=state_names[i])
def __init__(self, n_trials=3, leave_one_out=1):
"""Variable initialization"""
self.patient = rospy.get_param("gait_phase_det/patient")
self.verbose = rospy.get_param("gait_phase_det/verbose")
self.n_trials = n_trials
self.n_features = 2 # Raw data and 1st-derivative
self.leave_one_out = leave_one_out
self.rec_data = 0.0 # Number of recorded IMU data
self.proc_data = 0.0 # Number of extracted features
self.win_size = 3
self.raw_win = [None] * self.win_size
# self.fder_win = [0] * self.win_size
self.ff = [[] for x in range(self.n_trials)] # Training and test dataset
self.labels = [[] for x in range(self.n_trials)] # Reference labels from local data
self.first_eval = True
self.model_loaded = False
algorithm = rospy.get_param("gait_phase_det/algorithm")
rospy.loginfo('Decoding algorithm: {}'.format(algorithm))
if algorithm not in DECODER_ALGORITHMS:
raise ValueError("Unknown decoder {!r}".format(algorithm))
self.decode = {
"fov": self._run_fov,
"bvsw": self._run_bvsw
}[algorithm]
self.imu_callback = {
"fov": self._fov_callback,
"bvsw": self._bvsw_callback
}[algorithm]
"""HMM variables"""
''' State list:
s1: Heel Strike (HS)
s2: Flat Foot (FF)
s3: Heel Off (HO)
s4: Swing Phase (SP)'''
self.model_name = "Gait"
self.has_model = False
self.must_train = False
self.states = ['s1', 's2', 's3', 's4']
self.n_states = len(self.states)
self.state2phase = {"s1": "hs", "s2": "ff", "s3": "ho", "s4": "sp"}
self.train_data = []
self.mgds = {}
self.dis_means = [[] for x in range(self.n_states)]
self.dis_covars = [[] for x in range(self.n_states)]
self.start_prob = [1.0/self.n_states]*self.n_states
self.trans_mat = np.array([(0.9, 0.1, 0, 0), (0, 0.9, 0.1, 0), (0, 0, 0.9, 0.1), (0.1, 0, 0, 0.9)]) # Left-right model
# self.trans_mat = np.array([0.8, 0.1, 0, 0.1], [0.1, 0.8, 0.1, 0], [0, 0.1, 0.8, 0.1], [0.1, 0, 0.1, 0.8]) # Left-right-left model
self.log_startprob = []
self.log_transmat = np.empty((self.n_states, self.n_states))
self.max_win_len = 11 # ms (120 ms: mean IC duration for healthy subjects walking at comfortable speed)
self.viterbi_path = np.empty((self.max_win_len+1, self.n_states))
self.backtrack = [[None for x in range(self.n_states)] for y in range(self.max_win_len+1)]
self.global_path = []
self.work_buffer = np.empty(self.n_states)
self.boundary = 1
self.buff_len = 0
self.states_pos = {}
for i in range(len(self.states)):
self.states_pos[self.states[i]] = i
self.last_state = -1
self.curr_state = -1
self.conv_point = 0
self.conv_found = False
self.smp_freq = 100.0 # Hz
self.fp_thresh = 1/self.smp_freq*4 # Threshold corresponds to 8 samples
self.time_passed = 0.0
self.obs = [[None for x in range(self.n_features)] for y in range(self.max_win_len)]
self.model = HMM(name=self.model_name)
"""ROS init"""
rospy.init_node('real_time_HMM', anonymous=True)
rospack = rospkg.RosPack()
self.packpath = rospack.get_path('hmm_gait_phase_classifier')
self.init_subs()
self.init_pubs()
"""HMM-training (if no model exists)"""
try:
'''HMM-model loading'''
with open(self.packpath+'/log/HMM_models/'+self.patient+'.txt') as infile:
json_model = json.load(infile)
self.model = HMM.from_json(json_model)
rospy.logwarn(self.patient + "'s HMM model was loaded.")
self.has_model = True
except IOError:
if os.path.isfile(self.packpath + "/log/mat_files/" + self.patient + "_proc_data1.mat"):
"""Training with data collected with FSR-based reference system"""
self.data_ext = 'mat'
self.must_train = True
elif os.path.isfile(self.packpath + "/log/IMU_data/" + self.patient + "_labels.csv"):
"""Training with data collected with offline threshold-based gait phase detection method"""
self.data_ext = 'csv'
self.must_train = True
else:
rospy.logerr("Please collect data for training ({})!".format(self.patient))
if self.must_train:
rospy.logwarn("HMM model not trained yet for {}!".format(self.patient))
rospy.logwarn("Training HMM with local data...")
self.load_data()
self.init_hmm()
self.train_hmm()
self.has_model = True
if self.has_model:
try:
'''MGDs loading if model exists'''
for st in self.states:
with open(self.packpath+'/log/HMM_models/'+self.patient+'_'+self.state2phase[st]+'.txt') as infile:
yaml_dis = yaml.safe_load(infile)
dis = MGD.from_yaml(yaml_dis)
self.mgds[st] = dis
rospy.logwarn(self.patient +"'s " + self.state2phase[st] + " MGC was loaded.")
'''Loading means and covariance matrix'''
self.dis_means[self.states_pos[st]] = self.mgds[st].parameters[0]
self.dis_covars[self.states_pos[st]] = self.mgds[st].parameters[1]
except yaml.YAMLError as exc:
rospy.logwarn("Not able to load distributions: " + exc)
"""Transition and initial (log) probabilities matrices upon training"""
trans_mat = self.model.dense_transition_matrix()[:self.n_states,:self.n_states]
if self.verbose: print '**TRANSITION MATRIX (post-training)**\n'+ str(trans_mat)
for i in range(self.n_states):
self.log_startprob.append(ln(self.start_prob[i]))
for j in range(self.n_states):
self.log_transmat[i,j] = ln(trans_mat[i][j])
self.model_loaded = True
def sample(self, n=10):
try:
X1 = np.stack(self.model.sample(int(np.round(0.8 * n))))
if self.dim == 2:
mean = np.mean(X1, axis=0)
std = np.diag([1.0, 1.0])
gmm = MultivariateGaussianDistribution(mean, std)
X2 = np.stack(gmm.sample(int(np.round(0.1 * n))))
mean = np.mean(X1, axis=0)
std = np.diag([1e-3, 1e-3])
gmm = MultivariateGaussianDistribution(mean, std)
X3 = np.stack(gmm.sample(int(np.round(0.1 * n))))
else:
mean = np.mean(X1, axis=0)
std = np.diag([1.0, 1.0, 1e-3])
gmm = MultivariateGaussianDistribution(mean, std)
X2 = np.stack(gmm.sample(int(np.round(0.1 * n))))
mean = np.mean(X1, axis=0)
std = np.diag([1e-3, 1e-3, 10.0])
gmm = MultivariateGaussianDistribution(mean, std)
X3 = np.stack(gmm.sample(int(np.round(0.1 * n))))
X = np.concatenate((X1, X2, X3))
except ValueError:
print("exception caught on sampling")
if self.dim == 2:
mean = np.zeros(self.dim)
std = np.diag([1.0, 1.0])
gmm = MultivariateGaussianDistribution(mean, std)
X = gmm.sample(int(n))
else:
mean = np.zeros(self.dim)
std = np.diag([1.0, 1.0, 5.0])
gmm = MultivariateGaussianDistribution(mean, std)
X = gmm.sample(int(n))
return X
# looks like 3 is better than 4 components
# TODO kmeans + 4-5 components!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if kmeans:
km = KMeans(n_clusters=3)
y = km.fit_predict(X)
X_1 = X[y == 0]
X_2 = X[y == 1]
X_3 = X[y == 2]
else:
X_1 = X[2000:4000]
X_2 = X[400:800]
X_3 = X[7000:8000]
a = MultivariateGaussianDistribution.from_samples(X_1)
b = MultivariateGaussianDistribution.from_samples(X_2)
c = MultivariateGaussianDistribution.from_samples(X_3)
s1 = State(a, name="M1")
s2 = State(b, name="M2")
s3 = State(c, name="M3")
hmm = HiddenMarkovModel()
hmm.add_states(s1, s2, s3)
hmm.add_transition(hmm.start, s1, 0.34)
hmm.add_transition(hmm.start, s3, 0.33)
hmm.add_transition(hmm.start, s2, 0.33)
hmm.add_transition(s1, s1, 0.9)
hmm.add_transition(s1, s2, 0.05)
hmm.add_transition(s1, s3, 0.05)
def _initDists(self, X, distribution=MultivariateGaussianDistribution):
technique = "R_MV-GMM" # mixture of multivariate gaussain distribution
if (technique == "GMM"):
# gaussian mixture model
#// uvgd = NormalDistribution.from_samples(X)
#// gmm = GeneralMixtureModel([uvgd.copy() for _ in range(self.nmix)])
gmm = GeneralMixtureModel.from_samples(
distributions=[NormalDistribution for _ in range(self.nmix)],
X=X)
dists = [gmm.copy() for _ in range(self.statesNumber)]
elif (technique == "MV-GMM"):
# multivariate gaussian mixture model
#// mvgd = MultivariateGaussianDistribution.from_samples(X)
#// gmm = GeneralMixtureModel([mvgd.copy() for _ in range(self.nmix)])
gmm = GeneralMixtureModel.from_samples(distributions=[
MultivariateGaussianDistribution for _ in range(self.nmix)
],
X=X,
n_components=3)
dists = [gmm.copy() for _ in range(self.statesNumber)]
elif (technique == "MVG"):
self._initkmeans(X=X, numClasses=self.statesNumber)
dists = [
MultivariateGaussianDistribution.from_samples(X=X[y == i])
for i in range(self.statesNumber)
]
elif (technique == "R_GMM"):
# random gaussian mixture model
randNormal = lambda: NormalDistribution(np.random.randint(1, 10), 1
)
randGMM = lambda: GeneralMixtureModel(
[randNormal() for _ in range(self.nmix)])
dists = [randGMM() for _ in range(self.statesNumber)]
elif (technique == "R_MV-GMM"):
# random multivariate gaussian mixture model
randGMM = lambda: GeneralMixtureModel(
[randMVG() for _ in range(self.nmix)])
dists = [randGMM() for _ in range(self.statesNumber)]
return dists
#* not completed:
#! GMM-HMM-k
y = self._initkmeans(X, self.statesNumber)
# list(map(print, y))
return [
GeneralMixtureModel.from_samples(distribution,
X=X[y == i],
n_components=self.nmix)
for i in range(self.statesNumber)
]
#! Kmeans init
if not isinstance(X, BaseGenerator):
data_generator = SequenceGenerator(X, None, None)
else:
data_generator = X
initialization_batch_size = len(data_generator)
X_ = []
data = data_generator.batches()
for i in range(initialization_batch_size):
batch = next(data)
X_.extend(batch[0])
X_concat = np.concatenate(X_)
if X_concat.ndim == 1:
X_concat = X_concat.reshape(X_concat.shape[0], 1)
n, d = X_concat.shape
clf = Kmeans(self.statesNumber, init="kmeans++",
n_init=1) # init should be one of
clf.fit(X_concat, max_iterations=None, batches_per_epoch=None)
y = clf.predict(X_concat)
if callable(distribution):
if d == 1:
dists = [
distribution.from_samples(X_concat[y == i][:, 0])
for i in range(self.statesNumber)
]
elif distribution.blank().d > 1:
dists = [
distribution.from_samples(X_concat[y == i])
for i in range(self.statesNumber)
]
else:
print("error")
return dists
def __init__(self, dim , seed=None): #
K = 9
theta0=[.5,.5]
beta=np.ones(K)
Psi = .1*np.diag(np.ones(dim))
#mu0= np.zeros(dim)
#lambd=.1,
nu=dim+2.
rstate = np.random.get_state()
np.random.seed(seed)
unif_dist = UniformDistribution(0.,1.)
self.theta0 = theta0
beta_dist = DirichletDistribution(beta)
self.dim = Psi.shape[0]
self.dists = []
#same weights for both
weights = beta_dist.sample()
mus = []
for i,_ in enumerate(theta0):
#weights = beta_dist.sample()
#print(weights)
mix = []
for j,_ in enumerate(weights):
if j%3==0:
Sigma = invwishart.rvs(df=nu, scale=Psi)
elif j%3==1:
Sigma = invwishart.rvs(df=nu, scale=.01*Psi)
else:
Sigma = invwishart.rvs(df=nu, scale=.0001*Psi)
if i==0:
mu = unif_dist.sample(self.dim)
#mu =MultivariateGaussianDistribution(mu0,Sigma/lambd).sample()
mus.append(mu)
else:
mu = mus[j]
mix.append( MultivariateGaussianDistribution(mu, Sigma) )
model = GeneralMixtureModel(mix, weights=weights)
self.dists.append(model)
for d in self.dists:
print(d)
self.rstate = np.random.get_state()
np.random.set_state(rstate)
X_333 = X[y == 8]
else:
X_1 = X[2000:3000]
X_11 = X[3000:4000]
X_111 = X[4000:4500]
X_2 = X[400:500]
X_22 = X[500:600]
X_222 = X[600:800]
X_3 = X[7000:7300]
X_33 = X[7300:7600]
X_333 = X[7600:8000]
a = MultivariateGaussianDistribution.from_samples(X_1)
aa = MultivariateGaussianDistribution.from_samples(X_11)
aaa = MultivariateGaussianDistribution.from_samples(X_111)
b = MultivariateGaussianDistribution.from_samples(X_2)
bb = MultivariateGaussianDistribution.from_samples(X_22)
bbb = MultivariateGaussianDistribution.from_samples(X_222)
c = MultivariateGaussianDistribution.from_samples(X_3)
cc = MultivariateGaussianDistribution.from_samples(X_33)
ccc = MultivariateGaussianDistribution.from_samples(X_333)
s1 = State(a, name="M1")
s11 = State(aa, name="M11")
s111 = State(aaa, name="M111")
def sample(self, n=10):
try:
X1 = np.stack(self.model.sample(int(np.round(0.8 * n))))
# np.round 取最近的整数
# 从多元高斯分布中采样8个点
if self.dim == 2:
mean = np.mean(X1, axis=0)
# 由X1的采样点计算均值
std = np.diag([1.0, 1.0])
gmm = MultivariateGaussianDistribution(mean, std)
# 构建一个新的多元高斯分布
X2 = np.stack(gmm.sample(int(np.round(0.1 * n))))
# 采样1个点
mean = np.mean(X1, axis=0)
std = np.diag([1e-3, 1e-3]) # 标准差不同了
gmm = MultivariateGaussianDistribution(mean, std)
X3 = np.stack(gmm.sample(int(np.round(0.1 * n))))
# 又采样了一个点
else:
mean = np.mean(X1, axis=0)
std = np.diag([1.0, 1.0, 1e-3])
gmm = MultivariateGaussianDistribution(mean, std)
X2 = np.stack(gmm.sample(int(np.round(0.1 * n))))
mean = np.mean(X1, axis=0)
std = np.diag([1e-3, 1e-3, 10.0])
gmm = MultivariateGaussianDistribution(mean, std)
X3 = np.stack(gmm.sample(int(np.round(0.1 * n))))
X = np.concatenate((X1, X2, X3)) # 多尺度采样？
except ValueError:
print("exception caught on sampling")
if self.dim == 2:
mean = np.zeros(self.dim)
std = np.diag([1.0, 1.0])
gmm = MultivariateGaussianDistribution(mean, std)
X = gmm.sample(int(n))
else:
mean = np.zeros(self.dim)
std = np.diag([1.0, 1.0, 5.0])
gmm = MultivariateGaussianDistribution(mean, std)
X = gmm.sample(int(n))
return X