t81_558_class_01_1_overview.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_01_1_overview.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# T81-558: Applications of Deep Neural Networks\n",
    "**Module 1: Python Preliminaries**\n",
    "* Instructor: [Jeff Heaton](https://sites.wustl.edu/jeffheaton/), McKelvey School of Engineering, [Washington University in St. Louis](https://engineering.wustl.edu/Programs/Pages/default.aspx)\n",
    "* For more information visit the [class website](https://sites.wustl.edu/jeffheaton/t81-558/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 1 Material\n",
    "\n",
    "* **Part 1.1: Course Overview** [[Video]](https://www.youtube.com/watch?v=taxS7a-goNs&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_01_1_overview.ipynb)\n",
    "* Part 1.2: Introduction to Python [[Video]](https://www.youtube.com/watch?v=czq5d53vKvo&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_01_2_intro_python.ipynb)\n",
    "* Part 1.3: Python Lists, Dictionaries, Sets and JSON [[Video]](https://www.youtube.com/watch?v=kcGx2I5akSs&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_01_3_python_collections.ipynb)\n",
    "* Part 1.4: File Handling [[Video]](https://www.youtube.com/watch?v=FSuSLCMgCZc&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_01_4_python_files.ipynb)\n",
    "* Part 1.5: Functions, Lambdas, and Map/Reduce [[Video]](https://www.youtube.com/watch?v=jQH1ZCSj6Ng&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_01_5_python_functional.ipynb)\n",
    "\n",
    "Watch one (or more) of these depending on how you want to setup your Python TensorFlow environment:\n",
    "* [How to Submit a Module Assignment locally](https://www.youtube.com/watch?v=hmCGjCVhYNc)\n",
    "* [How to Use Google CoLab and Submit Assignment](https://www.youtube.com/watch?v=Pt-Od-oBgOM)\n",
    "* [Installing TensorFlow, Keras, and Python in Windows CPU](https://www.youtube.com/watch?v=RgO8BBNGB8w&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN)\n",
    "* [Installing TensorFlow, Keras, and Python in Mac](https://www.youtube.com/watch?v=MpUvdLD932c&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN)\n",
    "* [Installing TensorFlow, Keras, and Python in Windows GPU, warning, somewhat complex](https://www.youtube.com/watch?v=qrkEYf-YDyI&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Google CoLab Instructions\n",
    "\n",
    "The following code ensures that Google CoLab is running the correct version of TensorFlow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: not using Google CoLab\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    from google.colab import drive\n",
    "    %tensorflow_version 2.x\n",
    "    COLAB = True\n",
    "    print(\"Note: using Google CoLab\")\n",
    "except:\n",
    "    print(\"Note: not using Google CoLab\")\n",
    "    COLAB = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1.1: Course Overview\n",
    "\n",
    "Deep learning is a group of exciting new technologies for neural networks. [[Cite:lecun2015deep]](https://www.nature.com/articles/nature14539) By using a combination of advanced training techniques neural network architectural components, it is now possible to train neural networks of much greater complexity. This course introduces the student to deep belief neural networks, regularization units (ReLU), convolution neural networks, and recurrent neural networks. High-performance computing (HPC) aspects demonstrate how deep learning can be leveraged both on graphical processing units (GPUs), as well as grids. Deep learning allows a model to learn hierarchies of information in a way that is similar to the function of the human brain. The focus is primarily upon the application of deep learning, with some introduction to the mathematical foundations of deep learning. Students make use of the Python programming language to architect a deep learning model for several real-world data sets and interpret the results of these networks. [[Cite:goodfellow2016deep]](https://www.deeplearningbook.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignments\n",
    "\n",
    "Your grade is calculated according to the following assignments:\n",
    "\n",
    "Assignment          |Weight|Description\n",
    "--------------------|------|-------\n",
    "Ice Breaker         |    5%|Post a short get to know you discussion topic (individual)\n",
    "Group Selection     |    5%|Choose groups for Kaggle final projects\n",
    "Class Assignments   |   50%|10 small programming assignments (5% each, individual)\n",
    "Kaggle Project      |   20%|\"Kaggle In-Class\" competition (team)\n",
    "Final Project       |   20%|Deep Learning Implementation Report (team)\n",
    "\n",
    "The 10 class assignments correspond with each of the first 10 modules.  Generally, each module assignment is due just before the following module date.  Refer to the syllabus for exact due dates.  The 10 class assignments are submitted using the Python submission script.  Refer to assignment 1 for details.\n",
    "\n",
    "The Kaggle and Final Projects are completed in teams.  The same teams will complete each of these.\n",
    "\n",
    "* **Module 1 Assignment**: [How to Submit an Assignment](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class1.ipynb)\n",
    "* **Module 2 Assignment**: [Creating Columns in Pandas](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class2.ipynb)\n",
    "* **Module 3 Assignment**: [Data Preparation in Pandas](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class3.ipynb)\n",
    "* **Module 4 Assignment**: [Classification and Regression Neural Networks](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class4.ipynb)\n",
    "* **Module 5 Assignment**: [Predict Home Price](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class5.ipynb)\n",
    "* **Module 6 Assignment**: [Image Processing](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class6.ipynb)\n",
    "* **Module 7 Assignment**: [Computer Vision](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class7.ipynb)\n",
    "* **Module 8 Assignment**: [Feature Engineering](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class8.ipynb)\n",
    "* **Module 9 Assignment**: [Transfer Learning](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class9.ipynb)\n",
    "* **Module 10 Assignment**: [Time Series Neural Network](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class10.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Your Instructor: Jeff Heaton\n",
    "\n",
    "Jeff Heaton, pictured in Figure 1.JH is the author of this book and developer of this course. A brief summary of his credentials is given here:\n",
    "\n",
    "* Master of Information Management (MIM), Washington University in St. Louis, MO\n",
    "* PhD in Computer Science, Nova Southeastern University in Ft. Lauderdale, FL\n",
    "* [Vice President and Data Scientist](http://www.rgare.com/knowledge-center/media/articles/rga-where-logic-meets-curiosity), Reinsurance Group of America (RGA)\n",
    "* Senior Member, IEEE\n",
    "* jtheaton at domain name of this university\n",
    "* Other industry certifications: FLMI, ARA, ACS\n",
    "\n",
    "Social media:\n",
    "\n",
    "* [Homepage](http://www.heatonresearch.com) - My home page.  Includes my research interests and publications.\n",
    "* [YouTube Channel](https://www.youtube.com/user/HeatonResearch) - My YouTube Channel.  Subscribe for my videos on AI and updates to this class.\n",
    "* [Discord Server](https://discord.gg/3bjthYv) - To discuss this class and AI topics.\n",
    "* [GitHub](https://github.com/jeffheaton) - My GitHub repositories.\n",
    "* [LinkedIn](https://www.linkedin.com/in/jeffheaton) - My Linked In profile.\n",
    "* [Twitter](https://twitter.com/jeffheaton) - My Twitter feed.\n",
    "* [Google Scholar](https://scholar.google.com/citations?user=1jPGeg4AAAAJ&hl=en) - My citations on Google Scholar.\n",
    "* [Research Gate](https://www.researchgate.net/profile/Jeff_Heaton) - My profile/research at Research Gate.\n",
    "* [Orcid](https://orcid.org/0000-0003-1496-4049)\n",
    "* [Others](http://www.heatonresearch.com/about/) - About me and other social media sites that I am a member of.\n",
    "\n",
    "**Figure 1.JH: Jeff Heaton Recording a Video**\n",
    "![Jeff Heaton at WUSTL Video Studio](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/about-jeff-heaton-2020.jpg \"Jeff Heaton\")\n",
    "\n",
    "My PhD dissertation explored new methods for feature engineering in deep learning. [[Cite:heaton2017automated]](https://nsuworks.nova.edu/gscis_etd/994/) I also created the Encog Machine Learning Framework in Java and C#. [[Cite:heaton2015encog]](https://arxiv.org/pdf/1506.04776.pdf) I've also conducted research on artificial life [[Cite:heaton2019evolving]](https://link.springer.com/article/10.1007/s10710-018-9336-1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Course Resources\n",
    "\n",
    "* [Google CoLab](https://colab.research.google.com/) - Free web-based platform that includes Python, Juypter Notebooks, and TensorFlow [[Cite:GoogleTensorFlow]](http://download.tensorflow.org/paper/whitepaper2015.pdf).  No setup needed.\n",
    "* [Python Anaconda](https://www.continuum.io/downloads) - Python distribution that includes many data science packages, such as Numpy, Scipy, Scikit-Learn, Pandas, and much more.\n",
    "* [Juypter Notebooks](http://jupyter.org/) - Easy to use environment that combines Python, Graphics and Text. \n",
    "* [TensorFlow](https://www.tensorflow.org/) - Google's mathematics package for deep learning.\n",
    "* [Kaggle](https://www.kaggle.com/) - Competitive data science.  Good source of sample data.\n",
    "* [Course GitHub Repository](https://github.com/jeffheaton/t81_558_deep_learning) - All of the course notebooks will be published here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is Deep Learning\n",
    "\n",
    "The focus of this class is deep learning, which is a prevalent type of machine learning that builds upon the original neural networks popularized in the 1980s. There is very little difference between how a deep neural network is calculated compared with the first neural network.  We've always been able to create and calculate deep neural networks.  A deep neural network is nothing more than a neural network with many layers.  While we've always been able to create/calculate deep neural networks, we've lacked an effective means of training them.  Deep learning provides an efficient means to train deep neural networks.\n",
    "\n",
    "## What is Machine Learning\n",
    "\n",
    "If deep learning is a type of machine learning, this begs the question, \"What is machine learning?\"  Figure 1.ML-DEV  illustrates how machine learning differs from traditional software development.\n",
    "\n",
    "**Figure 1.ML-DEV: ML vs Traditional Software Development**\n",
    "![ML vs Traditional Software Development](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_1_ml_vs_trad.png \"Machine Learning vs Traditional Software Development\")\n",
    "\n",
    "* **Traditional Software Development** - Programmers create programs that specify how to transform input into the desired output.\n",
    "* **Machine Learning** - Programmers create models that can learn to produce the desired output for given input. This learning fills the traditional role of the computer program. \n",
    "\n",
    "Researchers have applied machine learning to many different areas.  This class explores three specific domains for the application of deep neural networks, as illustrated in Figure 1.ML-DOM.\n",
    "\n",
    "**Figure 1.ML-DOM: Application of Machine Learning**\n",
    "![Application of Machine Learning](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_1_ml_types.png \"Application of Machine Learning\")\n",
    "\n",
    "* **Predictive Modeling** - Several named input values allow the neural network to predict another named value that becomes the output.  For example, using four measurements of iris flowers to predict the species.  This type of data is often called tabular data.\n",
    "* **Computer Vision** - The use of machine learning to detect patterns in visual data.  For example, is an image a picture of a cat or a dog.\n",
    "* **Time Series** - The use of machine learning to detect patterns in time. Typical applications of time series are financial applications, speech recognition, and even natural language processing (NLP). \n",
    "\n",
    "### Regression\n",
    "\n",
    "Regression is when a model, such as a neural network, accepts input, and produces a numeric output.  Consider if you must to write a program that predicted how many miles per gallon (MPG) a car could achieve.  For the inputs, you would probably want such features as the weight of the car, the horsepower, how large the engine is, and other values.  Your program would be a combination of math and if-statements.  \n",
    "\n",
    "Machine learning lets the computer learn the \"formula\" for calculating the MPG of a car, using data.  Consider [this](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/data/auto-mpg.csv) dataset.  We can use regression machine learning models to study this data and learn how to predict the MPG for a car. \n",
    "\n",
    "### Classification\n",
    "\n",
    "The output of a classification model is what class the input most closely resembles.  For example, consider using four measurements of an iris flower to determine the likely species that the flower.  The [iris dataset](https://data.heatonresearch.com/data/t81-558/iris.csv) is a typical dataset for machine learning examples. \n",
    "\n",
    "### Beyond Classification and Regression\n",
    "\n",
    "One of the most potent aspects of neural networks is that a neural network can be both regression and classification at the same time.  The output from a neural network could be any number of the following:\n",
    "\n",
    "* An image\n",
    "* A series of numbers that could be interpreted as text, audio, or another time series\n",
    "* A regression number\n",
    "* A classification class\n",
    "\n",
    "## What are Neural Networks\n",
    "\n",
    "Neural networks are one of the earliest examples of a machine learning model.  Neural networks were initially introduced in the 1940s and have risen and fallen several times from popularity. The current generation of deep learning begain in 2006 with an improved training algorithm by Geoffrey Hinton. [[Cite:hinton2006fast]](https://www.mitpressjournals.org/doi/abs/10.1162/neco.2006.18.7.1527) This technique finally allowed neural networks with many layers (deep neural networks) to be efficiently trained. Four researchers have contributed significantly to the development of neural networks.  They have consistently pushed neural network research, both through the ups and downs.  These four luminaries are shown in Figure 1.LUM.\n",
    "\n",
    "**Figure 1.LUM: Neural Network Luminaries**\n",
    "![Neural Network Luminaries](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_1_luminaries_ann.jpg \"Neural Network Luminaries\")\n",
    "\n",
    "The current luminaries of artificial neural network (ANN) research and ultimately deep learning, in order as appearing in the above picture:\n",
    "\n",
    "* [Yann LeCun](http://yann.lecun.com/), Facebook and New York University - Optical character recognition and computer vision using convolutional neural networks (CNN).  The founding father of convolutional nets.\n",
    "* [Geoffrey Hinton](http://www.cs.toronto.edu/~hinton/), Google and University of Toronto. Extensive work on neural networks. Creator of deep learning and early adapter/creator of backpropagation for neural networks.\n",
    "* [Yoshua Bengio](http://www.iro.umontreal.ca/~bengioy/yoshua_en/index.html), University of Montreal. Extensive research into deep learning, neural networks, and machine learning.  He has so far remained entirely in academia.\n",
    "* [Andrew Ng](http://www.andrewng.org/), Badiu and Stanford University.  Extensive research into deep learning, neural networks, and application to robotics.\n",
    "\n",
    "Geoffrey Hinton, Yann LeCun, and Yoshua Bengio won the [Turing Award](https://www.acm.org/media-center/2019/march/turing-award-2018) for their contributions to deep learning.\n",
    "\n",
    "## Why Deep Learning?\n",
    "\n",
    "For predictive modeling, neural networks are not that different than other models, such as:\n",
    "\n",
    "* Support Vector Machines\n",
    "* Random Forests\n",
    "* Gradient Boosted Machines\n",
    "\n",
    "Like these other models, neural networks can perform both **classification** and **regression**.  When applied to relatively low-dimensional predictive modeling tasks, deep neural networks do not necessarily add significant accuracy over other model types.  Andrew Ng describes the advantage of deep neural networks over traditional model types as illustrated by Figure 1.DL-VS.\n",
    "\n",
    "**Figure 1.DL-VS: Why Deep Learning?**\n",
    "![Why Deep Learning?](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_1_why_deep.png \"Why Deep Learning\")\n",
    "\n",
    "Neural networks also have two additional significant advantages over other machine learning models:\n",
    "\n",
    "* **Convolutional Neural Networks** - Can scan an image for patterns within the image.\n",
    "* **Recurrent Neural Networks** - Can find patterns across several inputs, not just within a single input.\n",
    "\n",
    "Neural networks are also very flexible in the types of data that are compatible with the input and output layers.  A neural network can take tabular data, images, audio sequences, time series tabular data, and text as its input or output.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python for Deep Learning\n",
    "\n",
    "Python 3.x is the programming language that will be used for this class.  Python, as a programming language, has the widest support for deep learning.  The three most popular frameworks for deep learning in Python are:\n",
    "\n",
    "* [TensorFlow](https://www.tensorflow.org/) (Google)\n",
    "* [MXNet](https://github.com/dmlc/mxnet) (Amazon)\n",
    "* [CNTK](https://cntk.ai/) (Microsoft) \n",
    "\n",
    "Some references on popular programming languages for AI/Data Science:\n",
    "\n",
    "* [Popular Programming Languages for AI](https://en.wikipedia.org/wiki/List_of_programming_languages_for_artificial_intelligence)\n",
    "* [Popular Programming Languages for Data Science](http://www.kdnuggets.com/2014/08/four-main-languages-analytics-data-mining-data-science.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Software Installation\n",
    "This class is technically oriented.  A successful student needs to be able to compile and execute Python code that makes use of TensorFlow for deep learning. There are two options for you to accomplish this:\n",
    "\n",
    "* Install Python, TensorFlow and some IDE (Jupyter, TensorFlow, and others)\n",
    "* Use Google CoLab in the cloud\n",
    "\n",
    "Near the top of this document, there are links to videos that describe how to use Google CoLab. There are also videos explaining how to install Python on your local computer.  The following sections take you through the process of installing Python on your local computer.  This process is essentially the same on Windows, Linux, or Mac.  For specific OS instructions, refer to one of the tutorial YouTube videos earlier in this document.\n",
    "\n",
    "To install Python on your computer complete the following instructions:\n",
    "\n",
    "* [Installing Python and TensorFlow](./install/tensorflow-install-jul-2020.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Introduction\n",
    "\n",
    "\n",
    "* [Anaconda v3.6](https://www.continuum.io/downloads) Scientific Python Distribution, including: [Scikit-Learn](http://scikit-learn.org/), [Pandas](http://pandas.pydata.org/), and others: csv, json, numpy, scipy\n",
    "* [Jupyter Notebooks](http://jupyter.readthedocs.io/en/latest/install.html)\n",
    "* [PyCharm IDE](https://www.jetbrains.com/pycharm/)\n",
    "* [Cx_Oracle](http://cx-oracle.sourceforge.net/)\n",
    "* [MatPlotLib](http://matplotlib.org/)\n",
    "\n",
    "## Jupyter Notebooks\n",
    "\n",
    "Space matters in Python, indent code to define blocks\n",
    "\n",
    "Jupyter Notebooks Allow Python and Markdown to coexist.\n",
    "\n",
    "Even LaTeX math:\n",
    "\n",
    "$ f'(x) = \\lim_{h\\to0} \\frac{f(x+h) - f(x)}{h}. $\n",
    "\n",
    "## Python Versions\n",
    "\n",
    "* If you see `xrange` instead of `range`, you are dealing with Python 2\n",
    "* If you see `print x` instead of `print(x)`, you are dealing with Python 2 \n",
    "* This class uses Python 3.6!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor Flow Version: 2.1.0\n",
      "Keras Version: 2.2.4-tf\n",
      "\n",
      "Python 3.7.7 (default, May  6 2020, 11:45:54) [MSC v.1916 64 bit (AMD64)]\n",
      "Pandas 1.0.5\n",
      "Scikit-Learn 0.23.1\n",
      "WARNING:tensorflow:From <ipython-input-2-796d1d9091ed>:15: is_gpu_available (from tensorflow.python.framework.test_util) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.config.list_physical_devices('GPU')` instead.\n",
      "GPU is available\n"
     ]
    }
   ],
   "source": [
    "# What version of Python do you have?\n",
    "import sys\n",
    "\n",
    "import tensorflow.keras\n",
    "import pandas as pd\n",
    "import sklearn as sk\n",
    "import tensorflow as tf\n",
    "\n",
    "print(f\"Tensor Flow Version: {tf.__version__}\")\n",
    "print(f\"Keras Version: {tensorflow.keras.__version__}\")\n",
    "print()\n",
    "print(f\"Python {sys.version}\")\n",
    "print(f\"Pandas {pd.__version__}\")\n",
    "print(f\"Scikit-Learn {sk.__version__}\")\n",
    "print(\"GPU is\", \"available\" if tf.test.is_gpu_available() \\\n",
    "      else \"NOT AVAILABLE\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Software used in this class:\n",
    "    \n",
    "* **Python** - The programming language.\n",
    "* **TensorFlow** - Googles deep learning framework, must have the version specified above. \n",
    "* **Keras** - [Keras](https://github.com/fchollet/keras) is a high-level neural networks API, written in Python and capable of running on top of TensorFlow, CNTK, or Theano. [[Cite:franccois2017deep]](https://www.manning.com/books/deep-learning-with-python)\n",
    "* **Pandas** - Allows for data preprocessing.  Tutorial [here](http://pandas.pydata.org/pandas-docs/version/0.18.1/tutorials.html)\n",
    "* **Scikit-Learn** - Machine learning framework for Python.  Tutorial [here](http://scikit-learn.org/stable/tutorial/basic/tutorial.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 1 Assignment\n",
    "\n",
    "You can find the first assignment here: [assignment 1](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class1.ipynb)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3.6 (tensorflow)",
   "language": "python",
   "name": "tensorflow"
  },
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}