t81_558_class_01_1_overview.ipynb

{
 "cells": [
  {
   "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://youtu.be/CnCf1QGsjx8) [[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 & 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 Submit a Module Assignment with Google CoLab](https://www.youtube.com/watch?v=hmCGjCVhYNc)\n",
    "* [Installing TensorFlow, Keras, and Python in Windows](https://www.youtube.com/watch?v=59duINoc8GM&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN&index=6)\n",
    "* [Installing TensorFlow, Keras, and Python in Mac](https://www.youtube.com/watch?v=mcIKDJYeyFY&index=6&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN)\n",
    "* [Using Google CoLab](https://www.youtube.com/watch?v=CyWxFqMVOvg)"
   ]
  },
  {
   "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 will introduce the student to deep belief neural networks, regularization units (ReLU), convolution neural networks and recurrent neural networks. High performance computing (HPC) aspects will 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. Focus will be primarily upon the application of deep learning, with some introduction to the mathematical foundations of deep learning. Students will use the Python programming language to architect a deep learning model for several of real-world data sets and interpret the results of these networks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignments\n",
    "\n",
    "Your grade will be calculated according to the following assignments:\n",
    "\n",
    "Assignment          |Weight|Title\n",
    "--------------------|------|-------\n",
    "Class Participation |   10%|Class attendance and participation\n",
    "Class Assignments   |   50%|10 small programming assignments (5% each)\n",
    "Kaggle Project      |   20%|\"Kaggle In-Class\" project submitted through Kaggle\n",
    "Final Project       |   20%|A computer security project\n",
    "\n",
    "The 10 class assignments will be assigned with each of the first 10 modules.  Generally, each module assignment is due just before the following module date.  Refer to 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   |Title\n",
    "---------|--------------\n",
    "Module 1 |[Simple Test Submission](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class1.ipynb)\n",
    "Module 2 |[Data Preparation in Pandas](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class2.ipynb)\n",
    "Module 3 |[Creating Columns in Pandas](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class3.ipynb)\n",
    "Module 4 |[Regression Neural Network](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class4.ipynb)\n",
    "Module 5 |[K-Fold Cross-Validation](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class5.ipynb)\n",
    "Module 6 |[Classification Neural Network](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class6.ipynb)\n",
    "Module 7 |[Computer Vision Neural Network](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class7.ipynb)\n",
    "Module 8 |[Building a Kaggle Submission File](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class8.ipynb)\n",
    "Module 9 |[Exploring Regularization](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/assignments/assignment_yourname_class9.ipynb)\n",
    "Module 10|[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.  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 very popular type of machine learning that is based upon the original neural networks popularized in the 1980's. There is very little difference between how a deep neural network is calculated compared with the original 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 will explore 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 are used 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 cat or a dog.\n",
    "* **Time Series** - The use of machine learning to detect patterns in in time.  Common 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 were tasked 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, etc.  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 belongs to.  For example, consider using four measurements of an iris flower to determine the species that the flower is in.  This dataset could be used to perform [this](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/data/iris.csv).  \n",
    "\n",
    "### Beyond Classification and Regression\n",
    "\n",
    "One of the most powerful aspects of neural networks is that they simply cannot be typed as either regression or classification.  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 types of machine learning model.  Neural networks were originally introduced in the 1940's and have risen and fallen [several times from popularity](http://hushmagazine.ca/living-2/business/the-believers-the-hidden-story-behind-the-code-that-runs-our-lives). Four researchers have contributed greatly 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 completely 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 lerning.\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 on the type of data that can be presented to 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 is a technical class.  You will need to be able to compile and execute Python code that makes use of TensorFlow for deep learning. There are two options to you for accomplish this:\n",
    "\n",
    "* Install Python, TensorFlow and some IDE (Jupyter, TensorFlow, etc.)\n",
    "* Use IBM Cognitive Class Labs online\n",
    "\n",
    "## Installing Python and TensorFlow\n",
    "\n",
    "It is possible to install and run Python/TensorFlow entirely from your own computer.  Google provides TensorFlow for Windows, Mac and Linux.  Previously, TensorFlow did not support Windows.  However, as of December 2016, TensorFlow supports Windows for both CPU and GPU operation.\n",
    "\n",
    "The first step is to install Python 3.7.  As of January 2019, this 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 will be needed by this class.  Anaconda directly supports: Windows, Mac and Linux.  Miniconda is the minimal set of features from the very large Anaconda Python distribution.  Download Miniconda from the following URL:\n",
    "\n",
    "* [Miniconda](https://docs.conda.io/en/latest/miniconda.html)\n",
    "\n",
    "# Dealing with TensorFlow incompatibility with Python 3.7\n",
    "\n",
    "*Note: I will remove this section once TensorFlow adds support for Python 3.7.\n",
    "\n",
    "**VERY IMPORTANT** Once Miniconda has been downloaded you must create a Python 3.6 environment.  TensorFlow does not currently (as of Jan 2019) support Python 3.7. So you must execute the following commands:\n",
    "\n",
    "```\n",
    "conda create --name tensorflow python=3.6\n",
    "```\n",
    "\n",
    "To enter this environment, you must use the following command (**for Windows**), this command must be done every time you open a new Anaconda/Miniconda terminal window:\n",
    "\n",
    "```\n",
    "activate tensorflow\n",
    "```\n",
    "\n",
    "\n",
    "For **Mac**, do this:\n",
    "\n",
    "```\n",
    "source activate tensorflow\n",
    "```\n",
    "\n",
    "# Installing Jupyter\n",
    "\n",
    "it is easy to install Jupyter notebooks with the following command:\n",
    "\n",
    "```\n",
    "conda install jupyter\n",
    "```\n",
    "\n",
    "Once Jupyter is installed, it is started with the following command:\n",
    "\n",
    "```\n",
    "jupyter notebook\n",
    "```\n",
    "\n",
    "The following packages are needed for this course:\n",
    "\n",
    "```\n",
    "conda install scipy\n",
    "pip install --upgrade sklearn\n",
    "pip install --upgrade pandas\n",
    "pip install --upgrade pandas-datareader\n",
    "pip install --upgrade matplotlib\n",
    "pip install --upgrade pillow\n",
    "pip install --upgrade tqdm\n",
    "pip install --upgrade requests\n",
    "pip install --upgrade h5py\n",
    "pip install --upgrade pyyaml\n",
    "pip install --upgrade tensorflow_hub\n",
    "pip install --upgrade bayesian-optimization\n",
    "pip install --upgrade spacy\n",
    "pip install --upgrade gensim\n",
    "pip install --upgrade keras-rl2\n",
    "pip install --upgrade gym\n",
    "pip install --upgrade tensorflow==1.12.0\n",
    "pip install --upgrade keras==2.2.4\n",
    "```\n",
    "\n",
    "Notice that I am installing as specific version of TensorFlow.  As of the current semester, this is the latest version of TensorFlow.  It is very likely that Google will upgrade this during this semester. The newer version may have some incompatibilities, so it is important that we start with this version and end with the same.\n",
    "\n",
    "You should 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.6 kernel.  This is demonstrated in the video.\n",
    "\n",
    "```\n",
    "python -m ipykernel install --user --name tensorflow --display-name \"Python 3.6 (tensorflow)\"\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Introduction\n",
    "\n",
    "\n",
    "* [Anaconda v3.6](https://www.continuum.io/downloads) Scientific Python Distribution, including:\n",
    "    * [Scikit-Learn](http://scikit-learn.org/)\n",
    "    * [Pandas](http://pandas.pydata.org/)\n",
    "    * 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$:\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": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor Flow Version: 2.0.0-dev20190309\n",
      "Keras Version: 2.2.4-tf\n",
      "\n",
      "Python 3.6.8 |Anaconda, Inc.| (default, Dec 29 2018, 19:04:46) \n",
      "[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)]\n",
      "Pandas 0.24.1\n",
      "Scikit-Learn 0.20.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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}