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. 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignments\n",
    "\n",
    "Your grade is calculated according to the following assignments:\n",
    "\n",
    "Assignment          |Weight|Description\n",
    "--------------------|------|-------\n",
    "Class Participation |   10%|Class attendance and participation (individual)\n",
    "Class Assignments   |   50%|10 small programming assignments (5% each, individual)\n",
    "Kaggle Project      |   20%|\"Kaggle In-Class\" project submitted through Kaggle (Kaggle Team, up to 5 people)\n",
    "Final Project       |   20%|Deep Learning Implementation Report (Same Kaggle 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",
    "* 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: [K-Fold Cross-Validation](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: [Building a Kaggle Submission File](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class8.ipynb)\n",
    "* Module 9 Assignment: [Counting Items in a YOLO Image](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 at WUSTL Video Studio](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/jheaton1.png \"Jeff Heaton\")\n",
    "\n",
    "I will be your instructor for this course.  A brief summary of my 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",
    "* [GitHub](https://github.com/jeffheaton) - My GitHub repositories.\n",
    "* [Linked In](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",
    "* [Others](http://www.heatonresearch.com/about/) - About me and other social media sites that I am a member of."
   ]
  },
  {
   "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?\"  The following diagram illustrates how machine learning differs from traditional software development.\n",
    "\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:\n",
    "\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://github.com/jeffheaton/t81_558_deep_learning/blob/master/data/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. Four researchers have contributed significantly to the development of neural networks.  They have consistently pushed neural network research, both through the ups and downs: \n",
    "\n",
    "![Neural Network Luminaries](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_1_luminaries_ann.png \"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 follows:\n",
    "\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",
    "* [Theano](http://deeplearning.net/software/theano/) (University of Montreal) - Popular but discontinued. \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",
    "Note: This installation uses a YAML installation script that I created for this course.  Older videos used a more hands-on approach that I describe [here](manual_setup.ipynb).  Unless you are using an older version of my class, I suggest using the installation YAML script provided below.\n",
    "\n",
    "## Installing Python and TensorFlow\n",
    "\n",
    "The first step is to install the latest version of MiniConda Python.  As of January 2020, 3.7 is the latest version of Python 3.  I recommend using the MiniConda (Anaconda) release of Python, as it already includes many of the data science related packages that are needed by this class.  Anaconda directly supports Windows, Mac, and Linux.  Miniconda is the minimal set of features from the extensive Anaconda Python distribution.  Download Miniconda from the following URL:\n",
    "\n",
    "* [Miniconda](https://docs.conda.io/en/latest/miniconda.html)\n",
    "\n",
    "## Installing Jupyter\n",
    "\n",
    "We will use Jupyter notebooks extensively in this course. Install Jupyter into your base Python environment.  In the next section, we will create a sub-environment that holds precisely the software we need.  However, it is essential to have a Jupyter notebook installed in your base Python environment. It is easy to install Jupyter notebooks with the following command:\n",
    "\n",
    "```\n",
    "conda install -y jupyter\n",
    "```\n",
    "\n",
    "Next, we will create an environment to hold TensorFlow.\n",
    "\n",
    "# Dealing with TensorFlow incompatibility with Latest Python Versions\n",
    "\n",
    "**VERY IMPORTANT** If a later version of Miniconda than 3.7 is available, then download and install it.  We will create a Python 3.7 environment just for TensorFlow.  Not all TensorFlow 2.0 packages currently support later than Python 3.7.  Usually, you will need to stay one version back from the latest Python to maximize compatibility with standard machine learning packages. \n",
    "\n",
    "You will install all of the needed TensorFlow and machine learning packages with an Anaconda YAML installation script that I provide. The script can be downloaded from here (it is the same script for Windows, Mac, and Linux):\n",
    "\n",
    "* [T81-558: TensorFlow Environment Setup Script: tensorflow.yml](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/tensorflow.yml)\n",
    "* [T81-558: TensorFlow Environment Setup Script for GPU: tensorflow-gpu.yml](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/tensorflow-gpu.yml)\n",
    "* [Instructions for TensorFlow GPU Setup](https://www.tensorflow.org/install/gpu)\n",
    "\n",
    "Assuming you have MiniConda installed, run the following command from a terminal prompt.  Make sure you downloaded the **tensorflow.yml** script to the same directory so that Conda can find it.\n",
    "\n",
    "```\n",
    "conda env create -v -f tensorflow.yml\n",
    "```\n",
    "\n",
    "To enter this environment, you must use the following command. You must execute this command every time you open a new Anaconda/Miniconda terminal window:\n",
    "\n",
    "```\n",
    "conda activate tensorflow\n",
    "```\n",
    "\n",
    "You must also link your new **tensorflow** environment to Jupyter so that you can choose it as a Kernal.  Always make sure to run your Jupyter notebooks from your 3.7 kernel. You should only need to enter this command once.\n",
    "\n",
    "```\n",
    "python -m ipykernel install --user --name tensorflow --display-name \"Python 3.7 (tensorflow)\"\n",
    "```\n",
    "\n",
    "At this point, you should have a working Python environment for TensorFlow."
   ]
  },
  {
   "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.0.0\n",
      "Keras Version: 2.2.4-tf\n",
      "\n",
      "Python 3.7.5 (default, Oct 25 2019, 10:52:18) \n",
      "[Clang 4.0.1 (tags/RELEASE_401/final)]\n",
      "Pandas 0.25.3\n",
      "Scikit-Learn 0.21.3\n",
      "GPU is NOT 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() 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. \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",
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}