From 777faee237b4927330f4a0d04c4bf115160dc369 Mon Sep 17 00:00:00 2001 From: dishaay2898 <72732241+dishaay2898@users.noreply.github.com> Date: Mon, 12 Oct 2020 13:53:18 +0530 Subject: [PATCH 1/7] Create task1 disha --- Disha Mathur SEC-C 4th year/task1 disha | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Disha Mathur SEC-C 4th year/task1 disha diff --git a/Disha Mathur SEC-C 4th year/task1 disha b/Disha Mathur SEC-C 4th year/task1 disha new file mode 100644 index 0000000..f174320 --- /dev/null +++ b/Disha Mathur SEC-C 4th year/task1 disha @@ -0,0 +1,14 @@ +PYTHON LIBRARIES ARE AS FOLLOWS: +1. NUMPY: +Numpy is a popular array – processing package of Python. It provides good support for different dimensional array objects as well as for matrices. Numpy is not only confined to providing arrays only, but it also provides a variety of tools to manage these arrays. It is fast, efficient, and really good for managing matrice and arrays. + +2. REQUEST: +Requests is a rich Python HTTP library. Released under Apache2.0 license, Requests is focused on making HTTP requests more responsive and user-friendly. This python library is a real blessing for beginners as it allows the use of most common methods of HTTP. You can easily customize, inspect, authorize, and configure HTTP requests using this library. +3. TENSER FLOW: +TensorFlow is a free, open-source python machine learning library. It is very easy to learn and has a handful collection of useful tools. However, it is not limited to machine learning only; you can also use it for dataflow and programs that are differentiable. You can easily get to work with TensorFlow by installing Colab Notebooks in any browser you use. +4. FIRE: +Fire is an open-source python library. It can automatically generate CLIs (command-line interfaces). Even to do so, you will be just needing a few lines of code. Fire is a powerful library that can derive CLIs from literally any python objects. It is used by Google as well to create a command line and different experiment management tools as well. +5. ARROW: +Arrow is a practical python library. It is a friendly library that basically works with dates and times. Arrow comes with a smart API. This API supports many general schemes. It is an interesting library. Beginners with basic knowledge of coding can get pretty well with Arrow. +6. FLASH TEXT : +FlashText is another python library that offers easy search and replacement of words from documents. All FlashText needs is a set of words and string. Then it identifies some words as keywords and replaces them from Text Data. It is a very effective library. People who are struggling with word replacement can choose it with confidence. From 8b963006d88925942a9c66b336e1329737fbcbbf Mon Sep 17 00:00:00 2001 From: dishaay2898 <72732241+dishaay2898@users.noreply.github.com> Date: Mon, 12 Oct 2020 13:56:11 +0530 Subject: [PATCH 2/7] Created using Colaboratory --- task2_disha.ipynb | 108 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 task2_disha.ipynb diff --git a/task2_disha.ipynb b/task2_disha.ipynb new file mode 100644 index 0000000..3b453ce --- /dev/null +++ b/task2_disha.ipynb @@ -0,0 +1,108 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "task2 disha", + "provenance": [], + "collapsed_sections": [], + "authorship_tag": "ABX9TyPhMY9I4zi6RpOeoQMKGZwq", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "i4MzKAdpwqxX", + "outputId": "d5f155b4-d1aa-43eb-8fcd-a59395e0c7a3", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 136 + } + }, + "source": [ + "a = 9\n", + "b = 4\n", + " \n", + "# Addition of numbers \n", + "add = a + b \n", + " \n", + "# Subtraction of numbers \n", + "sub = a - b \n", + " \n", + "# Multiplication of number \n", + "mul = a * b \n", + " \n", + "# Division of number \n", + "div1 = a / b \n", + " \n", + "# Division(floor) of number \n", + "div2 = a // b \n", + " \n", + "# Modulo of both number \n", + "mod = a % b \n", + " \n", + "# Power \n", + "p = a ** b \n", + " \n", + "# print results \n", + "print(add) \n", + "print(sub) \n", + "print(mul) \n", + "print(div1) \n", + "print(div2) \n", + "print(mod) \n", + "print(p) " + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "13\n", + "5\n", + "36\n", + "2.25\n", + "2\n", + "1\n", + "6561\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nyuXyXKWyujH" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nLyaLbNPyvc4" + }, + "source": [ + "" + ] + } + ] +} \ No newline at end of file From e59b3300229986c5b6b12535209d42459b16e0de Mon Sep 17 00:00:00 2001 From: dishaay2898 <72732241+dishaay2898@users.noreply.github.com> Date: Wed, 21 Oct 2020 20:16:11 +0530 Subject: [PATCH 3/7] Created using Colaboratory --- Welcome_To_Colaboratory.ipynb | 287 ++++++++++++++++++++++++++++++++++ 1 file changed, 287 insertions(+) create mode 100644 Welcome_To_Colaboratory.ipynb diff --git a/Welcome_To_Colaboratory.ipynb b/Welcome_To_Colaboratory.ipynb new file mode 100644 index 0000000..30f696f --- /dev/null +++ b/Welcome_To_Colaboratory.ipynb @@ -0,0 +1,287 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Welcome To Colaboratory", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true, + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5fCEDCU_qrC0" + }, + "source": [ + "

\"Colaboratory

\n", + "\n", + "

What is Colaboratory?

\n", + "\n", + "Colaboratory, or \"Colab\" for short, allows you to write and execute Python in your browser, with \n", + "- Zero configuration required\n", + "- Free access to GPUs\n", + "- Easy sharing\n", + "\n", + "Whether you're a **student**, a **data scientist** or an **AI researcher**, Colab can make your work easier. Watch [Introduction to Colab](https://www.youtube.com/watch?v=inN8seMm7UI) to learn more, or just get started below!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GJBs_flRovLc" + }, + "source": [ + "## **Getting started**\n", + "\n", + "The document you are reading is not a static web page, but an interactive environment called a **Colab notebook** that lets you write and execute code.\n", + "\n", + "For example, here is a **code cell** with a short Python script that computes a value, stores it in a variable, and prints the result:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gJr_9dXGpJ05", + "outputId": "9f556d03-ec67-4950-a485-cfdba9ddd14d", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "seconds_in_a_day = 24 * 60 * 60\n", + "seconds_in_a_day" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "86400" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 0 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2fhs6GZ4qFMx" + }, + "source": [ + "To execute the code in the above cell, select it with a click and then either press the play button to the left of the code, or use the keyboard shortcut \"Command/Ctrl+Enter\". To edit the code, just click the cell and start editing.\n", + "\n", + "Variables that you define in one cell can later be used in other cells:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "-gE-Ez1qtyIA", + "outputId": "94cb2224-0edf-457b-90b5-0ac3488d8a97", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "seconds_in_a_week = 7 * seconds_in_a_day\n", + "seconds_in_a_week" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "604800" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 0 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lSrWNr3MuFUS" + }, + "source": [ + "Colab notebooks allow you to combine **executable code** and **rich text** in a single document, along with **images**, **HTML**, **LaTeX** and more. When you create your own Colab notebooks, they are stored in your Google Drive account. You can easily share your Colab notebooks with co-workers or friends, allowing them to comment on your notebooks or even edit them. To learn more, see [Overview of Colab](/notebooks/basic_features_overview.ipynb). To create a new Colab notebook you can use the File menu above, or use the following link: [create a new Colab notebook](http://colab.research.google.com#create=true).\n", + "\n", + "Colab notebooks are Jupyter notebooks that are hosted by Colab. To learn more about the Jupyter project, see [jupyter.org](https://www.jupyter.org)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UdRyKR44dcNI" + }, + "source": [ + "## Data science\n", + "\n", + "With Colab you can harness the full power of popular Python libraries to analyze and visualize data. The code cell below uses **numpy** to generate some random data, and uses **matplotlib** to visualize it. To edit the code, just click the cell and start editing." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C4HZx7Gndbrh", + "outputId": "46abc637-6abd-41b2-9bba-80a7ae992e06", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + } + }, + "source": [ + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "ys = 200 + np.random.randn(100)\n", + "x = [x for x in range(len(ys))]\n", + "\n", + "plt.plot(x, ys, '-')\n", + "plt.fill_between(x, ys, 195, where=(ys > 195), facecolor='g', alpha=0.6)\n", + "\n", + "plt.title(\"Sample Visualization\")\n", + "plt.show()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEICAYAAABRSj9aAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/wEY0siNlckV2gAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4_kCnsPUqS6o" + }, + "source": [ + "You can import your own data into Colab notebooks from your Google Drive account, including from spreadsheets, as well as from Github and many other sources. To learn more about importing data, and how Colab can be used for data science, see the links below under [Working with Data](#working-with-data)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OwuxHmxllTwN" + }, + "source": [ + "## Machine learning\n", + "\n", + "With Colab you can import an image dataset, train an image classifier on it, and evaluate the model, all in just [a few lines of code](https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/tutorials/quickstart/beginner.ipynb). Colab notebooks execute code on Google's cloud servers, meaning you can leverage the power of Google hardware, including [GPUs and TPUs](#using-accelerated-hardware), regardless of the power of your machine. All you need is a browser." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ufxBm1yRnruN" + }, + "source": [ + "Colab is used extensively in the machine learning community with applications including:\n", + "- Getting started with TensorFlow\n", + "- Developing and training neural networks\n", + "- Experimenting with TPUs\n", + "- Disseminating AI research\n", + "- Creating tutorials\n", + "\n", + "To see sample Colab notebooks that demonstrate machine learning applications, see the [machine learning examples](#machine-learning-examples) below." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-Rh3-Vt9Nev9" + }, + "source": [ + "## More Resources\n", + "\n", + "### Working with Notebooks in Colab\n", + "- [Overview of Colaboratory](/notebooks/basic_features_overview.ipynb)\n", + "- [Guide to Markdown](/notebooks/markdown_guide.ipynb)\n", + "- [Importing libraries and installing dependencies](/notebooks/snippets/importing_libraries.ipynb)\n", + "- [Saving and loading notebooks in GitHub](https://colab.research.google.com/github/googlecolab/colabtools/blob/master/notebooks/colab-github-demo.ipynb)\n", + "- [Interactive forms](/notebooks/forms.ipynb)\n", + "- [Interactive widgets](/notebooks/widgets.ipynb)\n", + "- \"New\"\n", + " [TensorFlow 2 in Colab](/notebooks/tensorflow_version.ipynb)\n", + "\n", + "\n", + "### Working with Data\n", + "- [Loading data: Drive, Sheets, and Google Cloud Storage](/notebooks/io.ipynb) \n", + "- [Charts: visualizing data](/notebooks/charts.ipynb)\n", + "- [Getting started with BigQuery](/notebooks/bigquery.ipynb)\n", + "\n", + "### Machine Learning Crash Course\n", + "These are a few of the notebooks from Google's online Machine Learning course. See the [full course website](https://developers.google.com/machine-learning/crash-course/) for more.\n", + "- [Intro to Pandas](/notebooks/mlcc/intro_to_pandas.ipynb)\n", + "- [Tensorflow concepts](/notebooks/mlcc/tensorflow_programming_concepts.ipynb)\n", + "- [First steps with TensorFlow](/notebooks/mlcc/first_steps_with_tensor_flow.ipynb)\n", + "- [Intro to neural nets](/notebooks/mlcc/intro_to_neural_nets.ipynb)\n", + "- [Intro to sparse data and embeddings](/notebooks/mlcc/intro_to_sparse_data_and_embeddings.ipynb)\n", + "\n", + "\n", + "### Using Accelerated Hardware\n", + "- [TensorFlow with GPUs](/notebooks/gpu.ipynb)\n", + "- [TensorFlow with TPUs](/notebooks/tpu.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "P-H6Lw1vyNNd" + }, + "source": [ + "\n", + "\n", + "## Machine Learning Examples\n", + "\n", + "To see end-to-end examples of the interactive machine learning analyses that Colaboratory makes possible, check out these tutorials using models from [TensorFlow Hub](https://tfhub.dev).\n", + "\n", + "A few featured examples:\n", + "\n", + "- [Retraining an Image Classifier](https://tensorflow.org/hub/tutorials/tf2_image_retraining): Build a Keras model on top of a pre-trained image classifier to distinguish flowers.\n", + "- [Text Classification](https://tensorflow.org/hub/tutorials/tf2_text_classification): Classify IMDB movie reviews as either *positive* or *negative*.\n", + "- [Style Transfer](https://tensorflow.org/hub/tutorials/tf2_arbitrary_image_stylization): Use deep learning to transfer style between images.\n", + "- [Multilingual Universal Sentence Encoder Q&A](https://tensorflow.org/hub/tutorials/retrieval_with_tf_hub_universal_encoder_qa): Use a machine learning model to answer questions from the SQuAD dataset.\n", + "- [Video Interpolation](https://tensorflow.org/hub/tutorials/tweening_conv3d): Predict what happened in a video between the first and the last frame.\n" + ] + } + ] +} \ No newline at end of file From 43edd8d9b0e5976cbca9a9375c6204ed476f0d22 Mon Sep 17 00:00:00 2001 From: dishaay2898 <72732241+dishaay2898@users.noreply.github.com> Date: Wed, 21 Oct 2020 20:18:05 +0530 Subject: [PATCH 4/7] Created using Colaboratory --- Matplotlib.ipynb | 191 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 Matplotlib.ipynb diff --git a/Matplotlib.ipynb b/Matplotlib.ipynb new file mode 100644 index 0000000..82c269e --- /dev/null +++ b/Matplotlib.ipynb @@ -0,0 +1,191 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Matplotlib", + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Asd-6aNP-rVb" + }, + "source": [ + "from matplotlib import pyplot as plt " + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "Pdi3MM8x_xKD", + "outputId": "0e9ec5ee-5329-42d1-dbdc-17b1472e5c40", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "source": [ + "# x-axis values \n", + "x = [5, 2, 9, 4, 7] \n", + " \n", + "# Y-axis values \n", + "y = [10, 5, 8, 4, 2] \n", + " \n", + "# Function to plot \n", + "plt.plot(x,y) \n", + " \n", + "# function to show the plot \n", + "plt.show()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Dgfkj_65_6BQ", + "outputId": "956e3d4d-5b54-43ed-a93f-88af0e7ddb3c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "source": [ + "# Function to plot the bar \n", + "plt.bar(x,y) \n", + " \n", + "# function to show the plot \n", + "plt.show()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uwKPRQq5AEDW", + "outputId": "0cc2b3c0-2c82-453e-8bdc-afab583b596a", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "source": [ + "# Function to plot histogram \n", + "plt.hist(y) \n", + " \n", + "# Function to show the plot \n", + "plt.show() " + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAOnElEQVR4nO3df6zdd13H8eeLdhMGCLpeCPYHXUJBGhQ2bup0ipMN0w3SGjVkTVAkC/WPDYcQTVEzdP4DYvBHMtGGDRBhswzQRiqDwHSJcXN3bMDaUryWjbYMWmAMcZFRfPvH+XY5u7u357Q9t9/bD89HctPz/Z7Pznn3bH32nO8537NUFZKkM9+T+h5AkjQZBl2SGmHQJakRBl2SGmHQJakRy/u64xUrVtTatWv7untJOiPdfffdX6+qqfmu6y3oa9euZWZmpq+7l6QzUpIHFrrOQy6S1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNGBn0JDcmOZzkvgWuT5K/TDKb5HNJLpj8mJKkUcZ5hv5eYONxrr8MWNf9bAXedepjSZJO1MigV9XtwDePs2Qz8Lc1cAfwzCTPmdSAkqTxTOJM0ZXAgaHtg92+B+cuTLKVwbN41qxZc9J3uHbbx076nz1V97/tlb3cb5+/57709Vj/IPLP1Om1WL/n0/qmaFVtr6rpqpqempr3qwgkSSdpEkE/BKwe2l7V7ZMknUaTCPpO4Ne7T7tcCDxcVU843CJJWlwjj6EnuQm4GFiR5CDwVuAsgKr6a2AXcDkwCzwCvG6xhpUkLWxk0Ktqy4jrC7hqYhNJkk6KZ4pKUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1YqygJ9mYZF+S2STb5rl+TZLbktyT5HNJLp/8qJKk4xkZ9CTLgOuBy4D1wJYk6+cs+wNgR1WdD1wB/NWkB5UkHd84z9A3ALNVtb+qHgVuBjbPWVPAD3eXnwF8ZXIjSpLGMU7QVwIHhrYPdvuG/SHwmiQHgV3AG+a7oSRbk8wkmTly5MhJjCtJWsik3hTdAry3qlYBlwPvT/KE266q7VU1XVXTU1NTE7prSRKMF/RDwOqh7VXdvmFXAjsAqurfgScDKyYxoCRpPOME/S5gXZLzkpzN4E3PnXPWfBm4BCDJCxkE3WMqknQajQx6VR0FrgZuBfYy+DTL7iTXJdnULXsz8PoknwVuAn6jqmqxhpYkPdHycRZV1S4Gb3YO77t26PIe4KLJjiZJOhGeKSpJjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktSIsYKeZGOSfUlmk2xbYM2rk+xJsjvJByc7piRplOWjFiRZBlwPvAI4CNyVZGdV7Rlasw54C3BRVT2U5FmLNbAkaX7jPEPfAMxW1f6qehS4Gdg8Z83rgeur6iGAqjo82TElSaOME/SVwIGh7YPdvmHPB56f5N+S3JFk46QGlCSNZ+QhlxO4nXXAxcAq4PYkP1FV3xpelGQrsBVgzZo1E7prSRKM9wz9ELB6aHtVt2/YQWBnVX2vqr4EfJFB4B+nqrZX1XRVTU9NTZ3szJKkeYwT9LuAdUnOS3I2cAWwc86af2Dw7JwkKxgcgtk/wTklSSOMDHpVHQWuBm4F9gI7qmp3kuuSbOqW3Qp8I8ke4Dbgd6rqG4s1tCTpicY6hl5Vu4Bdc/ZdO3S5gDd1P5KkHnimqCQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1YqygJ9mYZF+S2STbjrPuV5JUkunJjShJGsfIoCdZBlwPXAasB7YkWT/PuqcD1wB3TnpISdJo4zxD3wDMVtX+qnoUuBnYPM+6PwbeDvzvBOeTJI1pnKCvBA4MbR/s9j0myQXA6qr62PFuKMnWJDNJZo4cOXLCw0qSFnbKb4omeRLwTuDNo9ZW1faqmq6q6ampqVO9a0nSkHGCfghYPbS9qtt3zNOBFwH/kuR+4EJgp2+MStLpNU7Q7wLWJTkvydnAFcDOY1dW1cNVtaKq1lbVWuAOYFNVzSzKxJKkeY0MelUdBa4GbgX2AjuqaneS65JsWuwBJUnjWT7OoqraBeyas+/aBdZefOpjSZJOlGeKSlIjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNWKsoCfZmGRfktkk2+a5/k1J9iT5XJJPJXnu5EeVJB3PyKAnWQZcD1wGrAe2JFk/Z9k9wHRV/SRwC/Ankx5UknR84zxD3wDMVtX+qnoUuBnYPLygqm6rqke6zTuAVZMdU5I0yjhBXwkcGNo+2O1byJXAP893RZKtSWaSzBw5cmT8KSVJI030TdEkrwGmgXfMd31Vba+q6aqanpqamuRdS9IPvOVjrDkErB7aXtXte5wklwK/D/x8VX13MuNJksY1zjP0u4B1Sc5LcjZwBbBzeEGS84G/ATZV1eHJjylJGmVk0KvqKHA1cCuwF9hRVbuTXJdkU7fsHcDTgA8luTfJzgVuTpK0SMY55EJV7QJ2zdl37dDlSyc8lyTpBHmmqCQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1YqygJ9mYZF+S2STb5rn+h5L8fXf9nUnWTnpQSdLxjQx6kmXA9cBlwHpgS5L1c5ZdCTxUVc8D/gx4+6QHlSQd3zjP0DcAs1W1v6oeBW4GNs9Zsxl4X3f5FuCSJJncmJKkUZaPsWYlcGBo+yDwUwutqaqjSR4GzgW+PrwoyVZga7f5nST7TmZoYMXc2z5dcvzXHr3NNcIZOdeIx3oxLdXHC5bubCc91yL/e16Sj1fefkpzPXehK8YJ+sRU1XZg+6neTpKZqpqewEgT5VwnxrlO3FKdzblOzGLNNc4hl0PA6qHtVd2+edckWQ48A/jGJAaUJI1nnKDfBaxLcl6Ss4ErgJ1z1uwEXttd/lXg01VVkxtTkjTKyEMu3THxq4FbgWXAjVW1O8l1wExV7QRuAN6fZBb4JoPoL6ZTPmyzSJzrxDjXiVuqsznXiVmUueITaUlqg2eKSlIjDLokNeKMCnqS1UluS7Inye4k1/Q9E0CSJyf5jySf7eb6o75nGpZkWZJ7kvxT37Mck+T+JJ9Pcm+Smb7nOSbJM5PckuQLSfYm+eklMNMLusfp2M+3k7yx77kAkvx299/8fUluSvLkvmcCSHJNN9PuPh+rJDcmOZzkvqF9P5rkk0n+s/v1RyZ1f2dU0IGjwJuraj1wIXDVPF9D0IfvAi+vqhcDLwE2Jrmw55mGXQPs7XuIefxCVb1kiX1O+C+Aj1fVjwMvZgk8blW1r3ucXgK8FHgE+GjPY5FkJfBbwHRVvYjBhyYW+wMRIyV5EfB6Bme5vxh4VZLn9TTOe4GNc/ZtAz5VVeuAT3XbE3FGBb2qHqyqz3SX/5vBH7aV/U4FNfCdbvOs7mdJvNucZBXwSuDdfc+y1CV5BvAyBp/aoqoerapv9TvVE1wC/FdVPdD3IJ3lwFO680/OAb7S8zwALwTurKpHquoo8K/AL/cxSFXdzuCTf8OGvyrlfcAvTer+zqigD+u+0fF84M5+JxnoDmvcCxwGPllVS2Iu4M+B3wX+r+9B5ijgE0nu7r4SYik4DzgCvKc7RPXuJE/te6g5rgBu6nsIgKo6BPwp8GXgQeDhqvpEv1MBcB/wc0nOTXIOcDmPPzmyb8+uqge7y18Fnj2pGz4jg57kacCHgTdW1bf7ngegqr7fvSReBWzoXvb1KsmrgMNVdXffs8zjZ6vqAgbf4nlVkpf1PRCDZ5sXAO+qqvOB/2GCL4dPVXdi3ybgQ33PAtAd+93M4C/CHwOemuQ1/U4FVbWXwTe+fgL4OHAv8P1eh1pAdwLmxF7Nn3FBT3IWg5h/oKo+0vc8c3Uv0W/jicfN+nARsCnJ/Qy+JfPlSf6u35EGumd3VNVhBseDN/Q7ETD44rmDQ6+ubmEQ+KXiMuAzVfW1vgfpXAp8qaqOVNX3gI8AP9PzTABU1Q1V9dKqehnwEPDFvmca8rUkzwHofj08qRs+o4LefSXvDcDeqnpn3/Mck2QqyTO7y08BXgF8od+poKreUlWrqmotg5fqn66q3p9BJXlqkqcfuwz8IoOXyb2qqq8CB5K8oNt1CbCnx5Hm2sISOdzS+TJwYZJzuj+bl7AE3kQGSPKs7tc1DI6ff7DfiR5n+KtSXgv846Ru+LR+2+IEXAT8GvD57ng1wO9V1a4eZwJ4DvC+7n8G8iRgR1UtmY8ILkHPBj7afWX+cuCDVfXxfkd6zBuAD3SHN/YDr+t5HuCxv/heAfxm37McU1V3JrkF+AyDT6Ddw9I51f7DSc4Fvgdc1deb20luAi4GViQ5CLwVeBuwI8mVwAPAqyd2f576L0ltOKMOuUiSFmbQJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGvH/t3+e6mWB98QAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "dN47-1C6AJt_", + "outputId": "467bdaa3-738e-4555-d988-1a5ec16fee40", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "source": [ + "# Function to plot scatter \n", + "plt.scatter(x, y) \n", + " \n", + "# function to show the plot \n", + "plt.show() " + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uDBOn7DkAObA" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 59bd25f147a5a25cafe6283938473955f2d3eadf Mon Sep 17 00:00:00 2001 From: dishaay2898 <72732241+dishaay2898@users.noreply.github.com> Date: Wed, 21 Oct 2020 20:18:58 +0530 Subject: [PATCH 5/7] Created using Colaboratory --- Data_Structures_in_Python.ipynb | 747 ++++++++++++++++++++++++++++++++ 1 file changed, 747 insertions(+) create mode 100644 Data_Structures_in_Python.ipynb diff --git a/Data_Structures_in_Python.ipynb b/Data_Structures_in_Python.ipynb new file mode 100644 index 0000000..9e6353d --- /dev/null +++ b/Data_Structures_in_Python.ipynb @@ -0,0 +1,747 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Data Structures in Python", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PUElL6aPIkXZ" + }, + "source": [ + "Commonly used Data structures in Python are:\n", + "* List\n", + "* Dictionary\n", + "* Tuple\n", + "* Set\n", + "* String\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Sjc5RLCzPFQ2" + }, + "source": [ + "# List" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pp5ZeLhOI61V", + "outputId": "626927e8-b86b-4de1-a7d4-40c011d3ccea", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + } + }, + "source": [ + "l =['a','ab','cd',10,10.9,-6] #collection of diffrent data types.\n", + "l[0] # access elemenst using Indexing." + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'a'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "un_2kHedOo-m", + "outputId": "e81404fd-add9-4fc6-9394-c38ca53602b6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 50 + } + }, + "source": [ + "print(l[-1]) # negative indexing to access elements from last\n", + "print(l[2])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "-6\n", + "cd\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "B_mo2tqmOcsh", + "outputId": "52b8790e-c7ec-412f-c17a-23840503be51", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "l[2:5] #slicing [a:b] from a to b-1" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['cd', 10, 10.9]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 14 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "PQWb536vNUvQ", + "outputId": "5eeea1b6-1f93-4105-bd09-a9b8f27d07d2", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "l.append(4) # adds an element at the last\n", + "l" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['a', 'ab', 'cd', 10, 10.9, -6, 4]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 19 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ao5w7-yDOvw6", + "outputId": "a86a6c0c-9625-4efa-a4c0-f33f41b5d21c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "l.pop() #pop: deletes the last element\n", + "l" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['a', 'ab', 'cd', 10, 10.9, -6]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 20 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YJF6H7owO_hh" + }, + "source": [ + "# Dictionary\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4fnT7_ygPLvO", + "outputId": "0d1bd58d-be70-43d3-8777-d162bf0c4c2c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "d ={1:'jake', 2:'amy'}\n", + "d\n" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{1: 'jake', 2: 'amy'}" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4D7AQ0xAQrJs", + "outputId": "e4a57c74-afb7-4917-b7d1-e56318fa5eff", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "d.keys() # to print all the keys" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "dict_keys([1, 2])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 28 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "bNeCmIjfQzPS", + "outputId": "8ae516bd-2418-4fcd-f37d-478e8bba917a", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + } + }, + "source": [ + "d[2] #access elements using key value like d[\"key value\"]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'amy'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 29 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "XNKG_V01Q4ES", + "outputId": "f782d1fa-f1ef-4b2f-945e-87135acd5374", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "d.values() # to print all the values associated with the keys" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "dict_values(['jake', 'amy'])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 31 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "JKH8rNNmRA32", + "outputId": "581ae76a-968f-4721-d906-ff440d340ac5", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "print ('xyz'in d) # to check if the value is present in the dictionary or not" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "False\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "216YZImRSA5X" + }, + "source": [ + "# Tuple" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "VGjIN7gRSGV2", + "outputId": "78249e9e-2a59-4160-a170-99704ee79919", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "t=('a','n','j',9,9.0,1+8) # tuple defined in (), collection of different data types\n", + "t" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('a', 'n', 'j', 9, 9.0, 9)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 36 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "MLAAb4KqSWH0", + "outputId": "6c6b967d-c3fb-48f9-9c5e-8367c4c7f8a0", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "ab=(\"captain holt\",(\"Terry\",\"Gina\")) #nested tuples\n", + "ab" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('captain holt', ('Terry', 'Gina'))" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "BiDgGt1zSrQ-", + "outputId": "1f65ab70-e147-48a8-c6df-e093db66affc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "ab[1]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('Terry', 'Gina')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 38 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "dGr9qUn1SuUX", + "outputId": "a5c0b23a-5e24-4b91-b7fb-0adacd5a4a20", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + } + }, + "source": [ + "ab[1][1]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'Gina'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 41 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "v_LBD_YsSzNf", + "outputId": "92e5148e-be4c-449c-b551-182eea5e39be", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "#most of the functionalities are same as Lists like INdexing and Sicing\n", + "ab[0:2]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('captain holt', ('Terry', 'Gina'))" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 42 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AesBYHnUTL83" + }, + "source": [ + "# Set\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "NhjsUfoQTJqZ" + }, + "source": [ + "s1= set() #creating an empty set\n", + " # sets are immutable \n" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "KPd2cYRETTXP" + }, + "source": [ + "for i in range(0,6): # to add elements in set use add() function\n", + " s1.add(i)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "-kxcKoRaTaRa", + "outputId": "0ca586f5-2bfa-4fd8-ee31-97af9f21db6c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "s1" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{0, 1, 2, 3, 4, 5}" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 45 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "TkVeJPXhTbSz" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Hiurwg8byLMZ" + }, + "source": [ + "# String" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "oblO57pRyOtX" + }, + "source": [ + "a=\"the best is yet to come!\" #strings:Single and double quotes are special characters.\n", + "b='Hello there :)'\n" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "VdvTn5CMymZ3", + "outputId": "70b656ca-c5b5-49d9-a299-cf33a710ebb6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + } + }, + "source": [ + "a" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'the best is yet to come!'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pA83-BApynGH", + "outputId": "0bf549c9-5d96-4fe5-8b7a-b67ebb77e8f1", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + } + }, + "source": [ + "b" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'Hello there :)'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "VfM1uGk5yoAa", + "outputId": "e32a9d71-e4b2-4230-b535-bbedf82ffc48", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + } + }, + "source": [ + "b[2:8] #indexing & slicing " + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'llo th'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hLGykswSyqsf", + "outputId": "73862a5c-4734-4c3a-b264-c3d4f5b0e4a8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + } + }, + "source": [ + "a[-6]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "' '" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "rlTVVvIvystx" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 4657e63e1af9dc77968b6ad38acabbd7d8f80952 Mon Sep 17 00:00:00 2001 From: dishaay2898 <72732241+dishaay2898@users.noreply.github.com> Date: Wed, 21 Oct 2020 20:19:50 +0530 Subject: [PATCH 6/7] Created using Colaboratory --- Matrix_Operations_with_Numpy.ipynb | 404 +++++++++++++++++++++++++++++ 1 file changed, 404 insertions(+) create mode 100644 Matrix_Operations_with_Numpy.ipynb diff --git a/Matrix_Operations_with_Numpy.ipynb b/Matrix_Operations_with_Numpy.ipynb new file mode 100644 index 0000000..1e5f3c9 --- /dev/null +++ b/Matrix_Operations_with_Numpy.ipynb @@ -0,0 +1,404 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Matrix Operations with Numpy", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "WbOD-h4_63_2" + }, + "source": [ + "import numpy as np" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "LY05RgH_4mZr" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "KuVZ6Thf7tza" + }, + "source": [ + "a= np.array([[1,2,3],[5,6,7],[8,9,0]])\n", + "b=np.array([[0,1,0],[1,1,1],[2,2,2]])\n" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "W8Y0gDCZ8VAR", + "outputId": "afddd58d-d790-44aa-c1ed-2bfa16039dba", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67 + } + }, + "source": [ + "# to add two matrices:\n", + "ad= np.add(a,b)\n", + "ad" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 1, 3, 3],\n", + " [ 6, 7, 8],\n", + " [10, 11, 2]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZMcmlj6M8m_X", + "outputId": "27e8f271-110f-4192-addc-7bd0e4a48b6e", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67 + } + }, + "source": [ + "# to subtract two matrices:\n", + "su= np.subtract(a,b)\n", + "su" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 1, 1, 3],\n", + " [ 4, 5, 6],\n", + " [ 6, 7, -2]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "2Cy3wdEz8xCR", + "outputId": "8002ce11-b090-4971-875f-884a7a7a95bb", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 101 + } + }, + "source": [ + "# to divide two matrices:\n", + "di= np.divide(a,b)\n", + "di" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in true_divide\n", + " \n" + ], + "name": "stderr" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[inf, 2. , inf],\n", + " [5. , 6. , 7. ],\n", + " [4. , 4.5, 0. ]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0mRRkR7A87my", + "outputId": "799586a5-0626-4131-e37d-03d8f8be8c47", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67 + } + }, + "source": [ + "# to multiply two matrices:\n", + "mul=np.dot(a,b)\n", + "mul\n" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 8, 9, 8],\n", + " [20, 25, 20],\n", + " [ 9, 17, 9]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 7 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "6WrJs1tT9HDV", + "outputId": "808c928f-ef2d-4fc2-8245-000741651957", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67 + } + }, + "source": [ + "mul2= np.multiply(a,b)\n", + "mul2" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 0, 2, 0],\n", + " [ 5, 6, 7],\n", + " [16, 18, 0]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "aQ_8bf3d9V-c", + "outputId": "917656b8-b9d1-4474-a458-824fbfb57053", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67 + } + }, + "source": [ + "# to do sqaureroot \n", + "s=np.sqrt(a)\n", + "s\n" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[1. , 1.41421356, 1.73205081],\n", + " [2.23606798, 2.44948974, 2.64575131],\n", + " [2.82842712, 3. , 0. ]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8N18mOIL9lzp", + "outputId": "a0529031-4e52-497d-be7f-c53b6b4cb032", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "# the summation of elements:\n", + "o=np.sum(b)\n", + "o" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "10" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 14 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "9uiekXHK955z", + "outputId": "35ffca27-d55c-426a-c0aa-9a00d5d1c1cc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "# row wise summation \n", + "r= np.sum(a,axis=1)\n", + "r" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([ 6, 18, 17])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 15 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pOm8f4YU-ImW", + "outputId": "9a9ae17a-d5f1-437a-9d41-857eb8819a66", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "source": [ + "# col wise summation \n", + "c= np.sum(a,axis=0)\n", + "c" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([14, 17, 10])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "F9y4U7zB-OWp", + "outputId": "bdc6f06e-34e5-461a-86b4-cf613ab8a1d9", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67 + } + }, + "source": [ + "#matrix transpose\n", + "t= a.T\n", + "t" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[1, 5, 8],\n", + " [2, 6, 9],\n", + " [3, 7, 0]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 18 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "r7cc-OoQ-f5Z" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 8e35f749a3b6f6929f7997c63cc94fb994972628 Mon Sep 17 00:00:00 2001 From: dishaay2898 <72732241+dishaay2898@users.noreply.github.com> Date: Sun, 6 Dec 2020 23:30:53 +0530 Subject: [PATCH 7/7] Add files via upload --- ... logic functions using numpy neuron..ipynb | 119 +++++++++++++ ANDlogic functions using numpy neuron..ipynb | 159 ++++++++++++++++++ BFS .ipynb | 74 ++++++++ DFS with Fix Limit.ipynb | 90 ++++++++++ Depth Limited Search .ipynb | 128 ++++++++++++++ Linear Separability AND.ipynb | 66 ++++++++ Linear Separability OR.ipynb | 77 +++++++++ Madaline Neural Network..ipynb | 119 +++++++++++++ NAND function using MP neuron..ipynb | 86 ++++++++++ NOR logic functions using numpy neuron.ipynb | 119 +++++++++++++ NOT logic functions using numpy neuron..ipynb | 106 ++++++++++++ OR logic functions using numpy neuron..ipynb | 143 ++++++++++++++++ Single layer perceptron ANDNOT.ipynb | 129 ++++++++++++++ ...le layer perceptron for AND function.ipynb | 115 +++++++++++++ 14 files changed, 1530 insertions(+) create mode 100644 ANDNOT logic functions using numpy neuron..ipynb create mode 100644 ANDlogic functions using numpy neuron..ipynb create mode 100644 BFS .ipynb create mode 100644 DFS with Fix Limit.ipynb create mode 100644 Depth Limited Search .ipynb create mode 100644 Linear Separability AND.ipynb create mode 100644 Linear Separability OR.ipynb create mode 100644 Madaline Neural Network..ipynb create mode 100644 NAND function using MP neuron..ipynb create mode 100644 NOR logic functions using numpy neuron.ipynb create mode 100644 NOT logic functions using numpy neuron..ipynb create mode 100644 OR logic functions using numpy neuron..ipynb create mode 100644 Single layer perceptron ANDNOT.ipynb create mode 100644 single layer perceptron for AND function.ipynb diff --git a/ANDNOT logic functions using numpy neuron..ipynb b/ANDNOT logic functions using numpy neuron..ipynb new file mode 100644 index 0000000..05d95b2 --- /dev/null +++ b/ANDNOT logic functions using numpy neuron..ipynb @@ -0,0 +1,119 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y is initiallised [[0]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[0]\n", + " [1]\n", + " [0]\n", + " [0]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 1\n", + "Enter Weight : 1\n", + "Enter Weight : -1\n", + "Y is initiallised [ 0. 1. -1. 0.]\n", + "Calculated y [[0.]\n", + " [1.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[0]\n", + " [1]\n", + " [0]\n", + " [0]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[0.]\n", + " [1.]\n", + " [0.]\n", + " [0.]]\n", + "\n", + "weights : [ 1. -1.] \n", + "\n", + "theta : 1\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[0],[1],[0],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(\"Y is initiallised\",yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1 \n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"Calculated y\",y)\n", + " print(\"Expected Target t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ANDlogic functions using numpy neuron..ipynb b/ANDlogic functions using numpy neuron..ipynb new file mode 100644 index 0000000..bd68d14 --- /dev/null +++ b/ANDlogic functions using numpy neuron..ipynb @@ -0,0 +1,159 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y is initiallised [[0]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 2\n", + "Enter Weight : 1\n", + "Enter Weight : 1\n", + "Y is initiallised [2. 1. 1. 0.]\n", + "Calculated y [[1.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[1.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[1.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "\n", + "weights : [1. 1.] \n", + "\n", + "theta : 2\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[1],[0],[0],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(\"Y is initiallised\",yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1 \n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"Calculated y\",y)\n", + " print(\"Expected Target t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/BFS .ipynb b/BFS .ipynb new file mode 100644 index 0000000..8d43b69 --- /dev/null +++ b/BFS .ipynb @@ -0,0 +1,74 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter the number you want to search-5\n", + "[1, 2, 3, 5]\n" + ] + } + ], + "source": [ + "def bfs(graph,start,search):\n", + " explored = []\n", + " queue = [start]\n", + " found = 1\n", + " while found:\n", + " node = queue.pop(0)\n", + " if(node == search):\n", + " found = 0\n", + " if node not in explored:\n", + " explored.append(node)\n", + " neighbours = graph[node]\n", + " for neighbour in neighbours:\n", + " queue.append(neighbour)\n", + " print(explored)\n", + "\n", + "search = int(input(\"enter the number you want to search-\"))\n", + "graph = {1: [2, 3, 5],\n", + " 2: [1,4, 5],\n", + " 3: [1, 6, 7],\n", + " 4: [2],\n", + " 5: [1, 2,4],\n", + " 6: [3],\n", + " 7: [3]}\n", + "bfs(graph,1,search)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/DFS with Fix Limit.ipynb b/DFS with Fix Limit.ipynb new file mode 100644 index 0000000..b3efd59 --- /dev/null +++ b/DFS with Fix Limit.ipynb @@ -0,0 +1,90 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter the node to be searched4\n", + "enter the depth2\n", + "Target is NOT reachable from source within max depth\n" + ] + } + ], + "source": [ + "from collections import defaultdict \n", + "class Graph: \n", + " def __init__(self,vertices): \n", + " self.V = vertices \n", + " self.graph = defaultdict(list) \n", + " \n", + " def addEdge(self,u,v): \n", + " self.graph[u].append(v) \n", + " \n", + " def DLS(self,src,target,maxDepth): \n", + " if src == target : return True \n", + " if maxDepth <= 0 : return False \n", + " for i in self.graph[src]: \n", + " if(self.DLS(i,target,maxDepth-1)): \n", + " return True\n", + " return False \n", + " \n", + " def IDDFS(self,src, target, maxDepth): \n", + " for i in range(maxDepth): \n", + " if (self.DLS(src, target, i)): \n", + " return True\n", + " return False\n", + " \n", + " \n", + "g = Graph (7); \n", + "g.addEdge(0, 1) \n", + "g.addEdge(0, 2) \n", + "g.addEdge(1, 3) \n", + "g.addEdge(1, 4) \n", + "g.addEdge(2, 5) \n", + "g.addEdge(2, 6) \n", + "target = int(input(\"enter the node to be searched\"));\n", + "maxDepth = int(input(\"enter the depth\"));\n", + "src = 0 \n", + "if g.IDDFS(src, target, maxDepth) == True: \n", + " print (\"Target is reachable from source \" +\n", + " \"within max depth\") \n", + "else : \n", + " print (\"Target is NOT reachable from source \" +\n", + " \"within max depth\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Depth Limited Search .ipynb b/Depth Limited Search .ipynb new file mode 100644 index 0000000..63f9452 --- /dev/null +++ b/Depth Limited Search .ipynb @@ -0,0 +1,128 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "adj {'S': ['2', '6'], '2': ['S', '3'], '3': ['2', '8'], 'G': ['10'], '6': ['S', '11'], '8': ['3', '13'], '10': ['G', '15'], '11': ['6', '12'], '12': ['11', '13', '17'], '13': ['8', '12'], '15': ['10', '20'], '17': ['12', '22'], '19': ['20', '24'], '20': ['15', '19'], '21': ['22'], '22': ['17', '21', '23'], '23': ['22', '24'], '24': ['19', '23']}\n", + "ENTER THE DEPTH LIMIT100\n", + "Starting a dls from \n", + "[ S ]\n", + "['2', '6']\n", + "['2', '11']\n", + "['2', '12']\n", + "['2', '13', '17']\n", + "['2', '13', '22']\n", + "['2', '13', '21', '23']\n", + "['2', '13', '21', '24']\n", + "['2', '13', '21', '19']\n", + "['2', '13', '21', '20']\n", + "['2', '13', '21', '15']\n", + "['2', '13', '21', '10']\n", + "['2', '13', '21', 'G']\n", + "Goal Node Found\n", + "True\n" + ] + } + ], + "source": [ + "ADJ = {}\n", + "ADJ['S'] = ['2', '6']\n", + "ADJ['2'] = ['S', '3']\n", + "ADJ['3'] = ['2','8']\n", + "ADJ['G'] = ['10']\n", + "ADJ['6'] = ['S', '11']\n", + "ADJ['8'] = ['3', '13']\n", + "ADJ['10'] = ['G', '15']\n", + "ADJ['11'] = ['6', '12']\n", + "ADJ['12'] = ['11', '13', '17']\n", + "ADJ['13'] = ['8', '12']\n", + "ADJ['15'] = ['10', '20']\n", + "ADJ['17'] = ['12','22']\n", + "ADJ['19'] = ['20', '24']\n", + "ADJ['20'] = ['15','19']\n", + "ADJ['21'] = ['22']\n", + "ADJ['22'] = ['17','21','23']\n", + "ADJ['23'] = ['22', '24']\n", + "ADJ['24'] = ['19','23']\n", + "print (\"adj\",ADJ)\n", + "# keep track of visited nodes\n", + "visited = {str(i) : False for i in range(1,26)}\n", + "visited['S'] = False\n", + "visited['G'] = False\n", + "\n", + "def dls(start, goal,limit):\n", + " depth = 0\n", + " \n", + " OPEN=[]\n", + " CLOSED=[]\n", + " OPEN.append(start)\n", + " visited[\"S\"] = True\n", + " while OPEN != []: # Step 2\n", + " if depth<=limit:\n", + " current = OPEN.pop() \n", + " \n", + " if current == goal:\n", + " print(\"Goal Node Found\")\n", + " return True\n", + " else:\n", + " lst = successors(current)\n", + " for i in lst:\n", + " # try to visit a node in future, if not already been to it\n", + " if(not(visited[i])):\n", + " OPEN.append(i)\n", + " \n", + " visited[i] = True\n", + " depth +=1\n", + "\n", + " else:\n", + " print(\"Not found within depth limit\")\n", + " return False\n", + " print(OPEN)\n", + " #print(\"node visited\",i,sep='>',end='\\n')\n", + " return False\n", + "\n", + "def successors(city):\n", + " return ADJ[city]\n", + "\n", + "def test():\n", + " start = 'S'\n", + " goal = 'G'\n", + " limit=int(input(\"ENTER THE DEPTH LIMIT\"))\n", + " print(\"Starting a dls from \\n[ \" + start+\" ]\")\n", + " print(dls(start, goal,limit))\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " test()\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Linear Separability AND.ipynb b/Linear Separability AND.ipynb new file mode 100644 index 0000000..5f5fe2c --- /dev/null +++ b/Linear Separability AND.ipynb @@ -0,0 +1,66 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "x = np.array([0,1,0])\n", + "y = np.array([0,0,1])\n", + "plt.scatter(x,y,c='red')\n", + "plt.scatter(1,1,c=\"blue\")\n", + "plt.xlabel('Input 1')\n", + "plt.ylabel('Input 2')\n", + "w=-1\n", + "b=1.5\n", + "x = np.linspace(0,1.5)\n", + "plt.plot(x,w*x+b,c='black')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Linear Separability OR.ipynb b/Linear Separability OR.ipynb new file mode 100644 index 0000000..1aab974 --- /dev/null +++ b/Linear Separability OR.ipynb @@ -0,0 +1,77 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.array([0,1])\n", + "y = np.array([0,1])\n", + "plt.scatter(x,y,c='red')\n", + "x = np.array([1,0])\n", + "y = np.array([0,1])\n", + "plt.scatter(x,y,c=\"blue\")\n", + "plt.xlabel('Input 1')\n", + "plt.ylabel('Input 2')\n", + "w=-1\n", + "b=1.5\n", + "x = np.linspace(0,1.5)\n", + "plt.plot(x,w*x+b,c='black')\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Madaline Neural Network..ipynb b/Madaline Neural Network..ipynb new file mode 100644 index 0000000..1272840 --- /dev/null +++ b/Madaline Neural Network..ipynb @@ -0,0 +1,119 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter new theta2\n", + "enter new alpha3\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "The final weight matrix is \n", + "[[3]\n", + " [3]]\n", + "The final output is:\n", + "[[ 1.]\n", + " [ 1.]\n", + " [ 1.]\n", + " [-1.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]])\n", + "t=np.array([[1],[1],[1],[-1]])\n", + "w=np.array([[0],[0]])\n", + "b=0\n", + "theta=float(input(\"enter new theta\"))\n", + "alpha=float(input(\"enter new alpha\"))\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " yin=x[i][0]*w[0]+x[i][1]*w[1]\n", + " yin = yin+b\n", + " if(yin>theta):\n", + " y[i] = 1\n", + " elif(yin<=theta and yin>=-theta):\n", + " y[i]=0\n", + " else:\n", + " y[i]=-1\n", + " if (y[i]==t[i]):\n", + " print(\"NO UPDATION REQUIRED\")\n", + " print(y[i])\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " print(\"The value of output is\")\n", + " print(y)\n", + " \n", + " w[0]=w[0]+alpha*x[i][0]*t[i]\n", + " w[1]=w[1]+alpha*x[i][1]*t[i]\n", + " b = b+alpha*t[i]\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " if(y==t).all():\n", + " found=1\n", + "print(\"The final weight matrix is \")\n", + "print(w)\n", + "print(\"The final output is:\")\n", + "print(y)\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/NAND function using MP neuron..ipynb b/NAND function using MP neuron..ipynb new file mode 100644 index 0000000..9ff8f18 --- /dev/null +++ b/NAND function using MP neuron..ipynb @@ -0,0 +1,86 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter the weight 1: -1\n", + "enter the weight 2: -1\n", + "enter the theta:-1\n", + "Input array\n", + "[[0, 0], [0, 1], [1, 0], [1, 1]]\n", + "Actual output\n", + "[1, 1, 1, 0]\n", + "Expected output\n", + "[1, 1, 1, 0]\n", + "assumed weights and theta are correct\n" + ] + } + ], + "source": [ + "\n", + "w1 = int(input(\"enter the weight 1: \"))\n", + "w2 = int(input(\"enter the weight 2: \"))\n", + "theta = int(input(\"enter the theta:\"))\n", + "inputarray = [[0,0],[0,1],[1,0],[1,1]]\n", + "expected = [1,1,1,0]\n", + "actual = []\n", + "for i in range(0,4):\n", + " temp = inputarray[i][0]*w1+inputarray[i][1]*w2\n", + " if(temp >= theta):\n", + " actual.append(1)\n", + " else:\n", + " actual.append(0)\n", + "for i in range(0,4):\n", + " if(expected[i] == actual[i]):\n", + " found = 1\n", + " else:\n", + " found = 0\n", + " break\n", + "print(\"Input array\")\n", + "print(inputarray)\n", + "print(\"Actual output\")\n", + "print(actual)\n", + "print(\"Expected output\")\n", + "print(expected)\n", + "if(found ==1):\n", + " print(\"assumed weights and theta are correct\")\n", + "else:\n", + " print(\"assumed weights and theta are incorrect\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/NOR logic functions using numpy neuron.ipynb b/NOR logic functions using numpy neuron.ipynb new file mode 100644 index 0000000..d3e55df --- /dev/null +++ b/NOR logic functions using numpy neuron.ipynb @@ -0,0 +1,119 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y is initiallised [[0]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[0]\n", + " [0]\n", + " [0]\n", + " [1]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 0\n", + "Enter Weight : -1\n", + "Enter Weight : -1\n", + "Y is initiallised [-2. -1. -1. 0.]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [1.]]\n", + "Expected Target t [[0]\n", + " [0]\n", + " [0]\n", + " [1]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[0.]\n", + " [0.]\n", + " [0.]\n", + " [1.]]\n", + "\n", + "weights : [-1. -1.] \n", + "\n", + "theta : 0\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[0],[0],[0],[1]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(\"Y is initiallised\",yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1 \n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"Calculated y\",y)\n", + " print(\"Expected Target t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/NOT logic functions using numpy neuron..ipynb b/NOT logic functions using numpy neuron..ipynb new file mode 100644 index 0000000..b1f77a1 --- /dev/null +++ b/NOT logic functions using numpy neuron..ipynb @@ -0,0 +1,106 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 0]\n", + "y [[0.]\n", + " [0.]]\n", + "t [[1]\n", + " [0]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 0\n", + "Enter Weight : -1\n", + "[[ 0]\n", + " [-1]]\n", + "y [[1.]\n", + " [0.]]\n", + "t [[1]\n", + " [0]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [0.]]\n", + "\n", + "weights : -1 \n", + "\n", + "theta : 0\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[0],[1]])\n", + "t=np.array([[1],[0]])\n", + "w=np.array([0])\n", + "theta=1\n", + "yin=np.zeros(shape=(2,1))\n", + "y=np.zeros(shape=(2,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(yin)\n", + " while(i<2):\n", + " if (yin[i]>=theta):\n", + " y[i]=1 \n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"y\",y)\n", + " print(\"t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(1)):\n", + " w=int(input(\"Enter Weight : \"))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/OR logic functions using numpy neuron..ipynb b/OR logic functions using numpy neuron..ipynb new file mode 100644 index 0000000..48f79fc --- /dev/null +++ b/OR logic functions using numpy neuron..ipynb @@ -0,0 +1,143 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y is initiallised [[0]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [1]\n", + " [1]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [1]\n", + " [1]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [1]\n", + " [1]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [1]\n", + " [1]\n", + " [0]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 1\n", + "Enter Weight : 1\n", + "Enter Weight : 1\n", + "Y is initiallised [2. 1. 1. 0.]\n", + "Calculated y [[1.]\n", + " [1.]\n", + " [1.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [1]\n", + " [1]\n", + " [0]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [1.]\n", + " [1.]\n", + " [0.]]\n", + "\n", + "weights : [1. 1.] \n", + "\n", + "theta : 1\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[1],[1],[1],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(\"Y is initiallised\",yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1 \n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"Calculated y\",y)\n", + " print(\"Expected Target t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Single layer perceptron ANDNOT.ipynb b/Single layer perceptron ANDNOT.ipynb new file mode 100644 index 0000000..202404b --- /dev/null +++ b/Single layer perceptron ANDNOT.ipynb @@ -0,0 +1,129 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter new theta:0.2\n", + "Enter new alpha:1\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[ 0.]\n", + " [-1.]\n", + " [ 0.]\n", + " [ 0.]]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[ 0.]\n", + " [-1.]\n", + " [-1.]\n", + " [ 1.]]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "The final weight matrix is \n", + "[[ 1]\n", + " [-1]]\n", + "The final output is:\n", + "[[-1.]\n", + " [ 1.]\n", + " [-1.]\n", + " [-1.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]])\n", + "t=np.array([[-1],[1],[-1],[-1]])\n", + "w=np.array([[0],[0]])\n", + "b=0\n", + "theta=float(input(\"Enter new theta:\"))\n", + "alpha=float(input(\"Enter new alpha:\"))\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " yin=x[i][0]*w[0]+x[i][1]*w[1]\n", + " yin = yin+b\n", + " if(yin>theta):\n", + " y[i] = 1\n", + " elif(yin<=theta and yin>=-theta):\n", + " y[i]=0\n", + " else:\n", + " y[i]=-1\n", + " if (y[i]==t[i]):\n", + " print(\"NO UPDATION REQUIRED\")\n", + " print(y[i])\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " print(\"The value of output is\")\n", + " print(y)\n", + " w[0]=w[0]+alpha*x[i][0]*t[i]\n", + " w[1]=w[1]+alpha*x[i][1]*t[i]\n", + " b = b+alpha*t[i]\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " if(y==t).all():\n", + " found=1\n", + "print(\"The final weight matrix is \")\n", + "print(w)\n", + "print(\"The final output is:\")\n", + "print(y)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/single layer perceptron for AND function.ipynb b/single layer perceptron for AND function.ipynb new file mode 100644 index 0000000..6d6cab0 --- /dev/null +++ b/single layer perceptron for AND function.ipynb @@ -0,0 +1,115 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter new theta:0.2\n", + "Enter new alpha:1\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "The final weight matrix is:\n", + "[[1]\n", + " [1]]\n", + "The final output is:\n", + "[[ 1.]\n", + " [ 1.]\n", + " [ 1.]\n", + " [-1.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]])\n", + "t=np.array([[1],[1],[1],[-1]])\n", + "w=np.array([[0],[0]])\n", + "b=0\n", + "theta=float(input(\"Enter new theta:\"))\n", + "alpha=float(input(\"Enter new alpha:\"))\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " yin=x[i][0]*w[0]+x[i][1]*w[1]\n", + " yin = yin+b\n", + " if(yin>theta):\n", + " y[i] = 1\n", + " elif(yin<=theta and yin>=-theta):\n", + " y[i]=0\n", + " else:\n", + " y[i]=-1\n", + " if (y[i]==t[i]):\n", + " print(\"NO UPDATION REQUIRED\")\n", + " print(y[i])\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " print(\"The value of output is\")\n", + " print(y)\n", + " w[0]=w[0]+alpha*x[i][0]*t[i]\n", + " w[1]=w[1]+alpha*x[i][1]*t[i]\n", + " b = b+alpha*t[i]\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " if(y==t).all(): \n", + " found=1\n", + "print(\"The final weight matrix is:\")\n", + "print(w)\n", + "print(\"The final output is:\")\n", + "print(y)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}