{"cells": [{"cell_type": "markdown", "metadata": {}, "source": ["## Submission for Dragonfruit software engineering challenge"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Import Libraries"]}, {"cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": ["import os\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import random\n", "from collections import deque\n", "from matplotlib.colors import ListedColormap\n", "import pickle\n", "from tqdm import tqdm\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Q1\n", "\n", "An ideal data structure for our use case will be a multidimensional matrix. Matrices allows us to easily model and navigate the structure of the parasite and its surroundings using graph algorithms like breadth-first search. Now even if the conventional matrices are very handy for our usecase, they still turn out to be very sparse as we are dealing with binary matrices where the occupancy of the parasite's body is between 25% to 30% of the matrix. This means most of the matrix is empty and taking up space. So we can use compression algorithms like run-length encoding to decrease the size of the matrix. If we consider a 100,000 x 100,000 matrix and 1 bit per cell with a value of 0 or 1, then the original matrix representation will take up about ~10GB of storage depending on how the matrix was created. With run-length encoding we can reduce this storage space as shown in the given example:-\n", "\n", "Matrix row: [0,0,0,0,0,0,0,1,1,0,0,0,0,0,0]\n", "\n", "Compress Matrix row with Run length encoding: [[0,7],[1,2],[0,6]]\n", "\n", "In the worst case scenario where the entire matrix has alternating 1s and 0s, run length encoding will perform worse than the non-encoded matrix. But on an average case, for a 100,000 x 100,000 matrix if we consider the average run length to be 100 and space taken by the [bit value, frequency] to be ~3bytes then the storage space occupied will be:-\n", "\n", "No of runs = (10^10) / 100 = 10^8\\\n", "Storage space = 10^8 * 10^(-9) * (1/3) = (10^ - 1) * (0.33) = 0.03GB\n", "\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Q2\n", "The following parasite class is created to generate sample parasite images using matrices as a data structure."]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Create Parasite samples"]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": ["class Parasite:\n", "\n", "    def __init__(self, image_height, image_width):\n", "\n", "        self.H = image_height\n", "        self.W = image_width\n", "        self.image = None\n", "        self.parasite_edges = {}\n", "        self.parasite = None\n", "        self.dye_image = None\n", "        self.initialize_image()\n", "\n", "\n", "    ### initializes the image matrix and starts the parasite generation process\n", "    def initialize_image(self):\n", "        self.image = [[0 for _ in range(self.H)] for _ in range(self.W)]\n", "        self.create_parasite()\n", "\n", "    #Helper function used to check if a cell is within the bounds of the matrix\n", "    def isCellValid(self, cell):\n", "        x, y = cell\n", "\n", "        return not( x < 0  or x >= self.H or y < 0 or y >= self.W) \n", "    \n", "    # Helper function to find the end points of the parasite in each row\n", "    def get_parasite_edges(self, row_id):\n", "\n", "        x = row_id\n", "        start = 0\n", "        end = -1\n", "        for y in range(self.W):\n", "            if self.image[x][y] != 0:\n", "                start = y\n", "                break\n", "\n", "        for y in range(self.W - 1, -1, -1):\n", "            if self.image[x][y] != 0:\n", "                end = y\n", "                break\n", "        if start == 0 and end == -1 and self.image[start][end] == 0:\n", "            end = 0\n", "        self.parasite_edges[x] = [start,end]\n", "\n", "\n", "    # Helper function to generate the final parasite by filling any unfilled cells in the parasites body to prevent gaps in the body\n", "    def flood_fill(self):\n", "\n", "        for i in range(self.H):\n", "            self.get_parasite_edges(i)\n", "\n", "        for x in range(self.H):\n", "            for y in range(self.parasite_edges[x][0],self.parasite_edges[x][1]):\n", "                self.image[x][y] = 1\n", "\n", "        self.dye_image = [[self.image[i][j] for j in range(self.W)] for i in range(self.H)]\n", "        self.add_dye()\n", "    \n", "    # Uses breadth first search and randomization to generate a parasite\n", "    def create_parasite(self):\n", "\n", "        # Pick a random occupancy percentage between 25% and 30% to define what percentage of the image will be occupied by the parasite\n", "        self.image_occupancy = random.uniform(0.25,0.30)\n", "        valid_directions = [[-1, 0], [0, -1], [0, 1], [1, 0]]\n", "\n", "        count = 0\n", "        visited = set()\n", "        self.parasite = []\n", "\n", "        # Choose a random starting point to start generating the parasite\n", "        random_start = [random.randint(0, self.H - 1 ), random.randint(0, self.W - 1)]\n", "        q = deque([random_start])\n", "        self.image[random_start[0]][random_start[1]] = 1\n", "        occupancy = (self.image_occupancy * (self.H * self.W))\n", "\n", "        #Continue the loop till the size of the parasite crosses the desired occupancy percentage inside the matrix\n", "        while count < occupancy:\n", "\n", "            #Run BFS\n", "            while q and count < occupancy:\n", "                node = q.popleft()\n", "                x1,y1 = node\n", "                if (x1,y1) in visited:\n", "                    continue\n", "                visited.add((x1, y1))\n", "                random.shuffle(valid_directions)\n", "                for d in random.sample(valid_directions,2):\n", "                    x2, y2 = x1 + d[0], y1 + d[1]\n", "                    if self.isCellValid([x2,y2]) and self.image[x2][y2] == 0:\n", "                        self.image[x2][y2] = 1\n", "                        self.parasite.append((x2,y2))\n", "                        q.append([x2, y2])\n", "                        count += 1\n", "                    if count > occupancy:\n", "                        break\n", "            \n", "            if count < occupancy:\n", "                if len(self.parasite) > 0:\n", "                    q = deque([random.sample(self.parasite,1)][0])\n", "                else:\n", "                    random_start = [random.randint(0, self.H - 1 ), random.randint(0, self.W - 1)]\n", "                    q = deque([random_start])\n", "        self.flood_fill()\n", "    \n", "    #Helper function that uses BFS and randomization to add dye to the parasites body\n", "    def add_dye(self):\n", "\n", "        visited = set()\n", "        valid_directions = [[-1, 0], [0, -1], [0, 1], [1, 0]]\n", "\n", "        \n", "\n", "        occupancy = random.uniform(0.01, 0.25)\n", "        dye_occupancy = occupancy * self.image_occupancy * self.H * self.W\n", "        count = 0\n", "        while count < dye_occupancy:\n", "            random_start = random.sample(list(self.parasite),1)[0]\n", "            if tuple(random_start) in visited:\n", "                continue\n", "            \n", "            q = deque([random_start])\n", "            while q and count < dye_occupancy:\n", "\n", "                x1, y1 = q.popleft()\n", "                if (x1,y1) in visited:\n", "                    continue\n", "                visited.add((x1,y1))\n", "                random.shuffle(valid_directions)\n", "                for d in random.sample(valid_directions,2):\n", "                    x2, y2 = x1 + d[0], y1 + d[1]\n", "                    if self.isCellValid([x2,y2]) and (x2,y2) not in visited:\n", "                        if self.dye_image[x2][y2] == 1:\n", "                            self.dye_image[x2][y2] = 2\n", "                            q.append([x2,y2])\n", "                            count += 1\n", "                if count > dye_occupancy:\n", "                    break\n", "        \n", "        # Second BFS inside the add_dye function to create areas where the dye spills into the outer regions around the parasite's body\n", "        spill_out = random.uniform(0.0, 0.25)* dye_occupancy\n", "        spilloutcount = 0\n", "        valid_parasite_edges = [i for i in self.parasite_edges if self.parasite_edges[i][0] != self.parasite_edges[i][1]]\n", "        visited = set()\n", "        while spilloutcount < spill_out:\n", "\n", "            r = random.sample(valid_parasite_edges, 1)[0]\n", "            random_start = [r,self.parasite_edges[r][0]]\n", "            if tuple(random_start) in visited:\n", "                continue\n", "            \n", "            q = deque([random_start])\n", "            while q and spilloutcount < spill_out:\n", "\n", "                x1, y1 = q.popleft()\n", "                if (x1,y1) in visited:\n", "                    continue\n", "                visited.add((x1,y1))\n", "                random.shuffle(valid_directions)\n", "                if self.dye_image[x1][y1] > 0:\n", "                    for d in random.sample(valid_directions,2):\n", "                        x2, y2 = x1 + d[0], y1 + d[1]\n", "                        if self.isCellValid([x2,y2]) and (x2,y2) not in visited:\n", "                            if self.dye_image[x2][y2] == 0:\n", "                                self.dye_image[x2][y2] = 2\n", "                                q.append([x2,y2])\n", "                                spilloutcount += 1\n", "                if spilloutcount > spill_out:\n", "                    break\n", "\n", "    ### Use Run length encoding for efficient storage of matrices\n", "    def encode_rle(self, binary_matrix):\n", "        encoded = []\n", "        for row in binary_matrix:\n", "            if not row:  \n", "                continue\n", "            count = 1\n", "            prev = row[0]\n", "            row_encoded = []\n", "            for value in row[1:] + [None]:\n", "                if value == prev:\n", "                    count += 1\n", "                else:\n", "                    row_encoded.append((prev, count))  \n", "                    prev = value\n", "                    count = 1\n", "            encoded.append(row_encoded)\n", "        return encoded\n", "\n", "    def decode_rle(self,encoded_matrix):\n", "        decoded = []\n", "        for row_encoded in encoded_matrix:\n", "            row = []\n", "            for value, count in row_encoded:\n", "                row.extend([value] * count)\n", "            decoded.append(row)\n", "        return decoded\n", "\n", "        \n"]}, {"cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 1000x1000 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"image/png": "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", "text/plain": ["<Figure size 1000x1000 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"text/plain": ["<Figure size 640x480 with 0 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["\n", "### Sample parasite\n", "\n", "parasite1 = Parasite(1000,1000)\n", "\n", "plt.figure(figsize=(10, 10))  # Adjust the size as needed\n", "cmap = ListedColormap(['white', 'black'])\n", "plt.subplot(1,2,1)\n", "plt.imshow(parasite1.image, cmap=cmap)\n", "plt.title(\"Parasite image\")\n", "plt.show()\n", "\n", "\n", "plt.figure(figsize=(10, 10))  # Adjust the size as needed\n", "cmap = ListedColormap(['white', 'black','red'])\n", "plt.subplot(1,2,2)\n", "plt.imshow(parasite1.dye_image, cmap=cmap)\n", "plt.title(\"Parasite with Dye image\")\n", "plt.show()\n", "plt.tight_layout()\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Q3\n", "Created a group of parasites based on the parasite class from the previous section. The parasite image and their dyed version are then passed into the \"hasCancer\" function as parameters to verify the presence of cancer."]}, {"cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Parasite 0 created\n", "Parasite 1 created\n", "Parasite 2 created\n", "Parasite 3 created\n", "Parasite 4 created\n", "Parasite 5 created\n", "Parasite 6 created\n", "Parasite 7 created\n"]}], "source": ["parasites = []\n", "for i in range(8):\n", "    parasites.append(Parasite(1000,1000))\n", "    print(\"Parasite \"+str(i)+\" created\")"]}, {"cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [{"data": {"image/png": "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", "text/plain": ["<Figure size 2000x1000 with 8 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["fig, axs = plt.subplots(2, 4, figsize=(20, 10))  # figsize(width, height) in inches\n", "count = 0\n", "cmap0 = ListedColormap(['white', 'black'])\n", "cmap1 = ListedColormap(['white', 'black','red'])\n", "\n", "for i in range(2):\n", "    axs[i, 0].imshow(parasites[i + count].image, cmap = cmap0)\n", "    axs[i, 0].set_title(f'Parasite {(i) + 0 + 1}')\n", "    axs[i, 1].imshow(parasites[i + count].dye_image, cmap = cmap1)\n", "    axs[i, 1].set_title(f'Parasite {(i) + 1} Dye Image')\n", "    axs[i, 2].imshow(parasites[i + count + 1].image, cmap = cmap0)\n", "    axs[i, 2].set_title(f'Parasite {(i) + 1 + 1}')\n", "    axs[i, 3].imshow(parasites[i + count + 1].dye_image, cmap = cmap1)\n", "    axs[i, 3].set_title(f'Parasite {(i) + 1 + 1} Dye Image')\n", "    count += 1\n", "plt.tight_layout()\n", "plt.show()"]}, {"cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": ["\n", "def hasCancer(parasite_image, dye_image):\n", "\n", "    comb_image = parasite_image * dye_image\n", "\n", "    parasite_occupancy = 0\n", "    dye_occupancy = 0\n", "\n", "    for i in range(len(comb_image)):\n", "        for j in range(len(comb_image[0])):\n", "            if comb_image[i][j] > 0:\n", "                parasite_occupancy += 1\n", "                if comb_image[i][j] == 2:\n", "                    dye_occupancy += 1\n", "\n", "    return (dye_occupancy / parasite_occupancy)"]}, {"cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Parasite 0 dye occupancy percentage:- 0.018 (Does not have cancer)\n", "Parasite 1 dye occupancy percentage:- 0.19 (has Cancer)\n", "Parasite 2 dye occupancy percentage:- 0.1 (has Cancer)\n", "Parasite 3 dye occupancy percentage:- 0.084 (Does not have cancer)\n", "Parasite 4 dye occupancy percentage:- 0.199 (has Cancer)\n", "Parasite 5 dye occupancy percentage:- 0.159 (has Cancer)\n", "Parasite 6 dye occupancy percentage:- 0.04 (Does not have cancer)\n", "Parasite 7 dye occupancy percentage:- 0.059 (Does not have cancer)\n"]}], "source": ["for i in range(len(parasites)):\n", "    parasite = parasites[i]\n", "    x = hasCancer(np.asarray(parasite.image), np.asarray(parasite.dye_image))\n", "    if x > 0.1:\n", "        print(\"Parasite \" + str(i) + \" dye occupancy percentage:- \" + str(round(x,3)) + \" (has Cancer)\")\n", "    else:\n", "        print(\"Parasite \" + str(i) + \" dye occupancy percentage:- \" + str(round(x,3)) + \" (Does not have cancer)\")\n"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Q4\n", "The existing implementation of the cancer detection function is an efficient implementation. Instead of loading and storing two matrices (image and dyed-image) in the memory and iterating through their rows and comparing both the matrices, the current implementation leverages the vectorization properties of the numpy library. An elementwise multiplication is performed to get rid of the areas where the dye has spilled in the dye-image by setting them to 0 as in the original image the value in that cell will be 0. Then we iterate through the final matrix to calculate the dye percentage in the parasite. \n", "\n", "A faster version could be implemented in parallel processing systems like a GPU and their corresponding frameworks like CUDA or a cpu using libraries like OpenMP. As the operations we are doing to compute the dye occupancy on each cell is independent of the other cells, we can parallelize them on the GPU threads and calculate the dye percentage in a single step where a dedicated thread for each cell checks the value and updates our dye occupancy percentage. The following is a sample OpenMP based C code where we do the cancer detection operation using two matrices and we do it parallely."]}, {"cell_type": "markdown", "metadata": {}, "source": ["```c\n", "#include <stdio.h>\n", "\n", "#include <stdlib.h>\n", "\n", "#include <omp.h>\n", "\n", "#define N 1000\n", "\n", "int main() {\n", "    int matrix1[N][N], matrix2[N][N];\n", "    int parasiteCellCount = 0;\n", "    int dyeCount = 0;\n", "\n", "    for(int i = 0; i < N; i++) {\n", "        for(int j = 0; j < N; j++) {\n", "            matrix1[i][j] = rand() % 3;\n", "            matrix2[i][j] = rand() % 3;\n", "        }\n", "    }\n", "\n", "    \n", "    // Using global indexing to access all cells in a single outer loop\n", "    #pragma omp parallel for reduction(+:parasiteCellCount)\n", "    for(int index = 0; index < N*N; index++) {\n", "        int i = index / N; // Calculate row index\n", "        int j = index % N; // Calculate column index\n", "        if(matrix1[i][j] == 1) {\n", "            parasiteCellCount += 1;\n", "            if(matrix2[i][j] == 2){\n", "                dyeCount += 1;\n", "            }\n", "        }\n", "    }\n", "\n", "    float occupancy = (float)dyeCount / parasiteCellCount;\n", "    printf(\"Dye occupancy: %f\\n\", occupancy);\n", "\n", "    return 0;\n", "}"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Q5\n", "Lets take the Runlength encoding as a sample compression technique. We'll also take a sample image of size 100,000 x 100,000 \n", "Device:- Macbook Pro M2-Pro\n", "\n", "Binary format:-\n", "\n", "Matrix creation time :- ~2hrs\n", "\n", "Matrix storage size :-  10.2GB\n", "\n", "(Compressed) Run length Encoded format:-\n", "\n", "Matrix creation time:- ~5mins\n", "\n", "Matrix storage size:- 700MB"]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["## Run length encoded format\n", "matrix = []\n", "size = 100000\n", "for i in tqdm(range(size)):\n", "    temp = []\n", "    count = 0\n", "    while count < size:\n", "        t = random.randint(30,200)\n", "        val = random.sample([0,1],1)[0]\n", "        temp.append([val,t])\n", "        count += t\n", "    matrix.append(temp)\n", "\n", "      "]}, {"cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": ["with open(\"matrix.pkl\",\"wb\") as fp:\n", "    pickle.dump(matrix,fp)"]}, {"cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [{"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 100000/100000 [2:04:06<00:00, 13.43it/s]  \n"]}], "source": ["#Binary format\n", "\n", "matrix = []\n", "size = 100000\n", "for i in tqdm(range(size)):\n", "    temp = []\n", "    for j in range(size):\n", "        val = random.sample([False,True],1)[0]\n", "        temp.append(val)\n", "    matrix.append(temp)"]}, {"cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["100000\n"]}], "source": ["print(len(matrix))"]}, {"cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": ["with open(\"matrix.pkl\",\"wb\") as fp:\n", "    pickle.dump(matrix,fp)"]}, {"cell_type": "markdown", "metadata": {}, "source": ["### Q6\n", "\n", "<b>Tools used</b>\n", "\n", "\n", "Perplexity :- Look up algorithms and existing techniques\n", "\n", "ChatGPT and Claude:- Used for Code Logic improvements and debugging."]}], "metadata": {"kernelspec": {"display_name": "cs224n", "language": "python", "name": "cs224n"}, "language_info": {"codemirror_mode": {"name": "ipython", "version": 3}, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.5"}}, "nbformat": 4, "nbformat_minor": 2}