Updated issue involving no update instructions for Python Issue #74

See merge request CMSE/datatools_tutorial_demo!143

Updated issue involving no update instructions for Python Issue #74
See merge request CMSE/datatools_tutorial_demo!143
bd058096 · goodm215 · 2c802ec7 · 9515db45 · bd058096
Commit bd058096 authored 1 year ago by goodm215
--- a/GUI_Tutorial.ipynb
+++ b/GUI_Tutorial.ipynb
@@ -44,6 +44,46 @@
    "!python --version"
   ]
  },
+  {
+   "cell_type": "markdown",
+   "id": "8d8a613b",
+   "metadata": {},
+   "source": [
+    "If your version of Python is not up to date, you can run the following commands to update it."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3624230e",
+   "metadata": {},
+   "source": [
+    "For Mac you can run:\n",
+    "\n",
+    "Open Terminal and update Homebrew\n",
+    "\n",
+    "`brew update`\n",
+    "\n",
+    "Upgrade Python\n",
+    "\n",
+    "`brew upgrade python`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b84b1e2",
+   "metadata": {},
+   "source": [
+    "For Linux you can run:\n",
+    "\n",
+    "Update the package list\n",
+    "\n",
+    "`sudo apt-get update`\n",
+    "\n",
+    "Install Python 3\n",
+    "\n",
+    "`sudo apt-get install python3`\n"
+   ]
+  },
  {
   "cell_type": "markdown",
   "id": "b8de36df",
@@ -315,7 +355,7 @@
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.8.8"
  }
 },
 "nbformat": 4,

 %% Cell type:markdown id:19d9a59e tags:

 ## Gradio: How you can build a GUI within a Jupyter Notebook

 #### By Team JACT

 %% Cell type:markdown id:f4ebbdbc tags:

 ## GUI Background
 A graphical user interface (GUI) is an interface through which a user interacts with electronic devices such as computers and smartphones through the use of icons, menus and other visual indicators or representations (graphics). GUIs graphically display information and related user controls, unlike text-based interfaces, where data and commands are strictly in text. GUI representations are manipulated by a pointing device such as a mouse, trackball, stylus, or by a finger on a touch screen.

 Source:
 https://www.techopedia.com/definition/5435/graphical-user-interface-gui

 %% Cell type:markdown id:89ac6392 tags:

 ## Getting Started

 First, the gradio library must be installed on your computer. It requires Python 3.7 or later. If you have not done so already, please check your version of Python and run the following line of code:

 %% Cell type:code id:cdfdbb3e tags:

 ``` python
 !python --version
 ```

+%% Cell type:markdown id:8d8a613b tags:
+
+If your version of Python is not up to date, you can run the following commands to update it.
+
+%% Cell type:markdown id:3624230e tags:
+
+For Mac you can run:
+
+Open Terminal and update Homebrew
+
+`brew update`
+
+Upgrade Python
+
+`brew upgrade python`
+
+%% Cell type:markdown id:3b84b1e2 tags:
+
+For Linux you can run:
+
+Update the package list
+
+`sudo apt-get update`
+
+Install Python 3
+
+`sudo apt-get install python3`
+
 %% Cell type:markdown id:b8de36df tags:

 On your terminal,

 %% Cell type:code id:8f5edb3b tags:

 ``` python
 !pip install gradio
 ```

 %% Cell type:markdown id:babf7f3f tags:

 Next, import the library as follows:

 %% Cell type:code id:227461d8 tags:

 ``` python
 import gradio as gr
 ```

 %% Cell type:markdown id:b879409c tags:

 Gradio can be used with a wide range of media-text, pictures, video, and sound. It is most useful for demonstrating machine learning algorithms.

 To get a feel for how it works, run the cell below this one. An interface will automatically pop up within the Jupyter Notebook. You can type your input directing into the interface.

 %% Cell type:code id:92c83d6b tags:

 ``` python
 def greet(name):
    return "Hello " + name + "!!"

 iface = gr.Interface(fn=greet, inputs="text", outputs="text")
 iface.launch(share=True)
 ```

 %% Cell type:markdown id:5f8fff86 tags:

 Although Gradio reads inputs as strings, type manipulation allows you to perform and display an even wider range of functions. Run the cell below and observe how it takes two numbers as string inputs and outputs a string displaying the sum of the two numbers.

 %% Cell type:code id:399ff8c3 tags:

 ``` python
 def addNumbers(num1, num2):
    return (num1, "+", num2, '=', str(int(num1) + int(num2)))

 iface = gr.Interface(fn=addNumbers, inputs="text", outputs="text")
 iface.launch()
 ```

 %% Cell type:markdown id:54f25173 tags:

 ### Checkbox Groups

 Another useful feature of Gradio is the ability to create checkboxes to gather user input

 https://gradio.app/docs/#checkboxgroup
 See example below:

 %% Cell type:code id:416d4b5a tags:

 ``` python
 def sentence_builder(quantity, animal, place, activity_list, morning):
    return f"""The {quantity} {animal}s went to the {place} where they {" and ".join(activity_list)} until the {"morning" if morning else "night"}"""

 demo = gr.Interface(
    sentence_builder,
    [
        gr.Slider(2, 20, value=4),
        gr.Dropdown(["cat", "dog", "bird"]),
        gr.Radio(["park", "zoo", "road"]),
        gr.Dropdown(["ran", "swam", "ate", "slept"], value=["swam", "slept"], multiselect=True),
        gr.Checkbox(label="Is it the morning?"),
    ],
    "text",
    examples=[
        [2, "cat", "park", ["ran", "swam"], True],
        [4, "dog", "zoo", ["ate", "swam"], False],
        [10, "bird", "road", ["ran"], False],
        [8, "cat", "zoo", ["ate"], True],
    ],
 )

 if __name__ == "__main__":
    demo.launch(share=True)
 ```

 %% Cell type:markdown id:caad1c75 tags:

 ### The Interface

 The core interface has three parameters:
 1. fn: The function.
 2. inputs: The input component.
 3. outputs: The output component.

 With these components, you can quickly create and launch an interface.

 %% Cell type:markdown id:d4bd4273 tags:

 ### Adding additional Inputs:

 Suppose you had a more complex function, with multiple inputs and outputs. In the example below, we define a function that takes a string, boolean, and number, and returns a string and number. Take a look how you pass a list of input and output components.


 Source: https://gradio.app/quickstart/

 %% Cell type:code id:dcc87cd1 tags:

 ``` python
 def greet(name, is_morning, temperature):
    salutation = "Good morning" if is_morning else "Good evening"
    greeting = f"{salutation} {name}. It is {temperature} degrees today"
    celsius = (temperature - 32) * 5 / 9
    return greeting, round(celsius, 2)

 demo = gr.Interface(
    fn=greet,
    inputs=["text", "checkbox", gr.Slider(0, 100)],
    outputs=["text", "number"],
 )
 demo.launch()
 ```

 %% Cell type:markdown id:46e5071f tags:

 ### Uses of Gradio

 %% Cell type:markdown id:cb8fbd70 tags:

 Gradio can load in data, similar to pandas frames, by using the command `gradio.inputs.Dataframe(data_name)`. It can only take in strings, numbers, bools, and dates as data types. Gradio does not contain a library of datasets, so data must be input by the user. It can also work with time series, images, audio, video, and generic file uploads.

 Applications:
 - Machine learning interface
    - Image classification.
    - Text generation interface (e.g. ChatBot).

 - Audio and video editing
    - Reverse audio files.
    - Flip video files.
    - Using machine learning, gradio can detect the main note in an inputted audio file.

 - File Outputs:
    - Zip files directly within Python.
    - Output your data in various file formats including JSON, HTML, PNG, etc.
    - Using a function called `.Carousel()`, Gradio can output a set of components that can be easily scrolled through.

 %% Cell type:markdown id:f84bbe7a tags:

 An example of a question could be, what is the conclusion of the sentence: Today will be a good day.

 A user could use Gardio to create an input field, then use the information from that field to generate a response.  For example, the input could be sent to a text generation model such as GPT-2 to generate a response.

 For a visual from data, you could create a cat/dog image classification model and Gradio demo to upload new images for class prediction. The model will be a Keras convolutional neural network (CNN) that would be trained on images of cats and dogs as features and their class names as labels

 %% Cell type:markdown id:a224aab9 tags:

 How this data or tool could be used in some of the team projects (maybe not your own)
 - For projects with time series modeling
    * Hope Village
    * Argonne
  (Include example of implemntation here)
 - For image analysis
    * Neogen
    * Ford
  (Include example of implemntation here)
 - Machine learning group
    * Kelloggs
    * AFRL
  (Include example of implemntation here)

 %% Cell type:markdown id:1c3a5506 tags:

 Sources:<br>
 [Analytics Vidhya](https://www.analyticsvidhya.com/blog/2021/04/create-interface-for-your-machine-learning-models-using-gradio-python-library/)

 [Gradio Documentation](https://gradio.app/getting_started/)