def g_estimation(data_set, size, alpha, posterior, dim, K):
G = []
data_set = CONCAT((data_set, FULL((size, 1), 1)), axis=1)
pixel_log = ASARRAY([LOG(data / SUM(data)) for data in data_set])
for index, aV in enumerate(alpha):
G.append(g_matrix_generator(aV, posterior[:, [index]], pixel_log, dim))
return ASARRAY(G)
def fisher_info_inv(alpha, beta, q_alpha, q_beta, q_a_sqr, q_b_sqr, q_a_b_sqr, k, dim):
updated_alpha = []
updated_beta = []
for aV, bV, qAV, qBV, qASqrV, qBSqrV, qABSqrV in zip(alpha, beta, q_alpha, q_beta, q_a_sqr, q_b_sqr, q_a_b_sqr):
for aVal, bVal, qAVal, qBVal, qASqVal, qBSqVal, qABSqVal in zip(aV, bV, qAV, qBV, qASqrV, qBSqrV, qABSqrV):
h_inverse = INVERSE(ASARRAY([qASqVal, qABSqVal, qABSqVal, qBSqVal]).reshape(2, 2))
theta = ASARRAY([aVal, bVal]).reshape(2, 1) - 0.5* MATMUL(h_inverse, ASARRAY([qAVal, qBVal]).reshape(2, 1))
updated_alpha.append(theta[0])
updated_beta.append(theta[1])
return ASARRAY(updated_alpha).reshape(k, dim), ASARRAY(updated_beta).reshape(k, dim)
def initial_algorithm(no_of_clusters):
data_set, size = IRIS()
data_set = NORMALIZE(data_set) + sys.float_info.epsilon
labels_kmeans = ASARRAY(KM(data_set,
no_of_clusters).predict()).reshape(1, size)
clusters, unique_clusters, dimension = split_Pixels_Based_On_Label(
labels_kmeans[0], data_set)
initial_py = ASARRAY(mixer_estimator(clusters,
size)).reshape(1, no_of_clusters)
initial_alpha = method_of_moment(no_of_clusters, clusters, dimension)
return initial_alpha, data_set, dimension, size, initial_py
def clusterDropTest(mix, alpha, dropingCriteria, K, DIM, pixelSize):
mixInfo = []
alphaInfo = []
for j in range(K):
if SUM(mix[:, j: j + 1]) > dropingCriteria:
mixInfo.append(mix[:, j: j + 1])
alphaInfo.append(alpha[j])
else:
print("Cluster having alpha :", alpha[j], " & Mix :", j, " is removed!")
return (ASARRAY(mixInfo).T).reshape(pixelSize, len(alphaInfo)), ASARRAY(alphaInfo).reshape(len(alphaInfo),
DIM), len(mixInfo)
def hessian(dim, posterior, alpha):
h_diagonal = []
h_constant = []
h_a = []
for index, a_vector in enumerate(alpha):
p_sum = SUM(posterior[:, index])
a_tri_gamma = POLYGAMMA(1, a_vector)
a_tri_gamma_sum = POLYGAMMA(1, SUM(a_vector))
h_diagonal.append(DIAGONAL(1 / (-1 * p_sum * a_tri_gamma)))
h_constant.append(((a_tri_gamma_sum * SUM(1 / a_tri_gamma)) - 1) *
a_tri_gamma_sum * p_sum)
h_a.append(((-1 / p_sum) * (1 / a_tri_gamma)).reshape(1, dim + 1))
return ASARRAY(h_diagonal), h_constant, ASARRAY(h_a)
def cluster_drop_test(mix, alpha, cluster_drop_val, K, dim):
mix_arr = []
alpha_arr = []
mix = mix[0]
for j in range(K):
if mix[j] > cluster_drop_val:
mix_arr.append(mix[j])
alpha_arr.append(alpha[j])
else:
print("Cluster having alpha :", alpha[j], " & Mix :", j,
" & Value :", mix[j], " is removed!")
mix_arr = ASARRAY(mix_arr)
alpha_arr = ASARRAY(alpha_arr)
return mix_arr.reshape(1, mix_arr.size), alpha_arr.reshape(
len(alpha_arr), dim + 1), mix_arr.size
def method_of_moment(K, clusterSet, DIM):
alpha = ZEROS((K, DIM))
for label in clusterSet:
sum = 0
for d in range(DIM):
clusterSet[label] = ASARRAY(clusterSet[label])
mean = MEAN(clusterSet[label][:, [d]])
den = VAR(clusterSet[label][:, [d]]) + sys.float_info.epsilon
alpha_D_pls_One = ((POW(mean, 2) + mean) / den) + 2
sum += alpha_D_pls_One
alpha[label][d] = mean * (alpha_D_pls_One - 1)
return NORMALIZE(alpha)
def method_of_moment(K, cluster_set, dim):
alpha = ZEROS((K, dim + 1))
for label in cluster_set:
alpha_sum = 0
for d in range(dim):
cluster_set[label] = ASARRAY(cluster_set[label])
mean = MEAN(cluster_set[label][:, [d]])
den = VAR(cluster_set[label][:, [d]]) + sys.float_info.epsilon
alpha_d_pls_One = ((POW(mean, 2) + mean) / den) + 2
alpha_sum += alpha_d_pls_One
alpha[label][d] = mean * (alpha_d_pls_One - 1)
alpha[label][dim] = MEAN(alpha_sum)
return NORMALIZE(alpha)
def g_estimation(self, data_set, alpha, beta, posterior, dim, K):
q_alpha = []
q_beta = []
q_alpha_square = []
q_beta_square = []
q_alpha_beta_square = []
for index, (a_vector, b_vector) in enumerate(zip(alpha, beta)):
a_d_gamma = POLYGAMMA(0, a_vector).reshape(1, dim)
b_d_gamma = POLYGAMMA(0, b_vector).reshape(1, dim)
ab_d_gamma = POLYGAMMA(0, a_vector + b_vector).reshape(1, dim)
a_t_gamma = POLYGAMMA(1, a_vector).reshape(1, dim)
b_t_gamma = POLYGAMMA(1, b_vector).reshape(1, dim)
ab_t_gamma = POLYGAMMA(1, a_vector + b_vector).reshape(1, dim)
a_data = ASARRAY([LOG(data / (1 + data)) for data in data_set]).reshape(len(data_set), dim)
b_data = ASARRAY([LOG(1 / (1 + data)) for data in data_set]).reshape(len(data_set), dim)
q_alpha.append(SUM(posterior[:, [index]] * (ab_d_gamma - a_d_gamma + a_data), axis=0).reshape(1, dim))
q_beta.append(SUM(posterior[:, [index]] * (ab_d_gamma - b_d_gamma + b_data), axis=0).reshape(1, dim))
q_alpha_square.append(SUM(posterior[:, [index]] * (ab_t_gamma - a_t_gamma), axis=0).reshape(1, dim))
q_beta_square.append(SUM(posterior[:, [index]] * (ab_t_gamma - b_t_gamma), axis=0).reshape(1, dim))
q_alpha_beta_square.append(SUM(posterior[:, [index]] * ab_t_gamma, axis=0).reshape(1, dim))
return ASARRAY(q_alpha).reshape(K, dim), ASARRAY(q_beta).reshape(K, dim), ASARRAY(q_alpha_square).reshape(K, dim), ASARRAY(
q_beta_square).reshape(K, dim), ASARRAY(q_alpha_beta_square).reshape(K, dim)
def pdf_fetcher(self):
result = []
for p_v in self.img_pixels:
result.append([self.pdf(p_v, a_v, b_v) for a_v, b_v in zip(self.alpha, self.beta)])
return ASARRAY(result)
def posterior_estimator(pdf, mix):
return ASARRAY([(mix * pV) / SUM(mix * pV) for pV in pdf]).reshape(len(pdf), mix.size)
def geo_transformation(pixels, DIM, pixelSize):
return ASARRAY(
[pixels[:, d:d + 1] / (1 + SUM(pixels[:, 0:d], axis=1).reshape(pixelSize, 1)) for d in
range(DIM)]).T.reshape(
pixelSize, DIM)
def intialMixerEstimator(mix, pixelSize, K):
return ASARRAY([FULL((pixelSize, 1), pi)
for pi in mix]).T.reshape(pixelSize, K)
def alpha_updater(alpha_set, hessian_inverse, G, K, dim):
return ASARRAY([
alpha_set[j].reshape(dim + 1, 1) -
0.9 * MATMUL(hessian_inverse[j], G[j]) for j in range(K)
]).reshape(K, dim + 1)
def hessian_inverse(K, diagonal, constant, a):
return ASARRAY(
[diagonal[j] + (constant[j] * MATMUL(a[j].T, a[j])) for j in range(K)])