Initial commit

README.md

@@ -8,6 +8,10 @@ sdk_version: 3.0.24
 app_file: app.py
 pinned: false
 license: bsd-3-clause
+tags:
+- sklearn
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Clustering with scikit learn
+
+Gradio demo based on this [sklearn demo](https://scikit-learn.org/stable/auto_examples/cluster/plot_cluster_comparison.html).

app.py

@@ -0,0 +1,206 @@
+"""Gradio demo for different clustering techiniques
+
+Derived from https://scikit-learn.org/stable/auto_examples/cluster/plot_cluster_comparison.html
+
+"""
+
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.cluster import (
+    AgglomerativeClustering, Birch, DBSCAN, KMeans, MeanShift, OPTICS, SpectralClustering, estimate_bandwidth
+)
+from sklearn.datasets import make_blobs, make_circles, make_moons
+from sklearn.mixture import GaussianMixture
+from sklearn.neighbors import kneighbors_graph
+from sklearn.preprocessing import StandardScaler
+
+
+plt.style.use('seaborn')
+
+
+SEED = 0
+N_CLUSTERS = 4
+N_SAMPLES = 1000
+np.random.seed(SEED)
+
+
+def normalize(X):
+    return StandardScaler().fit_transform(X)
+
+
+def get_regular():
+    centers = [[1, 1], [1, -1], [-1, 1], [-1, -1]]
+    assert len(centers) == N_CLUSTERS
+    X, labels = make_blobs(n_samples=N_SAMPLES, centers=centers, cluster_std=0.7, random_state=SEED)
+    return normalize(X), labels
+
+
+def get_circles():
+    X, labels = make_circles(n_samples=N_SAMPLES, factor=0.5, noise=0.05, random_state=SEED)
+    return normalize(X), labels
+
+
+def get_moons():
+    X, labels = make_moons(n_samples=N_SAMPLES, noise=0.05, random_state=SEED)
+    return normalize(X), labels
+
+
+def get_noise():
+    X, labels = np.random.rand(N_SAMPLES, 2), np.zeros(N_SAMPLES)
+    return normalize(X), labels
+
+
+def get_anisotropic():
+    X, labels = make_blobs(n_samples=N_SAMPLES, centers=N_CLUSTERS, random_state=170)
+    transformation = [[0.6, -0.6], [-0.4, 0.8]]
+    X = np.dot(X, transformation)
+    return X, labels
+
+
+def get_varied():
+    X, labels = make_blobs(
+        n_samples=N_SAMPLES, cluster_std=[1.0, 2.5, 0.5], random_state=SEED
+    )
+    return normalize(X), labels
+
+
+DATA_MAPPING = {
+    'regular': get_regular,
+    'circles': get_circles,
+    'moons': get_moons,
+    'noise': get_noise,
+    'anisotropic': get_anisotropic,
+    'varied': get_varied,
+}
+
+def get_kmeans(X, **kwargs):
+    model = KMeans(init="k-means++", n_clusters=N_CLUSTERS, n_init=10, random_state=SEED)
+    model.set_params(**kwargs)
+    return model.fit(X)
+
+
+def get_dbscan(X, **kwargs):
+    model = DBSCAN(eps=0.3)
+    model.set_params(**kwargs)
+    return model.fit(X)
+
+
+def get_agglomerative(X, **kwargs):
+    connectivity = kneighbors_graph(
+        X, n_neighbors=N_CLUSTERS, include_self=False
+    )
+    # make connectivity symmetric
+    connectivity = 0.5 * (connectivity + connectivity.T)
+    model = AgglomerativeClustering(
+        n_clusters=N_CLUSTERS, linkage="ward", connectivity=connectivity
+    )
+    model.set_params(**kwargs)
+    return model.fit(X)
+
+
+def get_meanshift(X, **kwargs):
+    bandwidth = estimate_bandwidth(X, quantile=0.3)
+    model = MeanShift(bandwidth=bandwidth, bin_seeding=True)
+    model.set_params(**kwargs)
+    return model.fit(X)
+
+
+def get_spectral(X, **kwargs):
+    model = SpectralClustering(
+        n_clusters=N_CLUSTERS,
+        eigen_solver="arpack",
+        affinity="nearest_neighbors",
+    )
+    model.set_params(**kwargs)
+    return model.fit(X)
+
+
+def get_optics(X, **kwargs):
+    model = OPTICS(
+        min_samples=7,
+        xi=0.05,
+        min_cluster_size=0.1,
+    )
+    model.set_params(**kwargs)
+    return model.fit(X)
+
+
+def get_birch(X, **kwargs):
+    model = Birch(n_clusters=3)
+    model.set_params(**kwargs)
+    return model.fit(X)
+
+
+def get_gaussianmixture(X, **kwargs):
+    model = GaussianMixture(
+        n_components=N_CLUSTERS, covariance_type="full", random_state=SEED,
+    )
+    model.set_params(**kwargs)
+    return model.fit(X)
+
+
+MODEL_MAPPING = {
+    'KMeans': get_kmeans,
+    'DBSCAN': get_dbscan,
+    'AgglomerativeClustering': get_agglomerative,
+    'MeanShift': get_meanshift,
+    'SpectralClustering': get_spectral,
+    'OPTICS': get_optics,
+    'Birch': get_birch,
+    'GaussianMixture': get_gaussianmixture,
+}
+
+
+def plot_clusters(ax, X, labels):
+    for label in range(N_CLUSTERS):
+        idx = labels == label
+        if not sum(idx):
+            continue
+        ax.scatter(X[idx, 0], X[idx, 1])
+
+    ax.grid(None)
+    ax.set_xticks([])
+    ax.set_yticks([])
+    return ax
+
+
+def cluster(clustering_algorithm: str, dataset: str):
+    X, labels = DATA_MAPPING[dataset]()
+    model = MODEL_MAPPING[clustering_algorithm](X)
+    if hasattr(model, "labels_"):
+        y_pred = model.labels_.astype(int)
+    else:
+        y_pred = model.predict(X)
+
+    fig, axes = plt.subplots(1, 2, figsize=(16, 8))
+
+    ax = axes[0]
+    plot_clusters(ax, X, labels)
+    ax.set_title("True clusters")
+
+    ax = axes[1]
+    plot_clusters(ax, X, y_pred)
+    ax.set_title(clustering_algorithm)
+
+    return fig
+
+
+demo = gr.Interface(
+    fn=cluster,
+    inputs=[
+        gr.Radio(
+            list(MODEL_MAPPING),
+            value="KMeans",
+            label="clustering algorithm"
+        ),
+        gr.Radio(
+            list(DATA_MAPPING),
+            value="regular",
+            label="dataset"
+        ),
+    ],
+    outputs=gr.Plot(),
+)
+
+demo.launch()

requirements.txt

@@ -0,0 +1,2 @@
+matplotlib>=3.5.2
+scikit-learn>=1.0.1