def _alternate_descent(self):
n, d = self.X.shape
self.centers = cluster._init_centers(self.centers, self.X,
self.n_clusters)
self.memberships = cluster._init_memberships(self.memberships,
self.centers, self.X,
self.n_clusters)
self.weights = cluster._init_weights(self.weights, self.X,
self.n_clusters)
self.memberships, self.centers = super()._alternate_descent()
for niter in range(self.max_iter):
if self.verbose & Verbosity.COST_FUNCTION:
self._log_cost(self.centers, self.memberships, self.weights)
cst = np.min(
1 / self._memberships_hessian(self.memberships, self.centers))
print("Cst is {}".format(cst))
#print("Cst is now {}".format(cst))
new_memberships = _pfscm_prox_gradient(
self.memberships,
self._memberships_gradient,
_prox_op,
cst,
prox_arg=cst * self.memberships_gamma,
max_iter=10,
tol=self.tol,
grad_args=(self.X, self.centers))
new_centers = self._update_centers(self.X, self.n_clusters,
self.weights, new_memberships)
gain = np.linalg.norm(new_centers - self.centers)
if gain < self.tol:
break
self.centers = new_centers
self.memberships = new_memberships
return self.memberships, self.centers
def weighted_fcm(x,
n_clusters,
max_iter=300,
tol=1e-4,
centers=None,
memberships=None,
weights=None,
**kwargs):
n, d = x.shape
centers = cluster._init_centers(centers, x, n_clusters, **kwargs)
memberships = cluster._init_memberships(memberships, centers, x,
n_clusters, **kwargs)
weights = _init_weights(weights, x, n_clusters)
for i in range(max_iter):
new_memberships = cluster._update_memberships(x, n_clusters, weights,
centers, **kwargs)
new_centers = cluster._update_centers(x, n_clusters, weights,
new_memberships, **kwargs)
new_weights = _new_update_weights(x, n_clusters, new_memberships,
new_centers, **kwargs)
if np.linalg.norm(new_centers - centers) < tol:
break
memberships = new_memberships
centers = new_centers
weights = new_weights
return (memberships, centers, weights)
def _alternate_descent(self):
n, d = self.X.shape
self._init_weights()
centers = cluster._init_centers(self.centers, self.X, self.n_clusters)
memberships = cluster._init_memberships(self.memberships, centers,
self.X, self.n_clusters)
for i in range(self.max_iter):
if self.verbose & Verbosity.COST_FUNCTION:
self._log_cost(centers, memberships, self.weights)
new_memberships = self._update_memberships(self.X, self.weights,
centers)
new_centers = self._update_centers(self.X, self.weights,
new_memberships)
# print(new_memberships)
# print("centers")
# print(new_centers)
# print("weights")
# print(self.weights)
# print(self._compute_inertia(self.X, centers, memberships,
# self.weights, _mode="debug"))
new_weights = self._update_weights(self.X, new_memberships,
new_centers, self.weights)
# print(self._compute_inertia(self.X, centers, memberships,
# new_weights, _mode="debug"))
if np.linalg.norm(new_centers - centers) < self.tol:
break
memberships = new_memberships
centers = new_centers
self.weights = new_weights
if self.verbose & Verbosity.COST_FUNCTION:
self._log_cost(centers, memberships, self.weights)
return memberships, centers
def laplacian_weighted_fcm(x,
n_clusters,
weights,
affinity,
gamma=1.,
max_iter=300,
tol=1e-4,
centers=None,
memberships=None,
**kwargs):
n, d = x.shape
centers = cluster._init_centers(centers, x, n_clusters, **kwargs)
memberships = cluster._init_memberships(memberships, centers, x,
n_clusters, **kwargs)
for i in range(max_iter):
new_memberships = _new_laplacian_memberships(x,
n_clusters,
weights,
centers,
affinity,
memberships,
gamma=gamma,
**kwargs)
new_centers = cluster._update_centers(x, n_clusters, weights,
new_memberships, **kwargs)
if np.linalg.norm(new_centers - centers) + np.linalg.norm(
new_memberships - memberships) < tol:
break
memberships = new_memberships
centers = new_centers
return memberships, centers
def _alternate_descent(self):
n, d = self.X.shape
self.centers = cluster._init_centers(self.centers, self.X,
self.n_clusters)
self.memberships = cluster._init_memberships(self.memberships,
self.centers, self.X,
self.n_clusters)
self.weights = cluster._init_weights(self.weights, self.X,
self.n_clusters)
fcm_init = cluster.FCMeans(self.n_clusters)
fcm_init.fit(self.X)
# self.memberships, self.centers = fcm_init.memberships, fcm_init.centers
for i in range(self.max_iter):
if self.verbose & Verbosity.COST_FUNCTION:
self._log_cost(self.centers, self.memberships, self.weights)
new_memberships = self._update_memberships(self.X, self.n_clusters,
self.weights,
self.centers,
self.memberships)
new_centers = self._update_centers(self.X, self.n_clusters,
self.weights, new_memberships)
new_weights = self._update_weights(self.X, self.n_clusters,
new_memberships, new_centers)
if np.linalg.norm(new_centers - self.centers) < self.tol:
break
self.memberships = new_memberships
self.centers = new_centers
self.weights = new_weights
if self.verbose & Verbosity.COST_FUNCTION:
self._log_cost(self.centers, self.memberships, self.weights)
self._fcm_init = fcm_init
return self.memberships, self.centers, self.weights
def _alternate_descent(self):
n, d = self.X.shape
self.centers = cluster._init_centers(self.centers, self.X,
self.n_clusters)
self.memberships = cluster._init_memberships(self.memberships,
self.centers, self.X,
self.n_clusters)
self.weights = cluster._init_weights(self.weights, self.X,
self.n_clusters)
self.memberships, self.centers = cluster.FCMeans._alternate_descent(
self)
for niter in range(self.max_iter):
if self.verbose & Verbosity.COST_FUNCTION:
self._log_cost(self.centers, self.memberships, self.weights)
memberships_cst = np.min(1 / self._memberships_hessian(
self.memberships, self.centers, self.weights))
new_memberships = _pfscm_prox_gradient(
self.memberships,
self._memberships_gradient,
_prox_op,
memberships_cst,
prox_arg=memberships_cst * self.memberships_gamma,
max_iter=10,
tol=self.tol,
grad_args=(self.X, self.centers, self.weights))
#print(np.sum(new_memberships))
new_centers = self._update_centers(self.X, self.n_clusters,
self.weights, new_memberships)
weights_cst = np.min(1 / self._weights_hessian(
new_memberships, new_centers, n, d, self.n_clusters))
new_weights = _pfscm_prox_gradient(
self.weights,
self._weights_gradient,
_sparsity_prox_op,
weights_cst,
prox_arg=weights_cst * self.weights_gamma,
max_iter=10,
tol=self.tol,
grad_args=(self.X, new_centers, new_memberships))
gain = np.linalg.norm(new_centers - self.centers)
#print(self.centers)
#print(gain)
if gain < self.tol:
break
self.weights = new_weights
self.centers = new_centers
self.memberships = new_memberships
return self.memberships, self.centers, self.weights
def _alternate_descent(self):
n, d = self.X.shape
centers = cluster._init_centers(self.centers, self.X, self.n_clusters)
memberships = cluster._init_memberships(self.memberships, centers,
self.X, self.n_clusters)
weights = cluster._init_weights(self.weights, self.X, self.n_clusters)
for i in range(self.max_iter):
if self.verbose & Verbosity.COST_FUNCTION:
self._log_cost(centers, memberships, weights)
new_memberships = self._update_memberships(self.X, self.n_clusters,
weights, centers)
new_centers = self._update_centers(self.X, self.n_clusters,
weights, new_memberships)
new_weights = self._update_weights(self.X, self.n_clusters,
new_memberships, new_centers)
if np.linalg.norm(new_centers - centers) < self.tol:
break
memberships = new_memberships
centers = new_centers
weights = new_weights
if self.verbose & Verbosity.COST_FUNCTION:
self._log_cost(centers, memberships, weights)
return memberships, centers, weights
def sparsity_pfscm(x,
n_clusters,
max_iter=100,
tol=1e-4,
gamma_const=0.1,
verbose=Verbosity.NONE,
**kwargs):
if verbose is False or verbose is None:
verbose = Verbosity.NONE
if verbose is True:
verbose = Verbosity.ALL
DEBUG = []
(n, d) = x.shape
m = v = 2.
centers = cluster._init_centers(None, x, n_clusters)
#print(centers)
memberships = np.zeros((n_clusters, n))
for i in range(n):
r = random.randint(0, n_clusters - 1)
memberships[r, i] = 1
weights = np.ones((n_clusters, d))
weights *= 1. / d
if sp.issparse(x):
weights = sp.csc_matrix(weights)
xcsc = x.tocsc() # Used in gradient descent
#print("Fin CSC")
for niter in range(max_iter):
if verbose & Verbosity.COST_FUNCTION:
xs = xcsc if sp.issparse(x) else x
kwargs["cost_function"].append(
_cost_function(xs, centers, memberships, weights, gamma_const))
#print("Iteration #{}".format(niter))
clus = cluster.weighted_fcm(x,
n_clusters,
weights,
max_iter=max_iter,
tol=tol,
centers=centers,
memberships=memberships,
verbose=verbose,
**kwargs)
#print("Fin clustering")
new_centers = clus[1]
#print(new_centers)
new_memberships = clus[0]
#print(weights)
# computation of an ad-hoc descent step...
h_norm = 0
if sp.issparse(x):
for r in range(n_clusters):
for i in range(n):
for jptr in range(x.indptr[i], x.indptr[i + 1]):
j = x.indices[jptr]
h_norm += v * new_memberships[
r, i]**m * np.linalg.norm(x.data[jptr] -
new_centers[r, j])**2
cst = 1. / (h_norm)
new_weights = _pfscm_prox_gradient(weights,
_pfscm_grad,
_sparsity_prox_op,
cst,
prox_arg=cst * gamma_const,
max_iter=10,
tol=tol,
grad_args=(xcsc, new_centers,
new_memberships))
weight_gain = sp.linalg.norm(new_weights - weights)
else:
for j in range(d):
for r in range(n_clusters):
h_norm += v * sum(new_memberships[r, i]**m *
(x[i, j] - new_centers[r, j])**2
for i in range(n))
cst = 1. / h_norm
new_weights = _pfscm_prox_gradient(weights,
_pfscm_grad,
_sparsity_prox_op,
cst,
prox_arg=cst * gamma_const,
max_iter=10,
tol=tol,
grad_args=(x, new_centers,
new_memberships))
weight_gain = np.linalg.norm(new_weights - weights)
#print(cst)
gain = np.linalg.norm(new_centers -
centers) + weight_gain + np.linalg.norm(
new_memberships - memberships)
#print(gain)
if gain < tol:
#print("Itération", niter)
break
else:
#print("gain", gain, "itération", i)
#print(centers)
#print(new_centers)
pass
#print(np.linalg.norm(new_centers - centers)) # + np.linalg.norm(new_weights - weights))
#print(centers)
#print(new_centers)
#print(np.linalg.norm(new_weights - weights))
#print(new_weights)
#print(np.linalg.norm(new_memberships - memberships))
weights = new_weights
centers = new_centers
memberships = new_memberships
clus = cluster.weighted_fcm(x,
n_clusters,
weights,
max_iter=max_iter,
tol=tol,
centers=centers,
memberships=memberships)
memberships = clus[0]
centers = clus[1]
if verbose & Verbosity.COST_FUNCTION:
xs = xcsc if sp.issparse(x) else x
kwargs["cost_function"].append(
_cost_function(xs,
centers,
memberships,
weights,
gamma_const,
distance_f=distance_f))
return memberships, centers, weights
