From 2478d40711c3c229738be7b9c3487e85ddca5162 Mon Sep 17 00:00:00 2001 From: Ruchika-20 <84443383+Ruchika-20@users.noreply.github.com> Date: Wed, 24 Nov 2021 23:57:18 +0530 Subject: [PATCH 1/6] Create Data Science with Python : RANSAC Algorithm --- .../Tutorials/Data Science with Python : RANSAC Algorithm | 1 + 1 file changed, 1 insertion(+) create mode 100644 Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm diff --git a/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm b/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm @@ -0,0 +1 @@ + From 7b2ee3753caf2265bbdfe60e9d4a267768020827 Mon Sep 17 00:00:00 2001 From: Ruchika-20 <84443383+Ruchika-20@users.noreply.github.com> Date: Wed, 24 Nov 2021 23:57:39 +0530 Subject: [PATCH 2/6] Delete Data Science with Python : RANSAC Algorithm --- .../Tutorials/Data Science with Python : RANSAC Algorithm | 1 - 1 file changed, 1 deletion(-) delete mode 100644 Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm diff --git a/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm b/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm deleted file mode 100644 index 8b13789179..0000000000 --- a/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm +++ /dev/null @@ -1 +0,0 @@ - From a4ecf3c16adbed023b3cd1a039eb041d19718e33 Mon Sep 17 00:00:00 2001 From: Ruchika-20 <84443383+Ruchika-20@users.noreply.github.com> Date: Wed, 24 Nov 2021 23:59:32 +0530 Subject: [PATCH 3/6] Create Data Science with Python : RANSAC Algorithm --- .../Tutorials/Data Science with Python : RANSAC Algorithm | 1 + 1 file changed, 1 insertion(+) create mode 100644 Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm diff --git a/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm b/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm @@ -0,0 +1 @@ + From 403d07ec60115763cce62c215a2f34505f524252 Mon Sep 17 00:00:00 2001 From: Ruchika-20 <84443383+Ruchika-20@users.noreply.github.com> Date: Thu, 25 Nov 2021 00:00:09 +0530 Subject: [PATCH 4/6] Delete Data Science with Python : RANSAC Algorithm --- .../Tutorials/Data Science with Python : RANSAC Algorithm | 1 - 1 file changed, 1 deletion(-) delete mode 100644 Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm diff --git a/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm b/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm deleted file mode 100644 index 8b13789179..0000000000 --- a/Datascience_With_Python/Computer Vision/Tutorials/Data Science with Python : RANSAC Algorithm +++ /dev/null @@ -1 +0,0 @@ - From def88acdeac288b48f74d222e9156cb1d1cdca30 Mon Sep 17 00:00:00 2001 From: Ruchika-20 <84443383+Ruchika-20@users.noreply.github.com> Date: Sat, 27 Nov 2021 11:19:14 +0530 Subject: [PATCH 5/6] Create README.md --- .../README.md | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 Datascience_With_Python/Computer Vision/Tutorials/Data science with Python: RANSAC Algorithm/README.md diff --git a/Datascience_With_Python/Computer Vision/Tutorials/Data science with Python: RANSAC Algorithm/README.md b/Datascience_With_Python/Computer Vision/Tutorials/Data science with Python: RANSAC Algorithm/README.md new file mode 100644 index 0000000000..84c0cb5073 --- /dev/null +++ b/Datascience_With_Python/Computer Vision/Tutorials/Data science with Python: RANSAC Algorithm/README.md @@ -0,0 +1,44 @@ +Random sample consensus (RANSAC) +Definition +Hello EveryOne ! In this tutorial , we are going to have a look on RANSAC.So let's get started ! Hope you like it. + +Basic Idea +After reading this tutorial , you will acquire a basic knowledge of RANSAC and its imortance in computer vision. + +Goal +To understand the concept of RANSAC in detail. + +Topics to be Covered in this Tutorial : +WHAT IS RANSAC? + +Random sample consensus (RANSAC) is an iterative method to estimate parameters of a mathematical model from a set of observed data that contains outliers, when outliers are to be accorded no influence on the values of the estimates. + +PURPOSE + +This explains about the main purpose of using RANSAC over other algorithms and what is the basic idea behind using this. + +The RANSAC algorithm is a learning technique to estimate parameters of a model by random sampling of observed data. Given a dataset whose data elements contain both inliers and outliers, RANSAC uses the voting scheme to find the optimal fitting result. + +Major Advantages and Disadvantages + +An advantage of RANSAC is its ability to do robust estimation of the model parameters, i.e., it can estimate the parameters with a high degree of accuracy even when a significant number of outliers are present in the data set. + +A disadvantage of RANSAC is that there is no upper bound on the time it takes to compute these parameters. When the number of iterations computed is limited the solution obtained may not be optimal, and it may not even be one that fits the data in a good way. In this way RANSAC offers a trade-off; by computing a greater number of iterations the probability of a reasonable model being produced is increased. + +Another disadvantage of RANSAC is that it requires the setting of problem-specific thresholds. + +RANSAC can only estimate one model for a particular data set. As for any one-model approach when two (or more) model instances exist, RANSAC may fail to find either one. The Hough transform is an alternative robust estimation technique that may be useful when more than one model instance is present. + +Implementation of algorithm in Python + +This covers a detailed explaination of RANSAC algorithm using Python on a given Image. Feature Extraction and FEature matching are done for a given image. + +Bibliography + +http://www.cse.yorku.ca/~kosta/CompVis_Notes/ransac.pdf + +https://en.wikipedia.org/wiki/Random_sample_consensus#Advantages_and_disadvantages + +https://scikit-learn.org/stable/auto_examples/linear_model/plot_ransac.html + +https://vitalflux.com/ransac-regression-explained-with-python-examples/ From 292153f039f02fe2d8567a7831768b452ffca8c4 Mon Sep 17 00:00:00 2001 From: Ruchika-20 <84443383+Ruchika-20@users.noreply.github.com> Date: Sat, 27 Nov 2021 11:19:56 +0530 Subject: [PATCH 6/6] Add files via upload --- ... with Python RANSAC Algorithm #7355.ipynb | 346 ++++++++++++++++++ 1 file changed, 346 insertions(+) create mode 100644 Datascience_With_Python/Computer Vision/Tutorials/Data science with Python: RANSAC Algorithm/Data Science with Python RANSAC Algorithm #7355.ipynb diff --git a/Datascience_With_Python/Computer Vision/Tutorials/Data science with Python: RANSAC Algorithm/Data Science with Python RANSAC Algorithm #7355.ipynb b/Datascience_With_Python/Computer Vision/Tutorials/Data science with Python: RANSAC Algorithm/Data Science with Python RANSAC Algorithm #7355.ipynb new file mode 100644 index 0000000000..7f35619343 --- /dev/null +++ b/Datascience_With_Python/Computer Vision/Tutorials/Data science with Python: RANSAC Algorithm/Data Science with Python RANSAC Algorithm #7355.ipynb @@ -0,0 +1,346 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Untitled9.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "Hus89IFgfXW1" + }, + "source": [ + "# **RANSAC ALGORITHM**\n", + "\n", + "---\n", + "\n", + "\n", + "\n", + "---\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1lMSM87Ak_qo" + }, + "source": [ + "**OVERVIEW :**\n", + "\n", + "---\n", + "\n", + "\n", + "\n", + "\n", + "**Random sample consensus, or** **RANSAC**, is an iterative method for estimating a mathematical model from a data set that contains outliers. The RANSAC algorithm works by identifying the outliers in a data set and estimating the desired model using data that does not contain outliers.\n", + "\n", + "\n", + "The RANdom SAmple Consensus **(RANSAC)** algorithm proposed by **Fischler and**\n", + "**Bolles** is a general parameter estimation approach designed to cope with a large\n", + "proportion of outliers in the input data. \n", + "\n", + "Unlike many of the common robust estimation techniques such as M-estimators and least-median squares that have beenadopted by the computer vision community from the statistics literature, RANSACwas developed from within the computer vision community.\n", + "\n", + "\n", + "RANSAC is a **resampling technique** that generates candidate solutions by using\n", + "the minimum number observations (data points) required to estimate the underlying model parameters. \n", + "\n", + "As pointed out by Fischler and Bolles, unlike conventional sampling techniques that use as much of the data as possible to obtain an initial solution and then proceed to prune outliers, RANSAC uses the smallest set possible and proceeds to enlarge this set with consistent data points .\n", + "\n", + "\n", + "\n", + "\n", + "For example, the equation of a line that best fits a set of points can be estimated using RANSAC." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Z-yXws6d8Nb9" + }, + "source": [ + "**TERMINOLOGIES**:\n", + "\n", + "---\n", + "\n", + "\n", + "\n", + "**Outliers:** \n", + "\n", + "Outliers are data which are far from other data points. These data points can be found at both the ends. Meaning, outliers can be way below a certain point which can be termed as minimum or way more than other point which can be termed as maximum. One of the easy way to find outlier is to use boxplot. Here is the box plot created to find out outliers in the housing prices. In the boxplot given below, one can find outliers at both the ends such as minimum and maximum. These are the points which can have adverse impact on coefficients of regression model if not taken care of. In this post, you will learn about how using RANSAC algorithm will exclude outliers from training data used for training the model.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 415 + }, + "id": "jDuGxVaW9ooY", + "outputId": "f0a75ed9-b7ea-4af3-f992-aa8f685d3b70" + }, + "source": [ + "from sklearn import datasets\n", + "import matplotlib.pyplot as plt\n", + "#\n", + "# Load the boston housing dataset\n", + "#\n", + "bhd = datasets.load_boston()\n", + "X = bhd.data\n", + "y = bhd.target\n", + "#\n", + "# Create the box plot\n", + "#\n", + "fig1, ax1 = plt.subplots()\n", + "ax1.set_title('Box plot for Housing Prices')\n", + "ax1.boxplot(y, vert=False)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'boxes': [],\n", + " 'caps': [,\n", + " ],\n", + " 'fliers': [],\n", + " 'means': [],\n", + " 'medians': [],\n", + " 'whiskers': [,\n", + " ]}" + ] + }, + "metadata": {}, + "execution_count": 4 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C5iMDtI992rn" + }, + "source": [ + "**Inliers**: \n", + "\n", + "The data which are not outliers can be said as the inliers. Inliers represent the dataset which are used for training the model using algorithm specified as base_estimator. Looking the boxplot, one can say that the inliers data belong to dataset lying between minimum and maximum point." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EKhz33W0-MSv" + }, + "source": [ + "**Mean Absolute Deviation (MAD)**: \n", + "\n", + "Median absolute deviation is measure of variability of observations from the median value of the observation. This will be used to select the inlier threshold to classify whether a data point is inlier or outlier. The choice of right value for MAD is problem specific and the challenge is to select the most appropriate value for MAD to have the model which generalizes well with unseen dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "97MzsQhqlUGS" + }, + "source": [ + "**ALGORITHM** : \n", + "\n", + "---\n", + "\n", + "\n", + "\n", + "\n", + "1: Select randomly the minimum number of points required to determine the model\n", + "parameters.\n", + "\n", + "2: Solve for the parameters of the model.\n", + "\n", + "3: Determine how many points from the set of all points fit with a predefined tolerance.\n", + "\n", + "4: If the fraction of the number of inliers over the total number points in the set exceeds a predefined threshold τ , re-estimate the model parameters using all the identified inliers and terminate.\n", + "\n", + "5: Otherwise, repeat steps 1 through 4 (maximum of N times)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HcmQWiIOqioX" + }, + "source": [ + "**ADVANTAGES AND DISADVANTAGES :**\n", + "\n", + "---\n", + "\n", + "An advantage of RANSAC is its ability to do robust estimation of the model parameters, i.e., it can estimate the parameters with a high degree of accuracy even when a significant number of outliers are present in the data set.\n", + "\n", + "A disadvantage of RANSAC is that there is no upper bound on the time it takes to compute these parameters (except exhaustion). \n", + " \n", + "When the number of iterations computed is limited the solution obtained may not be optimal, and it may not even be one that fits the data in a good way. In this way RANSAC offers a trade-off; by computing a greater number of iterations the probability of a reasonable model being produced is increased. \n", + " \n", + "Moreover, RANSAC is not always able to find the optimal set even for moderately contaminated sets and it usually performs badly when the number of inliers is less than 50%.\n", + " \n", + "Optimal RANSAC was proposed to handle both these problems and is capable of finding the optimal set for heavily contaminated sets, even for an inlier ratio under 5%. \n", + "\n", + "Another disadvantage of RANSAC is that it requires the setting of problem-specific thresholds.\n", + "\n", + "RANSAC can only estimate one model for a particular data set. As for any one-model approach when two (or more) model instances exist, RANSAC may fail to find either one. \n", + "\n", + "The Hough transform is one alternative robust estimation technique that may be useful when more than one model instance is present. \n", + "\n", + "Another approach for multi model fitting is known as PEARL, which combines model sampling from data points as in RANSAC with iterative re-estimation of inliers and the multi-model fitting being formulated as an optimization problem with a global energy function describing the quality of the overall solution.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qrYx65JJwxtb" + }, + "source": [ + "**IMPLEMENTING RANSAC ALGORITHM IN PYTHON** :\n", + "\n", + "---\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SbZjhDUewrGE" + }, + "source": [ + "**Robust linear model estimation using RANSAC**\n", + "\n", + "---\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 313 + }, + "id": "ZKQeDZ2fuJLd", + "outputId": "b6a719a0-809e-448f-e2ce-4f028a8e6715" + }, + "source": [ + "\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from sklearn import linear_model, datasets\n", + "\n", + "\n", + "n_samples = 1000\n", + "n_outliers = 50\n", + "\n", + "\n", + "X, y, coef = datasets.make_regression(\n", + " n_samples=n_samples,\n", + " n_features=1,\n", + " n_informative=1,\n", + " noise=10,\n", + " coef=True,\n", + " random_state=0,\n", + ")\n", + "\n", + "# Add outlier data\n", + "np.random.seed(0)\n", + "X[:n_outliers] = 3 + 0.5 * np.random.normal(size=(n_outliers, 1))\n", + "y[:n_outliers] = -3 + 10 * np.random.normal(size=n_outliers)\n", + "\n", + "# Fit line using all data\n", + "lr = linear_model.LinearRegression()\n", + "lr.fit(X, y)\n", + "\n", + "# Robustly fit linear model with RANSAC algorithm\n", + "ransac = linear_model.RANSACRegressor()\n", + "ransac.fit(X, y)\n", + "inlier_mask = ransac.inlier_mask_\n", + "outlier_mask = np.logical_not(inlier_mask)\n", + "\n", + "# Predict data of estimated models\n", + "line_X = np.arange(X.min(), X.max())[:, np.newaxis]\n", + "line_y = lr.predict(line_X)\n", + "line_y_ransac = ransac.predict(line_X)\n", + "\n", + "# Compare estimated coefficients\n", + "print(\"Estimated coefficients (true, linear regression, RANSAC):\")\n", + "print(coef, lr.coef_, ransac.estimator_.coef_)\n", + "\n", + "lw = 2\n", + "plt.scatter(\n", + " X[inlier_mask], y[inlier_mask], color=\"yellowgreen\", marker=\".\", label=\"Inliers\"\n", + ")\n", + "plt.scatter(\n", + " X[outlier_mask], y[outlier_mask], color=\"gold\", marker=\".\", label=\"Outliers\"\n", + ")\n", + "plt.plot(line_X, line_y, color=\"navy\", linewidth=lw, label=\"Linear regressor\")\n", + "plt.plot(\n", + " line_X,\n", + " line_y_ransac,\n", + " color=\"cornflowerblue\",\n", + " linewidth=lw,\n", + " label=\"RANSAC regressor\",\n", + ")\n", + "plt.legend(loc=\"lower right\")\n", + "plt.xlabel(\"Input\")\n", + "plt.ylabel(\"Response\")\n", + "plt.show()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Estimated coefficients (true, linear regression, RANSAC):\n", + "82.1903908407869 [54.17236387] [82.08533159]\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file