def goKmeans():
clusteringNum = request.form['clusteringNum']
dataset = json.loads(request.form.get('dataset'))
if (clusteringNum == '' or int(float(clusteringNum)) < 2):
clusteringNum = 2
dataset = np.array(dataset)
#dataset = np.delete(dataset, 0, 1)
new_list = list(
list(float(a) for a in b if BN.is_number(a)) for b in dataset)
kmeans = KMeans(n_clusters=int(float(clusteringNum)),
random_state=0).fit(new_list)
new_list_as_array = np.array(new_list)
SilhouetteVisualize = SilhouetteVisualizer(kmeans)
SilhouetteVisualize.fit(new_list_as_array)
if (len(new_list) > 10):
k_upper_bound = 10
else:
k_upper_bound = len(new_list)
KElbowVisualize = KElbowVisualizer(KMeans(), k=k_upper_bound)
KElbowVisualize.fit(new_list_as_array) # Fit the data to the visualizer
silhouette = SilhouetteVisualize.silhouette_score_
elbow = KElbowVisualize.elbow_value_
return jsonify({
'inputArray': list(new_list),
'kmeansLabels': (kmeans.labels_.tolist()),
'elbowValue': str(elbow),
'silhouetteValue': ('%.3f' % silhouette)
})
def makespaces(s2, k, alpha, beta, legend, title):
kk = pd.DataFrame({
'Skew²': s2,
'Kurtosis': k,
'Alpha': alpha,
'Beta': beta
})
K = 8
model = KMeans()
visualizer = KElbowVisualizer(model, k=(1, K))
kIdx = visualizer.fit(
kk.drop(columns="Beta")) # Fit the data to the visualizer
visualizer.show() # Finalize and render the figure
kIdx = kIdx.elbow_value_
model = KMeans(n_clusters=kIdx).fit(kk.drop(columns="Beta"))
fig = plt.figure()
ax = Axes3D(fig)
cmap = plt.get_cmap('gnuplot')
clr = [cmap(i) for i in np.linspace(0, 1, kIdx)]
for i in range(0, kIdx):
ind = (model.labels_ == i)
ax.scatter(kk["Skew²"][ind],
kk["Kurtosis"][ind],
kk["Alpha"][ind],
s=30,
c=clr[i],
label='Cluster %d' % i)
ax.set_xlabel("Skew²")
ax.set_ylabel("Kurtosis")
ax.set_zlabel(r"$\alpha$")
ax.legend()
plt.title(title + ": EDF-K-means")
plt.savefig(title + "EDF.png")
plt.show()
model = KMeans()
visualizer = KElbowVisualizer(model, k=(1, K))
kIdx = visualizer.fit(
kk.drop(columns="Alpha")) # Fit the data to the visualizer
visualizer.show() # Finalize and render the figure
kIdx = kIdx.elbow_value_
model = KMeans(n_clusters=kIdx).fit(kk.drop(columns="Alpha"))
fig = plt.figure()
ax = Axes3D(fig)
cmap = plt.get_cmap('gnuplot')
clr = [cmap(i) for i in np.linspace(0, 1, kIdx)]
for i in range(0, kIdx):
ind = (model.labels_ == i)
ax.scatter(kk["Skew²"][ind],
kk["Kurtosis"][ind],
kk["Beta"][ind],
s=30,
c=clr[i],
label='Cluster %d' % i)
ax.set_xlabel("Skew²")
ax.set_ylabel("Kurtosis")
ax.set_zlabel(r"$\beta$")
ax.legend()
plt.title(title + ": EPSB-K-means")
plt.savefig(title + "EPSB.png")
plt.show()
def elbow_method(bag_of_words): model = KMeans() visualizer = KElbowVisualizer(model,k = (2,12)) visualizer.fit(bag_of_words) plt.cla() plt.close() return visualizer.elbow_value_
def bins(self, data, labels):
bins = []
for feature in self.to_discretize:
x = np.reshape(data[:, feature], (-1, 1))
model = KMeans()
visualizer = KElbowVisualizer(model, k=(3,12))
visualizer.fit(x)
n_bins = visualizer.elbow_value_
kmeans = KBinsDiscretizer(n_bins=n_bins, encode='ordinal', strategy='kmeans')
if self.filename != "":
plt.show(block=False)
plt.savefig(self.filename + "/" + str(self.feature_names[feature]) + "_elbow_visualisation.png")
plt.close('all')
kmeans.fit(x)
qts = []
for biner in kmeans.bin_edges_:
qts.append(biner)
qts = np.array(qts)
if qts.shape[0] == 0:
qts = np.array([np.median(data[:, feature])])
else:
qts = np.sort(qts)
bins.append(qts)
return bins
def elbow_method(X):
model = KMeans()
visualizer = KElbowVisualizer(model, k=(2, 12))
visualizer.fit(X)
plt.clf()
#visualizer.show()
return visualizer.elbow_value_
def makeK(d,ilist, title):
d=np.array(d)
kk=pd.DataFrame({'Variance': d[:,0], 'Skewness': d[:,1], 'Kurtosis': d[:,2]})
K=20
model=KMeans()
visualizer = KElbowVisualizer(model, k=(1,K))
kIdx=visualizer.fit(kk) # Fit the data to the visualizer
visualizer.show() # Finalize and render the figure
kIdx=kIdx.elbow_value_
model=KMeans(n_clusters=kIdx).fit(kk)
# scatter plot
fig = plt.figure()
ax = Axes3D(fig) #.add_subplot(111))
cmap = plt.get_cmap('gnuplot')
clr = [cmap(i) for i in np.linspace(0, 1, kIdx)]
for i in range(0,kIdx):
ind = (model.labels_==i)
ax.scatter(d[ind,2],d[ind,1], d[ind,0], s=30, c=clr[i], label='Cluster %d'%i)
ax.set_xlabel("Kurtosis")
ax.set_ylabel("Skew")
ax.set_zlabel("Variance")
plt.title(title+': KMeans clustering with K=%d' % kIdx)
plt.legend()
plt.savefig(title+"clustersnoises.png")
plt.show()
d=pd.DataFrame({'Variance': d[:,0], 'Skewness': d[:,1], 'Kurtosis': d[:,2], 'Alpha': d[:,3], 'Beta': d[:,4], "Cluster": model.labels_}, index=ilist)
return d
def km(img, number, g, dr, opa, parametr_p, rz_x):
# plt.cla()
# plt.clf()
x = g[0]
y = g[1]
# Если имеется массив центроидов
if len(x) > 0 and len(y) > 0:
mkm_width, caff = rz(1214.6, img, rz_x)
# zip (..., ..., img[x, y])
z = [list(hhh) for hhh in zip(x, y)]
# elbow method
model = KMeans()
vis = KElbowVisualizer(model, k=(1, 15))
vis.fit(np.array(z))
contours = measure.find_contours(img, 0.5)
k = KMeans(n_clusters=vis.elbow_value_).fit(z)
x_t = list(k.cluster_centers_[:, 0])
y_t = list(k.cluster_centers_[:, 1])
array_x_t.append(x_t)
array_y_t.append(y_t)
log.info('Параметр порога - {}'.format(parametr_p))
return img, contours, y_t, x_t, parametr_p, mkm_width, caff, k.cluster_centers_
else:
log.info("Не можем определить центроиды")
def elbow_method(column):
# Instantiate the clustering model
model = KMeans()
visualizer = KElbowVisualizer(model, k=(1, 11), timings=False)
# Plot visualizer
plt.figure(figsize=(10, 5))
# Fit the data to the visualizer
visualizer.fit(column)
return visualizer
def mbkmm(z):
model = MiniBatchKMeans()
vis = KElbowVisualizer(model, k=(1, 15))
vis.fit(np.array(z))
k = MiniBatchKMeans(n_clusters=vis.elbow_value_).fit(z)
x_t = list(k.cluster_centers_[:, 0])
y_t = list(k.cluster_centers_[:, 1])
return x_t, y_t
def check_test_unimodal_data(self,
counterfactual_in_sphere,
instances_in_sphere,
radius,
counterfactual_libfolding=None):
""" Test over instances in the hypersphere to discover if data are uni or multimodal """
try:
results = pf.FTU(
counterfactual_libfolding, routine="python"
) if counterfactual_libfolding is not None else pf.FTU(
counterfactual_in_sphere, routine="python")
#if results.p_value < 0.05:
self.multimodal_results = results.folding_statistics < 1
if self.multimodal_results:
visualizer = KElbowVisualizer(KMeans(), k=(1, 8))
x_elbow = np.array(counterfactual_in_sphere)
visualizer.fit(x_elbow)
n_clusters = visualizer.elbow_value_
if n_clusters is not None:
if self.verbose: print("n CLUSTERS ", n_clusters)
kmeans = KMeans(n_clusters=n_clusters)
kmeans.fit(counterfactual_in_sphere)
self.clusters_centers = kmeans.cluster_centers_
if self.verbose:
print("Mean center of clusters from KMEANS ",
self.clusters_centers)
else:
tree_closest_neighborhood = scipy.spatial.cKDTree(
instances_in_sphere)
mean = 0
#print("counterfactual in sphere", counterfactual_in_sphere)
target_class = self.black_box_predict(
counterfactual_in_sphere[0].reshape(1, -1))
for item in counterfactual_in_sphere:
the_result = tree_closest_neighborhood.query(item, k=2)
try:
if self.black_box_predict(
instances_in_sphere[the_result[1][1]].reshape(
1, -1)) == target_class:
mean += 1
except:
print(
"problem in the search of the closest neighborhood",
the_result)
mean /= len(counterfactual_in_sphere)
print("mean", mean)
self.multimodal_results = mean < self.threshold_precision
print("The libfolding test indicates that data are ",
"multimodal." if self.multimodal_results else "unimodal.")
return True
except ValueError:
print(
"There is an error in the libfolding code for unimodal testing."
)
return False
def get_nCluster_elbow(X, start,to):
model = KMeans()
visualizer = KElbowVisualizer(model, k=(start, to), locate_elbow=False, timings=False)
visualizer.fit(X) # Fit the data to the visualizer
# visualizer.show() # Finalize and render the figure
# print("visualizer.elbow_value is ", visualizer.elbow_value_)
k = visualizer.elbow_value_
return k
def elbow_plt(X_data):
# Import ElbowVisualizer
model = KMeans(init='k-means++', max_iter=1000, n_init=10, random_state=0)
# k is range of number of clusters.
visualizer = KElbowVisualizer(model, k=(3, 12), timings=False)
visualizer.fit(X_data) # Fit the data to the visualizer
# visualizer.show() # Finalize and render the figure
print("Elbow Value by Yellowbricks ", visualizer.elbow_value_)
plt.savefig(elbow_plt_path)
def elbow_RMSD(X):
model = AgglomerativeClustering(compute_full_tree=True, affinity='precomputed', linkage='average')
visualizer = KElbowVisualizer(model, k=(4,50), metric='silhouette', timings=False)
visualizer.fit(X)
plt.clf()
plt.close()
dendo_clustering = AgglomerativeClustering(n_clusters=None, compute_full_tree=True, distance_threshold=0, affinity='precomputed', linkage='average').fit(X)
plot_dendrogram(dendo_clustering, visualizer.elbow_value_)
plt.grid(b=None)
#plt.show()
plt.close()
return AgglomerativeClustering(n_clusters=visualizer.elbow_value_, affinity='precomputed', linkage='average').fit(X)
def clusterfind():
datadf = noramizedf()['body_text']
cv = CountVectorizer(ngram_range=(1, 2), min_df=10, max_df=0.8)
cv_matrix = cv.fit_transform(datadf)
print(cv_matrix.shape)
tfidf_vectorizer = TfidfVectorizer(ngram_range=(3, 4), max_df=0.9, min_df=0.005, sublinear_tf=True)
tfidf_matrix = tfidf_vectorizer.fit_transform(datadf)
km = KMeans(max_iter=10000, n_init=50, random_state=42, n_jobs= -1)
visualizer = KElbowVisualizer(km, k=(2, 15))
visualizer.fit(tfidf_matrix)
result = [tfidf_matrix,visualizer.elbow_value_]
return result
def makespaces(s2, k, alpha, beta, legend, title, ilist):
kk=pd.DataFrame({'Skew²': s2, 'Kurtosis': k, 'Alpha': alpha, 'Beta': beta, "Entity": ilist})
K=8
model=KMeans()
visualizer = KElbowVisualizer(model, k=(1,K))
kIdx=visualizer.fit(kk.drop(columns=["Beta", "Entity"])) # Fit the data to the visualizer
visualizer.show() # Finalize and render the figure
kIdx=kIdx.elbow_value_
model=KMeans(n_clusters=kIdx).fit(kk.drop(columns=["Beta", "Entity"]))
print(len(model.labels_))
fig = plt.figure(figsize=(20,15))
ax = Axes3D(fig)
cmap = plt.get_cmap('gnuplot')
ilist2=list(set(ilist))
clr = [cmap(i) for i in np.linspace(0, 1, len(ilist2))]
for i in range(0,len(ilist2)):
ind = (kk["Entity"]==ilist2[i])
ax.scatter(kk["Skew²"][ind],kk["Kurtosis"][ind], kk["Alpha"][ind], s=30, c=clr[i], label=ilist2[i])
ax.set_xlabel("Skew²")
ax.set_ylabel("Kurtosis")
ax.set_zlabel(r"$\alpha$")
ax.legend()
plt.title(title+": EDF-K-means")
plt.savefig("masoq.png")
plt.show()
kk=pd.DataFrame({'Skew²': s2, 'Kurtosis': k, 'Alpha': alpha, 'Beta': beta, "Entity": ilist}, index=model.labels_)
kk.sort_index(inplace=True)
kk.to_csv("clusteringalpha.csv")
model=KMeans()
visualizer = KElbowVisualizer(model, k=(1,K))
kIdx=visualizer.fit(kk.drop(columns=["Alpha", "Entity"])) # Fit the data to the visualizer
visualizer.show() # Finalize and render the figure
kIdx=kIdx.elbow_value_
model=KMeans(n_clusters=kIdx).fit(kk.drop(columns=["Alpha", "Entity"]))
fig = plt.figure(figsize=(20,15))
ax = Axes3D(fig)
cmap = plt.get_cmap('gnuplot')
clr = [cmap(i) for i in np.linspace(0, 1, len(ilist2))]
for i in range(0,len(ilist2)):
ind = (kk["Entity"]==ilist2[i])
ax.scatter(kk["Skew²"][ind],kk["Kurtosis"][ind], kk["Beta"][ind], s=30, c=clr[i], label=ilist[i])
ax.set_xlabel("Skew²")
ax.set_ylabel("Kurtosis")
ax.set_zlabel(r"$\beta$")
ax.legend()
plt.title(title+": EPSB-K-means")
plt.savefig("masoq2.png")
plt.show()
kk=pd.DataFrame({'Skew²': s2, 'Kurtosis': k, 'Alpha': alpha, 'Beta': beta, "Entity": ilist}, index=model.labels_)
kk.sort_index(inplace=True)
kk.to_csv("clusteringbeta.csv")
def clusterting_metric(self, number_of_clusters=50):
"""Automatic execution of the elbow method"""
#Min max scale the data
scaler, XC = StaticML.min_max_df(self.X_train)
model = KMeans()
#Perfom elbow method
visualizer = KElbowVisualizer(model, k=(4, number_of_clusters))
visualizer.fit(XC)
#get values of elbow method to plot later
wcss = pd.DataFrame(visualizer.k_scores_, columns=["wcss"])
self.wcss = wcss
#set optimal value of k in clustering.
self.elbow = visualizer.elbow_value_
def kelbow_optimization(df):
# Shows optimal number of clusters for model
model = KMeans()
visualizer = KElbowVisualizer(model, k=(1, 10))
visualizer.fit(df)
visualizer.poof()
visualizer.show(outpath="Elbow Kmeans Cluster.pdf")
return df
def elbow(X, path):
model = AgglomerativeClustering(affinity='cosine', linkage='average') # affinity='euclidean', linkage='ward'
visualizer = KElbowVisualizer(model, k=(4,50), metric='silhouette', timings=False)
visualizer.fit(X)
dendo_clustering = AgglomerativeClustering(n_clusters=None, compute_full_tree=True, distance_threshold=0,
linkage='average', affinity='cosine').fit(X)
plt.figure(figsize=(20,10), dpi=200)
plot_dendrogram(dendo_clustering, visualizer.elbow_value_)
plt.xlabel("Number of the snapshot")
plt.ylabel("cosine distance")
plt.grid(b=None)
plt.savefig(path + "/dendogram.png")
plt.clf()
plt.close()
return AgglomerativeClustering(n_clusters=visualizer.elbow_value_, affinity='cosine', linkage='average').fit(X), visualizer.elbow_value_
def check_test_unimodal_data(self, counterfactual_in_sphere, instances_in_sphere, radius, counterfactual_libfolding=None):
"""
Test over instances in the hypersphere to discover if data are uni or multimodal
Args: counterfactual_in_sphere: Counterfactual instances find in the area of the hyper field
instances_in_sphere: All the instances generated or present in the field
radius: Size of the hyper field
counterfactual_libfolding: counterfactual instances with continuous values for Libfolding
Return: Indicate whether the counterfactual find in the hyper field are unimodal or multimodal
and compute the clusters centers in case of multimodal data
"""
try:
results = pf.FTU(counterfactual_libfolding, routine="python") if counterfactual_libfolding is not None else pf.FTU(counterfactual_in_sphere, routine="python")
self.multimodal_results = results.folding_statistics<1
if self.multimodal_results:
# If counterfactual instances are multimodal we compute the clusters center
visualizer = KElbowVisualizer(KMeans(), k=(1,8))
x_elbow = np.array(counterfactual_in_sphere)
visualizer.fit(x_elbow)
n_clusters = visualizer.elbow_value_
if n_clusters is not None:
if self.verbose: print("n CLUSTERS ", n_clusters)
kmeans = KMeans(n_clusters=n_clusters)
kmeans.fit(counterfactual_in_sphere)
self.clusters_centers = kmeans.cluster_centers_
if self.verbose: print("Mean center of clusters from KMEANS ", self.clusters_centers)
else:
# If counterfactual instances are unimodal we test a linear separability problem
tree_closest_neighborhood = scipy.spatial.cKDTree(instances_in_sphere)
mean = 0
target_class = self.black_box_predict(counterfactual_in_sphere[0].reshape(1, -1))
for item in counterfactual_in_sphere:
the_result = tree_closest_neighborhood.query(item, k=2)
try:
if self.black_box_predict(instances_in_sphere[the_result[1][1]].reshape(1, -1)) == target_class:
mean+=1
except:
print("problem in the search of the closest neighborhood", the_result)
mean /= len(counterfactual_in_sphere)
if self.verbose: print("Value of the linear separability test:", mean)
# We indicate that data are multimodal if the test of linear separability is inferior to the threshold precision
# of the interpretability methods
self.multimodal_results = mean < self.threshold_precision
if self.verbose: print("The libfolding test indicates that data are ", "multimodal." if self.multimodal_results else "unimodal.")
return True
except ValueError:
print("There is an error in the libfolding code for unimodal testing.")
return False
def k_means(self): # k개의 centroid를 반환
model = KMeans()
visualizer = KElbowVisualizer(model, metric='calinski_harabasz', k=(3, 100))
visualizer.fit( self.reduced_new_lst )
#visualizer.show()
K = visualizer.elbow_value_
if K == None:
K = 50
print('K= ',K)
model = KMeans(init="k-means++", n_clusters=K, random_state=0)
xys = model.fit_transform(self.reduced_new_lst)
y_kmeans = model.predict(self.reduced_new_lst)
#print(xys)
word_vector = self.embedding_model.wv
keys = word_vector.vocab.keys()
xs = xys[:, 0]
ys = xys[:, 1]
#self.plot_2d_graph(keys, xs, ys)
# 아래는 dataframe으로 뿌리기 위한 용도이구나
pd_reduced_new_lst = pd.DataFrame(self.reduced_new_lst)
keys = [k for k in keys]
pd_keys = pd.DataFrame(keys)
pd_keys = pd_keys.rename(columns={0: "keyword"})
df = pd.concat([pd_reduced_new_lst, pd_keys], 1)
#print(df)
plt.figure()
plt.scatter(xs, ys, c=y_kmeans, s=50, cmap='viridis')
words = df['keyword']
for i, word in enumerate(words):
plt.annotate(word, xy=(xs[i], ys[i]))
centers = model.cluster_centers_
#plt.scatter(centers[:, 0], centers[:, 1], c='black', s=200, alpha=0.5)
pd_centers = pd.DataFrame(centers)
#print(pd_centers)
new = pd.concat([pd_centers, pd_keys], axis=1, join='inner')
print(new)
#plt.show()
return new
def fit(self, x, output_filename_suffix='output.pdf'):
x = np.array(x)
num_samples, num_features = x.shape[0], x.shape[1]
self.__pca = PCA(n_components=min(num_samples, num_features),
random_state=0)
x_transformed = self.__pca.fit_transform(x)
visualizer = KElbowVisualizer(KMedoids(random_state=0),
k=(1, num_samples),
timings=False,
locate_elbow=True)
visualizer.fit(x_transformed)
best_n_clusters = visualizer.elbow_value_ if visualizer.elbow_value_ is not None else 1
self.__clusterer = KMedoids(n_clusters=best_n_clusters, random_state=0)
self.__clusterer.fit(x_transformed)
def find_optimal_k(model, k_fold, X):
'''
Returns optimal no. of k clusters
Parameters:
model (object): Algorithm object (e.g. KMeans)
k_fold (int): Check up to how many k
Returns:
The optimal no. of k clusters
'''
visualizer = KElbowVisualizer(model, k=(2,k_fold))
visualizer.fit(X)
print(f"Using the elbow method, the optimal number of k: {visualizer.elbow_value_}")
return visualizer.elbow_value_
def fit(self):
a = time.time()
inertia_values = []
Model = KMeans()
Visualizer = KElbowVisualizer(Model, k=(3, 15), metric="silhouette")
Visualizer.fit(self.train_data)
plt.close()
elbow_value = Visualizer.elbow_value_
if elbow_value == None:
self.clusters = 5
else:
self.clusters = elbow_value
self.KM = KMeans(self.clusters)
self.KM.fit(self.train_data)
self.centers = self.KM.cluster_centers_
b = time.time()
print("Fit time: {}s.".format(b - a))
print("{} clusters are selected.".format(self.clusters))
def elbow(ax, metric="distortion"):
from sklearn.cluster import KMeans
from yellowbrick.cluster import KElbowVisualizer
from sklearn.datasets import make_blobs
kws = {
'centers': 8,
'n_samples': 1000,
'n_features': 12,
'shuffle': True,
}
X = make_blobs()
X, y = make_blobs(centers=8)
visualizer = KElbowVisualizer(KMeans(), ax=ax, k=(2, 16), metric=metric)
# visualizer.title = "Silhouette Ranked Elbow Curve for K-Means on 8 Blob Dataset"
visualizer.fit(X)
return visualizer
def analysis_feature(slide_id):
X = np.array(read_csv('lab2.xlsx', slide_id))
# normalize the data attributes
normalized_X = MinMaxScaler().fit_transform(X)
pca = PCA(n_components=2)
pca.fit(normalized_X)
pca_X = pca.transform(normalized_X)
model = KMeans()
visualizer = KElbowVisualizer(model, k=(2, 12))
visualizer.fit(pca_X)
kmeans = KMeans(n_clusters=visualizer.elbow_value_)
kmeans.fit(pca_X)
y_kmeans = kmeans.predict(pca_X)
plt.show()
_extraction_feature(normalized_X, y_kmeans, 10)
def clustering(fname="clustering.png"):
# Create side-by-side axes grid
_, axes = plt.subplots(ncols=2, figsize=(18,6))
X, y = make_blobs(centers=7)
# Add K-Elbow to the left
oz = KElbowVisualizer(MiniBatchKMeans(), k=(3,12), ax=axes[0])
oz.fit(X, y)
oz.finalize()
# Add SilhouetteVisualizer to the right
oz = SilhouetteVisualizer(Birch(n_clusters=5), ax=axes[1])
oz.fit(X, y)
oz.finalize()
# Save figure
path = os.path.join(FIGURES, fname)
plt.tight_layout()
plt.savefig(path)
def get_elbow_plot(X):
output_text = ""
try:
model = KMeans(random_state=40, )
elbow_score = KElbowVisualizer(model, k=(1, 30))
elbow_score.fit(X)
elbow_value = elbow_score.elbow_value_
model = KMeans(elbow_value, random_state=42)
silhoutte_score = SilhouetteVisualizer(model, colors='yellowbrick')
silhoutte_score.fit(X)
output_text = """The optimal number of clusters is """ + \
str(silhoutte_score.n_clusters_) + """ and the silhouette score is """ + \
str(np.round(silhoutte_score.silhouette_score_, 2))
except ValueError as e:
print(e)
return output_text
def run_k_means_elbow(params, x_data):
model = KMeans()
visualizer = KElbowVisualizer(model, k=(2, 40), metric='distortion')
plt.figure()
visualizer.fit(x_data)
visualizer.set_title(params['elbow_graph'])
try:
path = params['path'] + params['elbow_graph'] + '.png'
except:
path = params['elbow_graph'] + '.png'
visualizer.show(outpath=path)
def OptimumCluster(self,df):
from yellowbrick.cluster import KElbowVisualizer
kmeans = KMeans()
visualizer = KElbowVisualizer(kmeans, k=(1,15))
visualizer.fit(df)
visualizer.poof()
def plot_elbow(estimator, k_values, dataset, version, metric='distortion'):
visualizer = KElbowVisualizer(estimator, k=k_values, metric=metric)
visualizer.fit(data.DATA[dataset][version]['x_train'])
visualizer.show(
f'{PLOTS_FOLDER}/{dataset}/{version}/{dataset}_{version}_{estimator.__class__.__name__}_elbow_{metric}.png'
)
plt.clf()
def find_optimal_clusters(X):
# Instantiate the clustering model and visualizer
model = KMeans()
visualizer = KElbowVisualizer(model, k=(2, 21))
visualizer.fit(X) # Fit the data to the visualizer
visualizer.show()
