01. Introduction to Jupyter Notebooks and Data - R.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Welcome to Azure Notebooks!\n\n[R](https://www.r-project.org/) is a free programming language and software environment for statistical computing and graphics. The R language is very popular for statistical analysis and data analysis.\n\nIn the following exercise we will give you a taste of what using R is like.\n\nWe have provided some data for you, and tidied it up so it’s ready to analyse. You can move through the blocks of code below by clicking on the code (within the grey boxes), then clicking the `Run` button above."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Exercise 1: Introduction To Jupyter Notebooks\n===\n\nThe purpose of this exercise is to get you familiar with using Jupyter Notebooks. Don't worry if you find the code difficult to understand, as this is not an R course. You will slowly learn more about the R programming language as you go, and you definitely don't need to understand every line of code.\n\nStep 1\n---\n\nNotebooks contain blocks of code that you can execute, such as the grey box below.\n\nGive it a go.\n\n** Click on the code below, then press `Run` in the toolbar above (or press __Shift+Enter__) to run the code. **"
    },
    {
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"The code ran successfully!\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If all went well, the code should have printed a message for you."
    },
    {
      "metadata": {
        "slideshow": {
          "slide_type": "slide"
        }
      },
      "cell_type": "markdown",
      "source": "Step 2\n---\n\nLet's print a message you choose this time. \n\n** In the block of code below, write a message between the quotation marks. It is OK to use spaces, numbers, and letters. Your message should appear red in colour.**"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "###\n# WRITE A MESSAGE BETWEEN THE SPEECH MARKS IN THE LINE BELOW, THEN HIT RUN.\n###\nprint(\"type something here!\")\n###\n\n# It's ok to use spaces, numbers, or letters. Your message should look red.\n# For example: print(\"this is my message\")",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "You will notice the hash symbols `#` in the code block above. Anything after a `#` is ignored by the computer (within Jupyter Notebook the text appears blue in colour). Using `#` at the start of a line allows you to comment the code so that it is human readable and easier to follow."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Step 3\n---\n\nR allows us to save data to use later. In this exercise, we will save a message you create.\n\n** In the code below, write a message within the quotation marks. Again, it is OK to use spaces, numbers, and letters, as long as they are within the quotation marks. **"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "###\n# WRITE A MESSAGE BETWEEN THE SPEECH MARKS IN THE LINE BELOW, THEN PRESS RUN\n###\nmy_msg <- \"type something here!\"\n###\n\nprint(my_msg) ",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "OK, what happened here? \n\nIn the real world, we might put items into a cardboard box for storage, like toys, DVDs, or photo albums. We label the box, say \"My DVDs\", to identify what is inside the box.\n\nIn R, we can do something similar: when we want to store information, we use **variables** (the cardboard box in our analogy), and the variable is given a name to help us identify what it stores so we can refer back to it.\n\nThis is what you've just done in the code block above.\n\nYou created a message inside the quotation marks, then you saved it to a **variable** called `my_msg`.\n\n```\nmy_msg <- \"This is my message that I'm going to forget so I want to save it for later!\"\n           ↑↑↑\n           The message you created\n \nmy_msg <- \"This is my message that I'm going to forget so I want to save it for later!\"\n       ↑↑↑\n       The arrow (pointing left) is called the assignment symbol, and saves the information on the right\n     \nmy_msg <- \"This is my message that I'm going to forget so I want to save it for later!\"\n↑↑↑\nThe name of your variable (what the arrow is pointing towards)\n```\n\nNote that in R, variable names cannot contain spaces, or begin with a number. As per the [R FAQ](https://cran.r-project.org/doc/FAQ/R-FAQ.html#What-are-valid-names_003f), a syntactically valid name:\n\n> _... consists of letters, numbers and the dot or underline characters and starts with a letter or the dot not followed by a number. Names such as \".2way\" are not valid, and neither are the reserved words_\n\nReserved words include: `if` `else` `repeat` `while` `function` `for` `in` `next` `break` `TRUE` `FALSE` `NULL` `Inf` `NaN` `NA` `NA_integer_` `NA_real_` `NA_complex_` `NA_character_` `...` `..1` `..2` `..3` (etc)\n\nBe mindful that variable names should help describe the information you are saving; you should aim for variable names that are descriptive."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Step 4\n---\n\nLet's try using variables again, but save a number inside our variable this time. Remember, the variable is on the *left hand side* of the `<-` assignment symbol and is the equivalent of a labelled box. The information on the *right hand side* is the information we want to store inside the variable (or a box in our analogy).\n\n** In the cell below replace `<addNumber>` with any number you choose. ** The number should not contain spaces or commas.\n\nThen __run the code__."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "###\n# REPLACE THE <addNumber> WITH A NUMBER OF YOUR CHOICE\n###\nmy_first_number <- <addNumber>\n###\n\n# Typing the name of the variable prints the information it stores to screen\nmy_first_number\n\n# Add 1 to our variable\nmy_first_number + 1\n\n# Did this calculation affect our variable? Let's check...\nmy_first_number\n\n# What's the square root of our number?\nsqrt(my_first_number)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "What happened here?\n\nIn our real world example, we might store spare coins inside a cardboard box. We can use the money in different ways, for example, we may want to count how much money is in the box, take some money out of the box then deposit it in the bank, or add more money to the box.\n\nSimilarly, in R, when we save numbers inside a variable, we can perform various calculations to the numbers we store inside the variable. Above, we asked R to add a value of one to the number that we stored in the `my_first_number` variable. We also asked R to calculate the square root of our variable using the function `sqrt()`.\n\nN.B. Performing calculations on the `my_first_number` variable will not change the value it has stored. If you want to change the value of `my_first_number`, you need to use the assignment symbol `<-`. If you do not use the assignment symbol, your information/results won't be saved."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "How does the `sqrt` function work?\n\n```\nsqrt(...)\n↑↑↑\n```\nYou are calling R to perform a **function** called `sqrt`, which computes the square root of the value supplied to the function. There are many functions available in R, stored within **libraries**.\n\n```\nsqrt(...)\n    ↑   ↑\n```\nTo use functions, you need to specify the name of the function, followed by round brackets (parentheses). The pieces of information you provide within the brackets are known as **arguments**. The `sqrt` function only takes one argument.\n```\nsqrt(my_first_number)\n     ↑↑↑\n```\nIn the example above, we supplied the `sqrt()` function a variable name `my_first_number` between the brackets, and the result, i.e. the square root of `my_first_number`, is printed to the screen.               \n      \n\nStep 5\n---\n\nLet's make a graph from some data. First we need to load the appropriate library to create a graph. The first line of code below loads the `ggplot2` library that contains the functions for graphing capabilities in this exercise. At the start of (most) R programming exercises, we have to load **libraries** to help us perform tasks. \n\n** Click on the code below, then hit the `Run` button to create a scatter plot using the `ggplot2` library. You do not need to edit any of the code. **"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Load the required library for plotting functions\nlibrary(\"ggplot2\")\n\n# Create data to plot\n# N.B. Input to ggplot2 needs to be a data frame, i.e. x and y must be stored in the same variable\ntest_data <- data.frame(x.values = c(1, 2, 3), \n                        y.values = c(5, 4, 6))\n\n# The following code makes a scatter plot, using our continuous x and y values specified above\nggplot(data = test_data, aes(x = x.values, y = y.values)) +\n# Specify type of plot as scatter plot\ngeom_point() +\n# x-axis label\nxlab(\"x value\") +\n# y-axis label\nylab(\"y value\") +\n# Title of plot\nggtitle(\"My test plot using the ggplot2 library\") +\n# Align title to centre\ntheme(plot.title = element_text(hjust = 0.5))",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If you'd like, have a play with the code:\n\n* Change the `x.values` and `y.values` stored within the variable `test_data` and see how the graph changes. Make sure they have the same count of numbers in them (i.e. currently `x.values` and `y.values` have three numbers each).\n\n\nStep 6\n---\n\nFrom time to time, we will load data from text files, rather than create it ourselves. You can't see the text files in your browser because they are saved on the server running this website. We can load the files using R though. Let's load a text file, inspect it, then graph it.\n\n#### Run the code block below to load data about chocolate bars and inspect the data. You do not need to edit the code."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Load data with information about chocolate bars, and save it to a variable called 'choc_data'\nchoc_data <- read.delim(\"Data/chocolate data.txt\")\n\n# Use the function str() below to inspect the data\n# str displays the structure of the data\nstr(choc_data)\n\n# To view the data, use the head() function\n# head returns the first part of the data\nhead(choc_data)",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The `str` function returns a compact display of the structure of an object. It informs us of the **class** (type) of the object, and its contents. \n\nBy performing the `str` function on `choc_data`, we have determined our data is of the class `data.frame`, has 5 variables, and 100 observations (abbreviated \"obs.\"). The names of each variable are shown after the $ symbol:\n\n* weight;\n* cocoa_percent;\n* sugar_percent;\n* milk_percent;\n* customer_happiness.\n\nThe `head` function, by default, returns the first six rows of our object. For our object `choc_data`, each row (horizontal) represents the information about one chocolate bar, and each column (vertical) represents the different variables. For example, the first chocolate bar is:\n* weighed 185 grams;\n* is 65% cocoa;\n* is 11% sugar;\n* is 24% milk;\n* and a customer said they were 47% happy with it.\n\n\nStep 7\n---\n\nLet's graph features from the `choc_data` variable we saved earlier. We can graph some of these features in a scatter plot, referred to as the `geom_point` function in the library `ggplot2`. Let's place `customer_happiness` on the x-axis, and `cocoa_percent` on the y-axis. \n\n### In the cell below replace:\n#### 1. `<xValues>` with `customer_happiness`\n#### 2. `<yValues>` with `cocoa_percent`\n#### then __run the code__."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "###\n# REPLACE <xValues> WITH customer_happiness and <yValues> WITH cocoa_percent\n###\nggplot(data = choc_data, aes(x = <xValues>, y = <yValues>)) +\n###\ngeom_point() +\nxlab(\"Customer happiness\") +\nylab(\"Cocoa percent\") +\nggtitle(\"Customer satisfaction with chocolate bars given cocoa percentage\") +\ntheme(plot.title = element_text(hjust = 0.5))",
      "execution_count": null,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In this graph, every chocolate bar is represented by a single point. Later, we will analyse this data with AI.\n\nConclusion\n---\n\n__Well done!__ That's the end of programming Exercise 1.\n\nYou can now go back to the course and click __'Next Step'__ to move onto some key concepts of AI - models and error."
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "r",
      "display_name": "R",
      "language": "R"
    },
    "language_info": {
      "mimetype": "text/x-r-source",
      "name": "R",
      "pygments_lexer": "r",
      "version": "3.5.3",
      "file_extension": ".r",
      "codemirror_mode": "r"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}