01_intro_to_jupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a2c4894d",
   "metadata": {
    "id": "d293edfa-4420-4e96-90c7-78f1cf78cc00"
   },
   "source": [
    "![Practicum AI Logo image](https://github.com/PracticumAI/practicumai.github.io/blob/main/images/logo/PracticumAI_logo_250x50.png?raw=true) <img src='https://github.com/PracticumAI/practicumai.github.io/blob/main/images/icons/practicumai_python.png?raw=true' align='right' width=50>\n",
    "\n",
    "# *Practicum AI: Computing for AI*: Module 1\n",
    "\n",
    "Welcome! This notebook will get you familiarized with Jupyter notebooks.\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8dbc5c0",
   "metadata": {
    "id": "e7f126cc-e5ea-4c8c-8378-14886a9ee850"
   },
   "source": [
    "## Markdown cells\n",
    "\n",
    "Jupyter notebooks have two main types of cells: **Markdown** and **Code**.\n",
    "\n",
    "**Markdown** cells allow you to use symbols that are then rendered into nicely formatted text, tables, images, etc. [Markdown](https://en.wikipedia.org/wiki/Markdown) was created in 2004 as a plain text languge for generating formatted text that was itself readable in plain text. It is now widely used across many platforms. While there is a base standard, implementations can differ in some details. The official [Jupyter Notebook markdown](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Working%20With%20Markdown%20Cells.html) documentation provides a good overview, but for the *Practicum AI* courses, mostly you will not need to create markdown, but it will be used to provide the explanatory information for you as you run the code.\n",
    "\n",
    "### To do\n",
    "\n",
    "* **Double click on this cell to see the raw Markdown text that is rendered to create the formatted text.**\n",
    "* **For Jupyter on an HPC**: \n",
    "   * When you are done, either click the play button in the top row, or type Shift-Enter on your keyboard.\n",
    "   ![Screenshot showing the play button in Jupyter to run code cells or render Markdown cells](https://github.com/magitz/computing-for-ai/blob/main/images/Jupyter_play.png?raw=1)\n",
    "* **For Google Colab**:\n",
    "   * Google Colab has a slightly different Markdown editor view that splits the screen. Markdown is shown on the left, and formatted text on the right. You can even use the text formatting tools on the right to auto-generate the markdown. Rather than using the play button to render Markdown, simply click out of the cell and the split will return to the rendered view.\n",
    "   ![Screenshot showing the split screen Markdown editor in Google Colab](https://github.com/magitz/computing-for-ai/blob/main/images/Colab_Markdown.png?raw=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a808063",
   "metadata": {
    "id": "6fd0f4e0-26ef-463c-a341-94b279ca2208"
   },
   "source": [
    "## Now run the code cell below\n",
    "\n",
    "<div style=\"padding: 10px;margin-bottom: 20px;border: thin solid #30335D;border-left-width: 10px;background-color: #fff\">\n",
    "   <p><strong>Note:</strong> <strong>For Google Colab</strong>: When you run the first cell in a notebook, you will see a warning that the notebook is not authored by Google. You will need to click the <strong>Run anyway</strong> button to run the notebook.<br>\n",
    "   \n",
    "   <img src='https://github.com/magitz/computing-for-ai/blob/main/images/Colab_Run_anyway.png?raw=1' height=100 alt='Screenshot of the Google Colab warning that the notebook is not authored by Google. Click the Run anyway button.'>\n",
    "   </p>\n",
    "   </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "eabb7fa2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2edd1e49-1c6c-413a-a343-ed62dffcd3f8",
    "outputId": "586d9d13-01b5-4f46-aac7-491cd54acb3c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Practicum AI's Computing for AI course!\n"
     ]
    }
   ],
   "source": [
    "# This cell is a code cell. We will learn about Python in the next course, but this line is a comment since it starts with a \"#\"\n",
    "# To run a code cell, as with rendering Markdown cells, you can either click the play button or type Shift-Enter\n",
    "# Click into this cell and run it!\n",
    "\n",
    "print(\"Welcome to Practicum AI's Computing for AI course!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "911cc628",
   "metadata": {
    "id": "bd75b04b-b07f-4cf5-b595-69d170b5c134"
   },
   "source": [
    "## Code cell explanation\n",
    "\n",
    "The image below highlights the expected output from the code cell above. \n",
    "\n",
    "![Screenshot of the cell after execution highlighting the parts described in the text below](https://github.com/magitz/computing-for-ai/blob/main/images/Jupyter_Code_Cell.png?raw=1)\n",
    "\n",
    "* The cell execution counter to the left of the cell will have a number in square brackets. That helps you keep track of which cells have been run and in what order. \n",
    "   * If a cell has not been run, it will not have a number. \n",
    "   * Cells in a notebook can be run in any order, and the order does matter. Keep that in mind and check the numbers if you get unexpected results. Typically, it is best to start at the top and work your way down, but sometimes you will skip around--just be careful when you do that.\n",
    "   * While a cell is running the square brackets will have an asterisk ([\\*]). Some cells, especially model training cells, can take some time to run. While one cell is running, all other cells will be blocked from running. In a notebook, only one cell can run at a time.\n",
    "* Code cells can have text comments on lines that start with a hashtag (#). Comments can also end a line of code, anything after the hashtag is a comment.\n",
    "   * Comments are one way of documenting your code and make it easier for you and others to know what each cell or line of code is doing.\n",
    "* Code in the cells is what will be run when you execute the cell. Jupyter applies contextual coloring to the code to help enhance readability and help you catch typos--if you forget to close the quoted text for example, the red color continues past where you wanted to stop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "351d4256",
   "metadata": {
    "id": "dda9f12e-c412-4c69-8605-298b9e83010b"
   },
   "source": [
    "## Write your first code!\n",
    "\n",
    "Above, we wrote some code to print a welcome message. Use the cell below to print something else, maybe personalize the message with your name!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3be16a56",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c63b9caf-825a-4147-93f6-6f3bf087649d",
    "outputId": "13f4031d-f257-4245-acb8-7f960243f9ac"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is awesome!!\n"
     ]
    }
   ],
   "source": [
    "# Add your code here to print something\n",
    "print(\"This is awesome!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a1caa7c",
   "metadata": {
    "id": "de5b11ec-9df1-48e7-852d-e559f03acb92"
   },
   "source": [
    "## Add your notes\n",
    "\n",
    "Use this cell to add some notes to yourself on Jupyter notebooks (remember, you will need to double click to edit the contents of a markdown cell).\n",
    "\n",
    "* Notebooks have two types of cells:\n",
    "    * Markdown cells where I can use Markdown to create formatted text\n",
    "    * Code cells where I write the code that can be run\n",
    "* The order in which code cells are run is important!\n",
    "* I have already started writing Python code...see it wasn't that hard! 😅\n",
    "*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0672c1f9",
   "metadata": {
    "id": "d57ba71c-d3c6-4329-b36d-20947e0a5563"
   },
   "source": [
    "## Bonus exercise\n",
    "\n",
    "**After completing module 3 of this course** on `git` and Github.com, return to this notebook. \n",
    "\n",
    "(This will not work until you connect your account with GitHub using ssh keys or Google Colab authentication)\n",
    "\n",
    "Use the git tab to:\n",
    "1. Add the 01_intro_to_jupyter.ipynb notebook and track the changes\n",
    "1. Enter a commit message in the box\n",
    "1. Push your changes to GitHub.com\n",
    "1. Visit your notebook on GitHub.com and see your updated notebook there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4521d367",
   "metadata": {
    "id": "9f8e9eee-71e0-418b-9a11-557ff19f0c1d"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "UFRC Python-3.10",
   "language": "python",
   "name": "python3-3.10-ufrc"
  },
  "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}