def get_objective_function(self):
clusters = [[] for _ in range(self.c)]
for key in self.elements.keys():
clusters[self.elements[key]].append(key)
energy = 0
for i in range(self.c):
k_lim = len(clusters[i])
for k in range(k_lim):
energy += (1 - f.gaussian_kernel(
self.weights, np.array(self.view.iloc[clusters[i][k]]),
np.array(self.prototypes[i])))
return energy
def optimize_partition(self):
test = 1
ite = 0
while (test):
ite += 1
# clusters = [[] for _ in range(self.c)]
# for key in self.elements.keys():
# clusters[self.elements[key]].append(key)
#Calculating best prototypes
self.update_prototypes(self.clusters)
#calculating hyper parameters
self.update_weights(self.clusters)
#Allocating in partitions
test = 0
for k in range(self.rows):
dist = float("inf")
nearest_cluster = 0
#Kernel between element and cluster prototype
for h in range(self.c):
x = 2 * (1 - f.gaussian_kernel(
self.weights, np.array(self.view.iloc[k]),
np.array(self.prototypes[h])))
if (x < dist):
nearest_cluster = h
dist = x
if (nearest_cluster != self.elements[k]):
test = 1
nearest_cluster_old = self.elements[k]
self.elements[k] = nearest_cluster
#Adding to new cluster
self.clusters[nearest_cluster].append(k)
self.item_to_position[nearest_cluster][k] = len(
self.clusters[nearest_cluster]) - 1
#Removing from old cluster
position = self.item_to_position[nearest_cluster_old].pop(
k)
last_item = self.clusters[nearest_cluster_old].pop()
if position != len(self.clusters[nearest_cluster_old]):
self.clusters[nearest_cluster_old][
position] = last_item
self.item_to_position[nearest_cluster_old][
last_item] = position
def update_prototypes(self, clusters):
for i in range(self.c):
#Do not fool yourself: Numerator is a vector
num = 0
denom = 0
j_lim = len(clusters[i])
for j in range(j_lim):
kernel = f.gaussian_kernel(self.weights,
self.view.iloc[clusters[i][j]],
self.prototypes[i])
num += kernel * self.view.iloc[clusters[i][j]]
denom += kernel
if (denom != 0):
self.prototypes[i] = num / denom
else:
print("denominador igual a zero no update do prototipo!")
def initialize_partitions(self):
self.elements = {}
self.clusters = [[] for _ in range(self.c)]
self.item_to_position = clusters = [{} for _ in range(self.c)]
for el in range(self.rows):
dist = float("inf")
nearest_cluster = 0
for h in range(self.c):
#Kernel between element and cluster prototype
x = 2 * (1 - f.gaussian_kernel(self.weights,
np.array(self.view.iloc[el]),
np.array(self.prototypes[h])))
if (x < dist):
nearest_cluster = h
dist = x
self.elements[el] = nearest_cluster
self.clusters[nearest_cluster].append(el)
self.item_to_position[nearest_cluster][el] = len(
self.clusters[nearest_cluster]) - 1
def update_weights(self, cluster):
new_weights = self.p * [None]
vetor_somas = np.zeros(self.p)
#Calculo denominador
for h in range(self.p):
sum_kernels = 0
for i in range(self.c):
k_lim = len(cluster[i])
for k in range(k_lim):
#An Element from cluster
x_k = np.array(self.view.iloc[cluster[i][k]])
#Prototype from cluster
g_i = self.prototypes[i]
sum_kernels += f.gaussian_kernel(
self.weights, x_k,
g_i) * (x_k[h] - g_i[h]) * (x_k[h] - g_i[h])
vetor_somas[h] = sum_kernels
numerador = (self.gamma**(1 / self.p)) * np.prod(vetor_somas
**(1 / self.p))
self.weights = np.divide(numerador, vetor_somas)
marker='o')
plt.plot(xp, yp)
plt.xlim(0, 4.5)
plt.ylim(1.5, 5)
plt.show()
input('Program paused. Press enter to continue.\n')
plt.close()
# ########## Part3: Implementing Gaussian Kernel ##########
print('Evaluating the Gaussian Kernel ...\n')
x1 = np.array([1, 2, 1])
x2 = np.array([0, 4, -1])
sigma = 2
sim = gaussian_kernel(x1, x2, sigma)
print(
'Gaussian Kernel between x1 = [1; 2; 1], x2 = [0; 4; -1], sigma = {0} :\n'.
format(sigma),
'\t{0:.6f}\n(for sigma = 2, this value should be about 0.324652)'.format(
sim))
input('Program paused. Press enter to continue.\n')
plt.close()
# ########## Part4: Visualizing Dataset 2 ##########
data = sio.loadmat('ex6data2.mat')
X = data['X'] # 863 x 2 matrix
y = data['y'] # 863 x 1 matrix