Limit the number of neighbors based on the dataframe

.drone.yml

@@ -1,44 +0,0 @@
-kind: pipeline
-name: default
-type: docker
-
-trigger:
-  event:
-    - push
-
-steps:
-  - name: lint
-    image: python:3.12
-    commands:
-      - pip install --root-user-action=ignore -r requirements.txt
-      - ruff check .
-
-  - name: docker-image
-    image: plugins/docker
-    settings:
-      dockerfile: Dockerfile
-      registry: hub.codefirst.iut.uca.fr
-      repo: hub.codefirst.iut.uca.fr/bastien.ollier/miner
-      username:
-        from_secret: REGISTRY_USER
-      password:
-        from_secret: REGISTRY_PASSWORD
-      cache_from:
-        - hub.codefirst.iut.uca.fr/bastien.ollier/miner:latest
-    depends_on: [ lint ]
-
-  - name: deploy-miner
-    image: hub.codefirst.iut.uca.fr/clement.freville2/codefirst-dockerproxy-clientdrone:latest
-    settings:
-      image: hub.codefirst.iut.uca.fr/bastien.ollier/miner:latest
-      container: miner
-      command: create
-      overwrite: true
-      admins: bastienollier,clementfreville2,hugopradier2
-    environment:
-      DRONE_REPO_OWNER: bastien.ollier
-    depends_on: [ docker-image ]
-    when:
-      branch:
-        - main
-        - ci/*

.gitignore

@@ -1,2 +1 @@
 __pycache__
-.venv

Dockerfile

@@ -1,9 +0,0 @@
-FROM python:3.12-slim
-
-WORKDIR /app
-
-COPY . . 
-RUN pip3 install -r requirements.txt
-
-EXPOSE 80
-ENTRYPOINT ["streamlit", "run", "frontend/exploration.py", "--server.port=80", "--server.address=0.0.0.0", "--server.baseUrlPath=/containers/bastienollier-miner"]

frontend/clusters.py

@@ -1,63 +0,0 @@
-from sklearn.cluster import DBSCAN, KMeans
-import numpy as np
-
-class DBSCAN_cluster():
-    def __init__(self, eps, min_samples,data):
-        self.eps = eps
-        self.min_samples = min_samples
-        self.data = data
-        self.labels = np.array([])
-
-    def run(self):
-        dbscan = DBSCAN(eps=self.eps, min_samples=self.min_samples)
-        self.labels = dbscan.fit_predict(self.data)
-        return self.labels
-
-    def get_stats(self):
-        unique_labels = np.unique(self.labels)
-        stats = []
-        for label in unique_labels:
-            if label == -1:
-                continue
-            cluster_points = self.data[self.labels == label]
-            num_points = len(cluster_points)
-            density = num_points / (np.max(cluster_points, axis=0) - np.min(cluster_points, axis=0)).prod()
-            stats.append({
-                "cluster": label,
-                "num_points": num_points,
-                "density": density
-            })
-
-        return stats
-    
-
-class KMeans_cluster():
-    def __init__(self, n_clusters, n_init, max_iter, data):
-        self.n_clusters = n_clusters
-        self.n_init = n_init
-        self.max_iter = max_iter
-        self.data = data
-        self.labels = np.array([])
-        self.centers = []
-
-    def run(self):
-        kmeans = KMeans(n_clusters=self.n_clusters, init="random", n_init=self.n_init, max_iter=self.max_iter, random_state=111)
-        self.labels = kmeans.fit_predict(self.data)
-        self.centers = kmeans.cluster_centers_
-        return self.labels
-
-
-    def get_stats(self):
-        unique_labels = np.unique(self.labels)
-        stats = []
-
-        for label in unique_labels:
-            cluster_points = self.data[self.labels == label]
-            num_points = len(cluster_points)
-            center = self.centers[label]
-            stats.append({
-                'cluster': label,
-                'num_points': num_points,
-                'center': center
-            })
-        return stats

frontend/exploration.py

@@ -1,6 +1,5 @@
 import pandas as pd
 import streamlit as st
-import codecs
 
 st.set_page_config(
     page_title="Project Miner",
@@ -10,13 +9,10 @@ st.set_page_config(
 st.title("Home")
 
 ### Exploration
-uploaded_file = st.file_uploader("Upload your CSV file", type=["csv", "tsv"])
+uploaded_file = st.file_uploader("Upload your CSV file", type=["csv"])
-separator = st.selectbox("Separator", [",", ";", "\\t"])
-separator = codecs.getdecoder("unicode_escape")(separator)[0]
-has_header = st.checkbox("Has header", value=True)
 
 if uploaded_file is not None:
-    st.session_state.data = pd.read_csv(uploaded_file, sep=separator, header=0 if has_header else 1)
+    st.session_state.data = pd.read_csv(uploaded_file)
     st.session_state.original_data = st.session_state.data
     st.success("File loaded successfully!")
 

frontend/pages/clustering_dbscan.py

@@ -1,9 +1,10 @@
 import streamlit as st
 import matplotlib.pyplot as plt
-from clusters import DBSCAN_cluster
+from sklearn.cluster import DBSCAN
 
 st.header("Clustering: dbscan")
 
+
 if "data" in st.session_state:
     data = st.session_state.data
 
@@ -16,9 +17,8 @@ if "data" in st.session_state:
     if len(data_name) >= 2 and len(data_name) <=3:
         x = data[data_name].to_numpy()
 
-        dbscan = DBSCAN_cluster(eps,min_samples,x)
+        dbscan = DBSCAN(eps=eps, min_samples=min_samples)
-        y_dbscan = dbscan.run()
+        y_dbscan = dbscan.fit_predict(x)
-        st.table(dbscan.get_stats())
 
         fig = plt.figure()
         if len(data_name) == 2:
@@ -28,5 +28,8 @@ if "data" in st.session_state:
             ax = fig.add_subplot(projection='3d')
             ax.scatter(x[:, 0], x[:, 1],x[:, 2], c=y_dbscan, s=50, cmap="viridis")
         st.pyplot(fig)
+
+    
+
 else:
     st.error("file not loaded")

frontend/pages/clustering_kmeans.py

@@ -1,9 +1,10 @@
 import streamlit as st
+from sklearn.cluster import KMeans
 import matplotlib.pyplot as plt
-from clusters import KMeans_cluster
 
 st.header("Clustering: kmeans")
 
+
 if "data" in st.session_state:
     data = st.session_state.data
 
@@ -22,21 +23,20 @@ if "data" in st.session_state:
     if len(data_name) >= 2 and len(data_name) <=3:
         x = data[data_name].to_numpy()
 
-        kmeans = KMeans_cluster(n_clusters, n_init, max_iter, x)
+        kmeans = KMeans(n_clusters=n_clusters, init="random", n_init=n_init, max_iter=max_iter, random_state=111)
-        y_kmeans = kmeans.run()
+        y_kmeans = kmeans.fit_predict(x)
 
-        st.table(kmeans.get_stats())
-
-        centers = kmeans.centers
         fig = plt.figure()
         if len(data_name) == 2:
             ax = fig.add_subplot(projection='rectilinear')
             plt.scatter(x[:, 0], x[:, 1], c=y_kmeans, s=50, cmap="viridis")
+            centers = kmeans.cluster_centers_
             plt.scatter(centers[:, 0], centers[:, 1], c="black", s=200, marker="X")
         else:
             ax = fig.add_subplot(projection='3d')
 
             ax.scatter(x[:, 0], x[:, 1],x[:, 2], c=y_kmeans, s=50, cmap="viridis")
+            centers = kmeans.cluster_centers_
             ax.scatter(centers[:, 0], centers[:, 1],centers[:, 2], c="black", s=200, marker="X")
         st.pyplot(fig)
 

frontend/pages/prediction_classification.py

@@ -1,64 +0,0 @@
-import streamlit as st
-from sklearn.linear_model import LogisticRegression
-from sklearn.model_selection import train_test_split
-from sklearn.metrics import accuracy_score
-from sklearn.preprocessing import LabelEncoder
-import pandas as pd
-
-st.header("Prediction: Classification")
-
-if "data" in st.session_state:
-    data = st.session_state.data
-
-    with st.form("classification_form"):
-        st.subheader("Classification Parameters")
-        data_name = st.multiselect("Features", data.columns)
-        target_name = st.selectbox("Target", data.columns)
-        test_size = st.slider("Test Size", min_value=0.1, max_value=0.5, value=0.2, step=0.1)
-        st.form_submit_button('Train and Predict')
-
-    if data_name and target_name:
-        X = data[data_name]
-        y = data[target_name]
-
-        label_encoders = {}
-        for column in X.select_dtypes(include=['object']).columns:
-            le = LabelEncoder()
-            X[column] = le.fit_transform(X[column])
-            label_encoders[column] = le
-        
-        if y.dtype == 'object':
-            le = LabelEncoder()
-            y = le.fit_transform(y)
-            label_encoders[target_name] = le
-
-        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
-
-        model = LogisticRegression()
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        accuracy = accuracy_score(y_test, y_pred)
-
-        st.subheader("Model Accuracy")
-        st.write(f"Accuracy on test data: {accuracy:.2f}")
-
-        st.subheader("Enter values for prediction")
-        pred_values = []
-        for feature in data_name:
-            if feature in label_encoders:
-                values = list(label_encoders[feature].classes_)
-                value = st.selectbox(f"Value for {feature}", values)
-                value_encoded = label_encoders[feature].transform([value])[0]
-                pred_values.append(value_encoded)
-            else:
-                value = st.number_input(f"Value for {feature}", value=0.0)
-                pred_values.append(value)
-        
-        prediction = model.predict(pd.DataFrame([pred_values], columns=data_name))
-
-        if target_name in label_encoders:
-            prediction = label_encoders[target_name].inverse_transform(prediction)
-        
-        st.write("Prediction:", prediction[0])
-else:
-    st.error("File not loaded")

frontend/pages/prediction_regression.py

@@ -1,29 +0,0 @@
-import streamlit as st
-from sklearn.linear_model import LinearRegression
-import pandas as pd
-
-st.header("Prediction: Regression")
-
-if "data" in st.session_state:
-    data = st.session_state.data
-
-    with st.form("regression_form"):
-        st.subheader("Linear Regression Parameters")
-        data_name = st.multiselect("Features", data.select_dtypes(include="number").columns)
-        target_name = st.selectbox("Target", data.select_dtypes(include="number").columns)
-        st.form_submit_button('Train and Predict')
-
-    if data_name and target_name:
-        X = data[data_name]
-        y = data[target_name]
-
-        model = LinearRegression()
-        model.fit(X, y)
-        
-        st.subheader("Enter values for prediction")
-        pred_values = [st.number_input(f"Value for {feature}", value=0.0) for feature in data_name]
-        prediction = model.predict(pd.DataFrame([pred_values], columns=data_name))
-
-        st.write("Prediction:", prediction[0])
-else:
-    st.error("File not loaded")

requirements.txt

@@ -1,6 +0,0 @@
-matplotlib>=3.5.0
-pandas>=1.5.0
-seaborn>=0.12.0
-scikit-learn>=0.23.0
-streamlit>=1.35.0
-ruff>=0.4.8