maj

D3/TP/Cours.ipynb

@@ -100,7 +100,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.8.10 64-bit",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -114,12 +114,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.10"
+   "version": "3.9.4 (tags/v3.9.4:1f2e308, Apr  6 2021, 13:40:21) [MSC v.1928 64 bit (AMD64)]"
   },
   "orig_nbformat": 4,
   "vscode": {
    "interpreter": {
-    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
+    "hash": "2ef431f6525756fa8a44688585fa332ef3b2e5fcfe8fe75df35bbf7028a8b511"
    }
   }
  },

D3/TP/TP_SETI_Kmeans/Kmeans.py

@@ -21,7 +21,7 @@ def kmeans(points = [0,0], K = 1):
         Pc_index.append(np.random.randint(0,N))
     Pc = points[Pc_index,:]
 
-    while (np.mean(distance(Pc,Pc_save)) > eps and iter < 3):
+    while (np.mean(distance(Pc,Pc_save)) > eps and iter < 10):
         iter += 1
         Pc_save = Pc
         # print(Pc)
@@ -74,9 +74,10 @@ def kmeans_image(path_image, K):
     # imgplot = plt.imshow(img_seg)
     return Pc, index, img_seg
 
-path_image = "fruits.jpg"
+path_image = "images/fruits.jpg"
 
-start_time = time.time()
-Pc, index, img_seg = kmeans_image(path_image=path_image, K=2)
-end_time = time.time()
-print(f"It took {end_time-start_time:.2f} seconds to compute")
+for K in range(1,21):
+    start_time = time.time()
+    Pc, index, img_seg = kmeans_image(path_image=path_image, K=K)
+    end_time = time.time()
+    print(f"It took {end_time-start_time:.2f} seconds to compute for K =", K)

D3/TP/TP_SETI_Kmeans/Kmeans_cuda.py

@@ -1,82 +0,0 @@
-import numpy as np
-import pycuda.autoinit
-import pycuda.driver as cuda
-from pycuda.compiler import SourceModule
-import time
-
-# Load the image and convert it to a NumPy array
-from PIL import Image
-im = Image.open('fruits.jpg')
-im_data = np.array(im)
-
-# Convert the image data to float32 and normalize it
-im_data = im_data.astype(np.float32) / 255
-
-# Create a CUDA kernel to perform K-means clustering
-kernel = """
-__global__ void kmeans(float *data, int *labels, float *centroids, int n, int k, int dim)
-{
-    int tid = blockIdx.x * blockDim.x + threadIdx.x;
-    if (tid >= n)
-        return;
-
-    float min_dist = 10000;
-    int min_centroid = -1;
-    for (int i = 0; i < k; i++)
-    {
-        float dist = 0.0;
-        for (int j = 0; j < dim; j++)
-        {
-            float diff = data[tid * dim + j] - centroids[i * dim + j];
-            dist += diff * diff;
-        }
-        if (dist < min_dist)
-        {
-            min_dist = dist;
-            min_centroid = i;
-        }
-    }
-    labels[tid] = min_centroid;
-}
-"""
-
-mod = SourceModule(kernel)
-kmeans = mod.get_function("kmeans")
-
-# Set the number of clusters and the number of iterations
-k = 2
-n_iter = 5
-
-# Initialize the centroids and labels
-centroids = np.random.rand(k, im_data.shape[-1]).astype(np.float32)
-labels = np.zeros(im_data.shape[:2], dtype=np.int32)
-
-def replace_with_nearest_centroid(centroids, colors):
-    # Compute the distance between each color and each centroid
-    distances = np.sqrt(np.sum((colors[:, :] - centroids) ** 2, axis=2))
-    
-    # Find the index of the centroid that is nearest to each color
-    nearest_centroids = np.argmin(distances, axis=1)
-    
-    # Replace each color with the nearest centroid
-    colors[:] = centroids[nearest_centroids]
-
-
-start_time = time.time()
-
-# Run the K-means algorithm
-for _ in range(n_iter):
-    kmeans(cuda.In(im_data), cuda.Out(labels), cuda.In(centroids), np.int32(im_data.shape[0] * im_data.shape[1]), np.int32(k), np.int32(im_data.shape[-1]), block=(1024,1,1), grid=(im_data.shape[0] * im_data.shape[1] // 1024 + 1, 1))
-
-    # Update the centroids
-    for i in range(k):
-        centroids[i] = np.mean(im_data[labels == i], axis=0)
-
-replace_with_nearest_centroid(centroids=centroids, colors=im_data)
-# Convert the labels back to the original image format
-labels = labels
-
-end_time = time.time()
-print(f"It took {end_time-start_time:.2f} seconds to compute")
-
-

D3/TP/TP_SETI_Kmeans/Kmeans_skcuda.py

@@ -1,23 +1,41 @@
-import numpy as np
-import cv2
 import cupy as cp
+import numpy as np
+from sklearn.cluster import KMeans
+from skimage import io
+import time
+
+# Load the image using skimage
+image = io.imread('fruits.jpg')
+
+# Convert the image to a CuPy array
+image_cp = cp.asarray(image)
+
+# Flatten the image into a 2D array of pixels
+image_flat = image_cp.get().reshape(image_cp.shape[0] * image_cp.shape[1], image_cp.shape[2])
+
+def Kmeans_cuda(K=1):
+    # Use KMeans to cluster the pixels into a specified number of clusters
+    kmeans = KMeans(n_clusters=K, random_state=0).fit(image_flat)
+
+    # Predict the cluster for each pixel
+    clusters = kmeans.predict(image_flat)
 
-# Load the image and convert it to a NumPy array
-image = cv2.imread("fruits.jpg")
-image = image.astype(np.float32)
+    # Create a new CuPy array to hold the modified image
+    new_image_cp = cp.empty_like(image_cp)
 
-# Use cupy to transfer the image to the GPU
-image_gpu = cp.asarray(image)
+    # Iterate over each pixel and assign its value to the corresponding cluster center
+    for i, cluster in enumerate(clusters):
+        new_image_cp[i // image_cp.shape[1], i % image_cp.shape[1]] = cp.asarray(kmeans.cluster_centers_[cluster])
 
-# Perform k-means clustering on the GPU
-cluster_centers_gpu, labels_gpu, _ = cp.cluster.kmeans(image_gpu.reshape(-1, 3), k=8)
+    # Convert the CuPy array back to a NumPy array
+    new_image = cp.asnumpy(new_image_cp)
 
-# Transfer the cluster centers and labels back to the CPU
-cluster_centers = cp.asnumpy(cluster_centers_gpu)
-labels = cp.asnumpy(labels_gpu)
+    # Save the modified image using skimage
+    io.imsave("fruits" + "_%d" % K + "_cuda.jpg", new_image)
 
-# Convert the image pixels to the closest cluster
-clustered_image = cluster_centers[labels].reshape(image.shape)
 
-# Save the clustered image as a PNG file
-cv2.imwrite("clustered_image.png", clustered_image)
+for K in range(1,256):
+    start_time = time.time()
+    Kmeans_cuda(K=K)
+    end_time = time.time()
+    print(f"It took {end_time-start_time:.2f} seconds to compute for K =",K)