Merge branch 'master' into NinaM31

Author: ronny-udacity

.github/workflows/manual.yml

@@ -0,0 +1,46 @@
+# Workflow to ensure whenever a Github PR is submitted, 
+# a JIRA ticket gets created automatically. 
+name: Manual Workflow
+
+# Controls when the action will run. 
+on:
+  # Triggers the workflow on pull request events but only for the master branch
+  pull_request_target:
+    types: [assigned, opened, reopened]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  test-transition-issue:
+    name: Convert Github Issue to Jira Issue
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@master
+
+    - name: Login
+      uses: atlassian/gajira-login@master
+      env:
+        JIRA_BASE_URL: ${{ secrets.JIRA_BASE_URL }}
+        JIRA_USER_EMAIL: ${{ secrets.JIRA_USER_EMAIL }}
+        JIRA_API_TOKEN: ${{ secrets.JIRA_API_TOKEN }}
+        
+    - name: Create NEW JIRA ticket
+      id: create
+      uses: atlassian/gajira-create@master
+      with:
+        project: CONUPDATE
+        issuetype: Task
+        summary: |
+          Github PR - nd101	v7	Deep Learning | Repo: ${{ github.repository }}  | PR# ${{github.event.number}}
+        description: |
+           Repo link: https://github.com/${{ github.repository }}   
+           PR no. ${{ github.event.pull_request.number }} 
+           PR title: ${{ github.event.pull_request.title }}  
+           PR description: ${{ github.event.pull_request.description }}  
+           In addition, please resolve other issues, if any. 
+        fields: '{"components": [{"name":"Github PR"}], "customfield_16449":"https://classroom.udacity.com/nanodegrees/nd101/dashboard/overview", "customfield_16450":"Resolve the PR", "labels": ["github"]}'
+
+    - name: Log created issue
+      run: echo "Issue ${{ steps.create.outputs.issue }} was created"

.gitignore

@@ -1 +1,2 @@
 .ipynb_checkpoints
+.github/**

README.md

@@ -1,6 +1,6 @@
-# Deep Learning (PyTorch)
+# Deep Learning (PyTorch) - ND101 v7
 
-This repository contains material related to Udacity's [Deep Learning Nanodegree program](https://www.udacity.com/course/deep-learning-nanodegree--nd101). It consists of a bunch of tutorial notebooks for various deep learning topics. In most cases, the notebooks lead you through implementing models such as convolutional networks, recurrent networks, and GANs. There are other topics covered such as weight initialization and batch normalization.
+This repository contains material related to Udacity's [Deep Learning v7 Nanodegree program](https://www.udacity.com/course/deep-learning-nanodegree--nd101). It consists of a bunch of tutorial notebooks for various deep learning topics. In most cases, the notebooks lead you through implementing models such as convolutional networks, recurrent networks, and GANs. There are other topics covered such as weight initialization and batch normalization.
 
 There are also notebooks used as projects for the Nanodegree program. In the program itself, the projects are reviewed by real people (Udacity reviewers), but the starting code is available here, as well.
 

intro-to-pytorch/Part 1 - Tensors in PyTorch (Exercises).ipynb

@@ -60,7 +60,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -70,7 +70,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -86,14 +86,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "### Generate some data\n",
     "torch.manual_seed(7) # Set the random seed so things are predictable\n",
     "\n",
-    "# Features are 5 random normal variables\n",
+    "# Features are 3 random normal variables\n",
     "features = torch.randn((1, 5))\n",
     "# True weights for our data, random normal variables again\n",
     "weights = torch.randn_like(features)\n",
@@ -119,22 +119,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 74,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": "tensor([[0.1595]])"
-     },
-     "metadata": {},
-     "execution_count": 74
-    }
-   ],
+   "outputs": [],
    "source": [
-    "## Calculate the output of this network using the weights and bias tensors\n",
-    "output = activation(torch.sum(features*weights) + bias)\n",
-    "output"
+    "## Calculate the output of this network using the weights and bias tensors"
    ]
   },
   {
@@ -156,42 +145,28 @@
     "RuntimeError: size mismatch, m1: [1 x 5], m2: [1 x 5] at /Users/soumith/minicondabuild3/conda-bld/pytorch_1524590658547/work/aten/src/TH/generic/THTensorMath.c:2033\n",
     "```\n",
     "\n",
-    "As you're building neural networks in any framework, you'll see this often. Really often. What's happening here is our tensors aren't the correct shapes to perform a matrix multiplication. Remember that for matrix multiplications, the number of columns in the first tensor must equal to the number of rows in the second tensor. Both `features` and `weights` have the same shape, `(1, 5)`. This means we need to change the shape of `weights` to get the matrix multiplication to work.\n",
+    "As you're building neural networks in any framework, you'll see this often. Really often. What's happening here is our tensors aren't the correct shapes to perform a matrix multiplication. Remember that for matrix multiplications, the number of columns in the first tensor must equal to the number of rows in the second column. Both `features` and `weights` have the same shape, `(1, 5)`. This means we need to change the shape of `weights` to get the matrix multiplication to work.\n",
     "\n",
     "**Note:** To see the shape of a tensor called `tensor`, use `tensor.shape`. If you're building neural networks, you'll be using this method often.\n",
     "\n",
-    "There are a few options here: [`weights.reshape()`](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.reshape), [`weights.resize_()`](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.resize_), [`weights.view()`](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.view) and [`torch.transpose(weights,0,1)`](https://pytorch.org/docs/master/generated/torch.transpose.html).\n",
+    "There are a few options here: [`weights.reshape()`](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.reshape), [`weights.resize_()`](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.resize_), and [`weights.view()`](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.view).\n",
     "\n",
     "* `weights.reshape(a, b)` will return a new tensor with the same data as `weights` with size `(a, b)` sometimes, and sometimes a clone, as in it copies the data to another part of memory.\n",
     "* `weights.resize_(a, b)` returns the same tensor with a different shape. However, if the new shape results in fewer elements than the original tensor, some elements will be removed from the tensor (but not from memory). If the new shape results in more elements than the original tensor, new elements will be uninitialized in memory. Here I should note that the underscore at the end of the method denotes that this method is performed **in-place**. Here is a great forum thread to [read more about in-place operations](https://discuss.pytorch.org/t/what-is-in-place-operation/16244) in PyTorch.\n",
     "* `weights.view(a, b)` will return a new tensor with the same data as `weights` with size `(a, b)`.\n",
-    "* `torch.transpose(weights,0,1)` will return transposed weights tensor. This returns transposed version of inpjut tensor along dim 0 and dim 1. This is efficient since we do not specify to actual dimesions of weights.\n",
     "\n",
     "I usually use `.view()`, but any of the three methods will work for this. So, now we can reshape `weights` to have five rows and one column with something like `weights.view(5, 1)`.\n",
     "\n",
-    "One more approach is to use `.t()` to transpose vector of weights, in our case from (1,5) to (5,1) shape.\n",
-    
     "> **Exercise**: Calculate the output of our little network using matrix multiplication."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": "tensor([[0.1595]])"
-     },
-     "metadata": {},
-     "execution_count": 75
-    }
-   ],
+   "outputs": [],
    "source": [
-    "## Calculate the output of this network using matrix multiplication\n",
-    "output = activation(torch.matmul(features,torch.transpose(weights,0,1)) + bias)\n",
-    "output"
+    "## Calculate the output of this network using matrix multiplication"
    ]
   },
   {
@@ -229,7 +204,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 76,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -263,23 +238,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 77,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": "tensor([[0.3171]])"
-     },
-     "metadata": {},
-     "execution_count": 77
-    }
-   ],
+   "outputs": [],
    "source": [
-    "## Your solution here\n",
-    "h = activation(torch.matmul(features,W1).add_(B1))\n",
-    "output = activation(torch.matmul(h,W2).add_(B2))\n",
-    "output"
+    "## Your solution here"
    ]
   },
   {
@@ -288,7 +251,7 @@
    "source": [
     "If you did this correctly, you should see the output `tensor([[ 0.3171]])`.\n",
     "\n",
-    "The number of hidden units are a parameter of the network, often called a **hyperparameter** to differentiate it from the weights and biases parameters. As you'll see later when we discuss training a neural network, the more hidden units a network has, and the more layers, the better able it is to learn from data and make accurate predictions."
+    "The number of hidden units a parameter of the network, often called a **hyperparameter** to differentiate it from the weights and biases parameters. As you'll see later when we discuss training a neural network, the more hidden units a network has, and the more layers, the better able it is to learn from data and make accurate predictions."
    ]
   },
   {
@@ -302,18 +265,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 78,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": "array([[0.01999898, 0.8199435 , 0.49156905],\n       [0.41055049, 0.77689295, 0.34885976],\n       [0.18349863, 0.75363566, 0.92894509],\n       [0.55251871, 0.60749635, 0.21301188]])"
-     },
-     "metadata": {},
-     "execution_count": 78
-    }
-   ],
+   "outputs": [],
    "source": [
     "import numpy as np\n",
     "np.set_printoptions(precision=8)\n",
@@ -323,18 +277,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 79,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": "tensor([[0.0200, 0.8199, 0.4916],\n        [0.4106, 0.7769, 0.3489],\n        [0.1835, 0.7536, 0.9289],\n        [0.5525, 0.6075, 0.2130]], dtype=torch.float64)"
-     },
-     "metadata": {},
-     "execution_count": 79
-    }
-   ],
+   "outputs": [],
    "source": [
     "torch.set_printoptions(precision=8)\n",
     "b = torch.from_numpy(a)\n",
@@ -343,18 +288,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 80,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": "array([[0.01999898, 0.8199435 , 0.49156905],\n       [0.41055049, 0.77689295, 0.34885976],\n       [0.18349863, 0.75363566, 0.92894509],\n       [0.55251871, 0.60749635, 0.21301188]])"
-     },
-     "metadata": {},
-     "execution_count": 80
-    }
-   ],
+   "outputs": [],
    "source": [
     "b.numpy()"
    ]
@@ -368,37 +304,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 81,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": "tensor([[0.0400, 1.6399, 0.9831],\n        [0.8211, 1.5538, 0.6977],\n        [0.3670, 1.5073, 1.8579],\n        [1.1050, 1.2150, 0.4260]], dtype=torch.float64)"
-     },
-     "metadata": {},
-     "execution_count": 81
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Multiply PyTorch Tensor by 2, in place\n",
     "b.mul_(2)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 82,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": "array([[0.03999795, 1.639887  , 0.9831381 ],\n       [0.82110098, 1.55378589, 0.69771953],\n       [0.36699725, 1.50727133, 1.85789017],\n       [1.10503742, 1.2149927 , 0.42602377]])"
-     },
-     "metadata": {},
-     "execution_count": 82
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Numpy array matches new values from Tensor\n",
     "a"
@@ -407,9 +325,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.7.7 64-bit ('envTorch': conda)",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "python37764bitenvtorchcondaf1e8697b5c364e0493551efccbc5e8bb"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -421,7 +339,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.7-final"
+   "version": "3.6.6"
   }
  },
  "nbformat": 4,

sentiment-analysis-network/Sentiment_Classification_Projects.ipynb

@@ -321,7 +321,7 @@
     "\n",
     "Ok, the ratios tell us which words are used more often in postive or negative reviews, but the specific values we've calculated are a bit difficult to work with. A very positive word like \"amazing\" has a value above 4, whereas a very negative word like \"terrible\" has a value around 0.18. Those values aren't easy to compare for a couple of reasons:\n",
     "\n",
-    "* Right now, 1 is considered neutral, but the absolute value of the postive-to-negative rations of very postive words is larger than the absolute value of the ratios for the very negative words. So there is no way to directly compare two numbers and see if one word conveys the same magnitude of positive sentiment as another word conveys negative sentiment. So we should center all the values around netural so the absolute value fro neutral of the postive-to-negative ratio for a word would indicate how much sentiment (positive or negative) that word conveys.\n",
+    "* Right now, 1 is considered neutral, but the absolute value of the positive-to-negative ratios of very positive words is larger than the absolute value of the ratios for the very negative words. So there is no way to directly compare two numbers and see if one word conveys the same magnitude of positive sentiment as another word conveys negative sentiment. So we should center all the values around netural so the absolute value fro neutral of the postive-to-negative ratio for a word would indicate how much sentiment (positive or negative) that word conveys.\n",
     "* When comparing absolute values it's easier to do that around zero than one. \n",
     "\n",
     "To fix these issues, we'll convert all of our ratios to new values using logarithms.\n",