course-data.yaml

hello-world:
  # course_title: "Building a 'Hello World' for self-driving labs"
  course_shortname: "Hello World"
  course_title: "Introduction to AI for Discovery using Self-driving Labs"
  course_emoji: "💡"
  registration_link: "https://learn.utoronto.ca/programs-courses/courses/4010-introduction-ai-discovery-using-self-driving-labs" # didn't like `#sections` at end (hidden from sidebar)
  orientation_ref: "1.0-orientation"
  description: "In this course, you will build a minimal working example for a self-driving lab, using dimmable LEDs and a light sensor to perform a color-matching task. This introduction will help you implement microcontroller programming via a Pico W, Bayesian optimization via the Ax Platform, device communication via MQTT, and database integration via MongoDB. Finally, you will piece together the individual components to complete your self-driving lab. This introductory course will prepare you for deeper dives in data science, robotics, software development, and system design in later microcourses."
  media_command: |
    ```{image} ./images/clslab-light.gif
    :align: center
    :scale: 35 %
    ```
    <br>
  media_caption: "Animated schematic diagram of the 'Hello World' demo: A microcontroller controls the LEDs and reads sensor data. The difference between the target color and the measured color is fed into an adaptive experimentation algorithm, and the process repeats itself."
  recommended_prerequisites: For participants to complete this course within the expected timeframe (approx. 25 hours), at least beginner proficiency in Python programming is recommended. Those with advanced programming expertise will likely require a significantly shorter amount of time, whereas those with no prior programming experience may require 50 hours or more.
  welcome_video_url: https://www.youtube.com/embed/videoseries?si=Dt-C256m6yvzfnYT&amp;list=PLKFxDV1Aoxg6dBasfkbG-zFQoy2RDOidX&t=623s

  learning_outcomes:
    - "Define and explain key terms and principles of self-driving labs to demonstrate understanding"
    - "Apply MQTT or similar frameworks to send commands and receive sensor data over WiFi"
    - "Demonstrate the ability to use MongoDB to store and retrieve experiment configurations and results effectively"
    - "Develop and implement software on a Raspberry Pi Pico W microcontroller to control device power and read sensor data accurately"
    - "Modify a Bayesian optimization script using the Ax Platform to iteratively propose new experimental configurations"
    # - "Implement workflow orchestration for a color experiment using packages such as Prefect"
    - "Integrate the individual SDL components to orchestrate the full 'Hello World' workflow"
    # - "Modify the system to record temperature, humidity, barometric pressure, and accelerometer measurements"
  competencies_skills:
    - "Basic self-driving lab literacy"
    - "Microcontrollers and sensors"
    - "Bayesian optimization"
    - "Hardware/software communication"
    - "Database management"
    - "Workflow orchestration"
  course_assessments_and_grading_schema: "<p>Each student is required to complete various quizzes and GitHub Classroom assignments. The course is structured into an orientation module followed by several modules. The course is graded on a pass/fail basis with 70% as the threshold for passing. Here is the breakdown of the points for each part of the course:</p><ul><li>🧭 Orientation Module: Worth 15 points.</li><li>📚 Modules 1-6: Each includes:<ul><li>🧭 A guided notebook tutorial (ungraded)</li><li>📓 A knowledge check (graded, 5 points)</li><li>🛠️ A GitHub Classroom assignment (graded, 10 points*)</li></ul></li></ul><p>*The final module's GitHub Classroom assignment is worth 30 points.</p><p>Note that partial points are available on certain assignments.</p>"
  module_note: "The orientation modules are intended to be completed in under one hour in total. The modules after are intended to take approximately 3-4 hours each, assuming that the recommended prerequisites from above have been met."
  modules:
    - module_name: "1.0 Orientation"
      topics:
        - "Git"
        - "GitHub"
        - "Version control"
        - "GitHub Classroom"
        - "Codespaces"
      learning_outcomes:
        - "Describe the purpose of Git and GitHub"
        - "Create a GitHub account and a repository"
        - "Commit, push, and pull changes"
        - "Run a unit test and fix a simple Python function"
        - "Define continuous integration"
      tutorial_file: 1.0-orientation.md
      assessments:
        - "Quiz: Enter your GitHub classroom ID and your GitHub username"
        - "Quiz: Match terms with definitions"
        - "Pytest: Update a Python file to return the correct string"
        - "Quiz: Self-report the overall GitHub Classroom score"
    - module_name: "1.1 Run the demo"
      topics:
        - "Database management"
        - "Bayesian optimization"
        - "Microcontrollers"
      learning_outcomes:
        - "Describe key terms and principles of self-driving labs"
        - "Preview an end-to-end self-driving lab"
        - "Upload software to a microcontroller"
      tutorial_file: 1.1-running-the-demo.md
      tutorial:
        - "Video: build instructions for the SDL demo https://youtu.be/D54yfxRSY6s?si=fjS6yxr-mKb3yBEp"
        - "Building a hello world for self-driving labs: https://doi.org/10.1016/j.xpro.2023.102329"
        - "Additional resource: Accelerate 2022 talk https://youtu.be/LNkRjByzeZg?si=FmyAMy0vELeUOae5"
        - "Additional resource: What is a minimal working example for a self-driving laboratory? perspective paper https://doi.org/10.1016/j.matt.2022.11.007 (include a static copy and/or a link to the postprint: https://github.com/sparks-baird/self-driving-lab-demo/blob/main/reports/self_driving_optics_demo-rev1.pdf)"
      assessments:
        # - "Quiz: Check for matched terms with definitions"
        - "Quiz: Match the term to the specific platform used in CLSLab:Light" # demonstrate reading of manuscript
        # - "Pytest: Check that source code from a zip file is copy-pasted into a certain file"
        # - "Pytest: Check that a 'test' demo database entry exists that contains their course identifier"
        - "Pytest: Check for a test entry with their course identifier from the public database"
    - module_name: "1.2 Blink and read"
      topics:
        - "Microcontrollers"
        - "MicroPython"
      learning_outcomes:
        - "Write MicroPython scripts"
        - "Use a microcontroller"
      tutorial_file: 1.2-blink-and-read.md
      tutorial:
        - "Blink LED on Pico W tutorial (Getting started with the Pico W or similar)"
        - "NeoPixel tutorial"
        - "Maker Pi Pico neopixel tutorial"
        - "AS7341 Adafruit tutorial"
        - "main.py from tutorial https://github.com/sparks-baird/self-driving-lab-demo/blob/2f4bf8c27cf80776821306ce443244d11fae8968/src/public_mqtt_sdl_demo/main.py"
      assessments:
        # - "Quiz: Enter the name of the file (including extension) that needs to be uploaded to the microcontroller"
        - "Quiz: Enter the names of the MicroPython module and class that need to be imported to control the LED (machine.Pin, neopixel.NeoPixel)"
        - "Quiz: Enter the name of the MicroPython module and class that lets you interface with the light sensor (as7341_sensor.Sensor)"
        - "Pytest: Verify that a filled in function (that uses a dummy class for machine.Pin) returns the expected command"
        - "Pytest: Verify that a filled in function (that uses a dummy class for AS7341) returns the expected data"
        # - "Quiz & ungraded pytest: Check that some command line output (that users copy-pasted from Thonny terminal) matches the answer key for a script that blinks an LED"
        # - "Quiz & ungraded pytest: Check that some command line output (that users copy-pasted from Thonny terminal) matches the answer key for a script that reads the sensor data"
    - module_name: "1.3 Bayesian optimization"
      topics:
        - "Design of experiments"
        - "Bayesian optimization"
        - "Data visualization"
      learning_outcomes:
        - "Adapt a Bayesian optimization script to perform color-matching"
        - "Compare Bayesian optimization with other search methods"
        - "Visualize optimization efficiency"
      tutorial_file: 1.3-bayesian-optimization.ipynb
      tutorial:
        - "Video: A gentle introduction to Bayesian optimization | https://youtu.be/IVaWl2tL06c?si=P5dQFs4pX5TxsYxS"
        - "grid vs. random vs. Bayes (sort of from scratch) tutorial: https://towardsdatascience.com/grid-search-vs-random-search-vs-bayesian-optimization-2e68f57c3c46"
        - "Video: Bayes rule by 3Blue1Brown | https://youtu.be/HZGCoVF3YvM?si=Gfoi-0sRvxqsTW2u"
        - "combining content from random search for a self-driving lab https://github.com/sparks-baird/self-driving-lab-demo/blob/6c0b5f63b37ad2c24dea1a51bab498ac2cc37853/notebooks/2.0-random-search.ipynb grid search and BO https://github.com/sparks-baird/self-driving-lab-demo/blob/567184a073143f129b2ec72607ef0709222e51d4/notebooks/2.3-bayesian-optimization.ipynb and running comparisons of all three https://github.com/sparks-baird/self-driving-lab-demo/blob/112e7e6bfa69c11d61dcbbc4e72a704be0adb87b/notebooks/3.1-random-vs-grid-vs-bayesian.ipynb"
      assessments:
        - "Quiz: Match terms with definitions (summarized definitions from GPT4). Random number generator seed, grid search, random search, Sobol sampling, Latin Hypercube, Quasi-random, Bayesian optimization, Acquisition function, Exploration, Exploitation, Surrogate model, Constraint, Parameter, Expected improvement, Gaussian Process, Curse of dimensionality"
        - "Quiz: Ask a simple question about grid search (what are the datapoints for a 1D grid search from 0 to 1 with 3 points)"
        - "Quiz: Identify the number of grid points in 1D, 2D, and 3D with 3 points along each dimension"
        - "Quiz: Rank the typical efficiency of grid search vs. random search vs. quasi-random vs. Bayesian optimization"
        - "Quiz: Enter a random number generated by numpy according to directions in <URL> using a seed of 10 to N decimal points"
        # NOTE: could be paired with Canvas quiz, but difficult to keep synced
        # NOTE: provide a dummy class for the light-mixing demo
        - "Pytest: Verify that the filled in code for grid search with a specific set of seeds and a fixed Ax version reaches a particular outcome (i.e., verify that two floats match) for Branin function"
        - "Pytest: Verify that the filled in code for random search with a specific set of seeds reaches a particular outcome (i.e., match the numbers) for Branin function."
        - "Pytest: Verify that the filled in code for Bayesian optimization with a specific set of seeds and a fixed Ax version reaches a particular outcome (i.e., match the numbers)  for Branin function."
        - "Pytest: Verify that the data to be placed in a matplotlib figure for 'best result so far' vs. iteration number matches the answer key for a specific set of seeds for Branin function"
    - module_name: "1.4 Device communication"
      topics:
        - "MQTT"
        - "Broker/client"
      learning_outcomes:
        - "Send commands to a microcontroller"
        - "Receive sensor data from a microcontroller"
      tutorial_file: 1.4-hardware-software-communication.md
      tutorial:
        - "Video: What is MQTT? (or some equivalent, keep it to ~5 minutes maybe? Could be part 1 of HiveMQ MQTT essentials https://www.youtube.com/playlist?list=PLRkdoPznE1EMXLW6XoYLGd4uUaB6wB0wd)"
        - "Create a HiveMQ account and broker"
        - "Paho MQTT Python client: http://www.steves-internet-guide.com/receiving-messages-mqtt-python-client/ (specifically the part about Queue)"
        - "Google Colab Link to a Paho MQTT client ?"
        - "Send a toggle command to the onboard LED and receive the temperature"
      assessments:
        - "Quiz: Match terms with definitions (MQTT, Broker, Client, Paho MQTT, HiveMQ, micropython-mqtt, First-in first-out (FIFO) queue, Publish, Subscribe, callback, host, JSON, while loop, payload, quality of service)"
        - "Quiz: Pair the QOS level with the description"
        - "Quiz: Multiple fill in the blank: Publish the `LED command` to the `LED topic`, `` subscribes to `` on the `` topic. Etc."
        - "Pytest: Check that users added personal HiveMQ credentials as repository secrets, and that they're not the sgbaird ones"
        # - "Pytest: Verify the broker is working by running it with the pre-built CLSLab:Light demo (reuse the 'running the demo' pytest)."
        - "Pytest: Verify that a message can be sent using the HiveMQ secrets that were supplied, and that it's not the one provided publicly by me. Have it be the sending and receiving of the onboard LED command and the onboard temperature, respectively."
        - "Pytest: Verify that a user-implemented CLSLab:Light message gets sent/received properly (i.e., adapted optimization pytest from 'running the demo' or just a simple message)"
    - module_name: "1.5 Database Management"
      topics:
        - "MongoDB"
        - "JSON"
        - "PyMongo"
      learning_outcomes:
        - "Set up a MongoDB account and database"
        - "Upload data directly from microcontroller"
        - "Extract and collate data from database"
      tutorial_file: 1.5-data-logging.md
      tutorial:
        - "Video: What is FAIR data"
        - "What does FAIR data look like in chemistry and materials science?"
        - "What is MongoDB, and why are we using it instead of other solutions? (e.g., origins in Materials Project)"
        - "Create your own MongoDB free-tier database (Build instructions manuscript)"
        - "MongoDB data API tutorial (using your own credentials) - insertOne and findOne"
        # - "PyMongo tutorial (using credentials I provide)"
      assessments:
        - "Quiz: Match terms with definitions, FAIR, findable, accessible, interoperable, reusable, database, collection, document, field, key, value, schema, JSON, MongoDB, Atlas, pymongo, insert_one, find_one, find, SQL, REST, Indexing, NoSQL, Replica set, Metadata, Ontology, Figshare, DOI, Provenance, Licenses, query"
        - "Quiz: Check for a match between a pre-uploaded, specific database entry and the user input"
        - "Pytest: Check that users added personal MongoDB credentials as repository secrets"
        - "Pytest: Verify that an entry can be added using the MongoDB secrets"
        - "Pytest: Verify that an entry can be retrieved using the MongoDB secrets"
        - "Pytest: Verify that code students write uploads some sensor data to the database"
        - "Pytest: Verify that code students write extracts a database entry and created a pandas dataframe from it"
    # - module_name: "6. Workflow orchestration" # standalone module
    #   topics:
    #     - "Workflow orchestration"
    #     - "Prefect"
    #   learning_outcomes:
    #     - "Define workflow orchestration concepts"
    #     - "Describe the importance of workflow orchestration in the context of SDLs"
    #     - "Create a simple workflow orchestration deployment on a server"
    #   tutorial:
    #     - "Video: What is workflow orchestration?"
    #     - "Video: What is Prefect?"
    #     - "Create a Prefect account and project"
    #     - "Create a Prefect flow"
    #     - "Run a Prefect flow"
    #   assessments:
    #     - "Quiz: Match terms with definitions (workflow orchestration, Prefect, flow, task, state, schedule, trigger, parameter, parameterized, flow run, flow run ID, flow run state, flow run log, flow run result, flow run artifact, flow run parameter, flow run parameter value)"
    #     - "Quiz: Fill-in-the-blank statements (x calls y, y calls z)"
    - module_name: "1.6 Connecting the pieces"
      topics:
        - "Systems design"
      tutorial_file: 1.6-connecting-the-pieces.md
      learning_outcomes:
        - "Describe how individual components of an SDL can be integrated"
        - "Perform system-level debugging and troubleshooting"
        - "Conduct a full SDL experimental campaign"
      assessments: # Having trouble deciding how to ask learners to structure it
        - "Quiz: left-middle-right matching statements. E.g., <the Pico W> sends data using the <MQTT> protocol to the <HiveMQ> broker. The <Python client> sends commands using the <MQTT> protocol to the <Pico W> client. The <Pico W> sends data using the <MongoDB> protocol to the <MongoDB> database. The <Ax Platform> sends suggested next experiments to the <Python client> and receives new data from the <Python client>."
        - "Pytest: Verify that valid sensor data is received in response to a command by subscribing on an MQTT topic"
        - "Pytest: Verify that the BO evaluation function is using MQTT to send commands to the microcontroller and receive sensor data, rather than it occurring somewhere else, perhaps via timestamps or the experiment IDs"
        - "Pytest: Verify that MongoDB is getting updated with data at each iteration of the BO loop, again perhaps using timestamps or experiment IDs"
        - "Pytest: Verify that an AxClient exists and is being used (perhaps via static analysis of the code)"
        - "Pytest: Programatically access their (up-and-running) machine using the HiveMQ credentials and run a full BO campaign - check that the RMSE is below some threshold, MongoDB and HiveMQ are functioning properly, and the microcontroller commands are correct"
        - "Pytest: Copy the checks from the blink and read, HiveMQ, and MongoDB for the microcontroller"
    # - module_name: "7. Lab sensor system"
    #   topics:
    #     - "Environmental sensors"
    #   learning_outcomes:
    #     - "Continuously log temperature, humidity, vibration, etc."
    #   assessments:
    #     - "Quiz: match the data type with the name of each sensor (e.g., AS7341)"
    #     - "Pytest: verify that a capped collection has been set up per instructions"
    #     - "Pytest: verify that the data is being actively logged to the database and validate the schema"

  developers:
    - "Sterling Baird, PhD Materials Science and Engineering (Acceleration Consortium)"

data-science:
  course_shortname: "Data Science"
  course_title: "AI and Materials Databases for Self-driving Labs"
  course_emoji: "📊"
  registration_link: "https://learn.utoronto.ca/programs-courses/courses/4131-ai-and-materials-databases-self-driving-labs"
  # waitlist_link: "https://2learn.utoronto.ca/public/student/studentRequestInformation.do?method=edit&type=0&courseNumber=134035261"
  orientation_ref: 2.0-orientation
  description: "Unleash the power of data science in the realm of self-driving laboratories. This remote, asynchronous course empowers you to apply data science concepts to materials discovery tasks. You'll create Bayesian optimization scripts, explore advanced optimization topics, and adapt templates to create an advanced optimization setup for a materials discovery task. Topics will include multi-objective, constrained, high-dimensional, multi-fidelity, batch, asynchronous, and domain-aware Bayesian optimization. Additionally, you'll learn to share your findings by uploading datasets to a data repository, creating benchmark models, and hosting models on data science platforms."
  media_command: "![](./images/ax-repo/bo_1d_opt.gif)"
  media_caption: "*Animation of 1D Bayesian Optimization: A Gaussian Process surrogate model can be used with an acquisition function to seamlessly transition from exploration to optimization in noisy settings. Source: [https://ax.dev/docs/bayesopt.html](https://ax.dev/docs/bayesopt.html)*"
  recommended_prerequisites: "The **recommended prerequisite** for this course is {{ hello-world }} (Course 1: Hello World)"
  learning_outcomes:
    - "Describe and categorize a materials discovery task using data science language and concepts"
    - "Customize a Bayesian optimization script to systematically identify the optimal chocolate chip cookie recipe, demonstrating practical application of optimization techniques"
    - "Evaluate and select an advanced optimization setup that is best suited for a specific materials discovery task, showcasing critical analysis and decision-making skills"
    - "Develop and execute a program to upload a dataset to a public database, construct a benchmark model, and deploy it online, illustrating proficiency in data sharing and model hosting"
  competencies_skills:
    - "Data science literacy"
    - "Bayesian optimization"
    - "Advanced Bayesian optimization"
    - "Workflow orchestration"
    - "Benchmarking"
  course_assessments_and_grading_schema: "{{ courses.hello-world.course_assessments_and_grading_schema }}"
  developers:
    - "Sterling Baird, PhD Materials Science and Engineering (Acceleration Consortium)"
  module_note: "Each module is intended to take approximately 3-4 hours, assuming that the recommended prerequisites have been met."
  modules:
    - module_name: "2.0 Orientation"
      tutorial_file: 2.0-orientation.md
      topics:
        - "Git"
        - "GitHub"
        - "Version control"
        - "GitHub Classroom"
        - "Codespaces"
      learning_outcomes:
        - "Describe the purpose of Git and GitHub"
        - "Create a GitHub account and a repository"
        - "Commit, push, and pull changes"
        - "Run a unit test and fix a simple Python function"
        - "Define continuous integration"
    - module_name: "2.1 Single-objective"
      tutorial_file: 2.1-single-objective.md
      topics:
        - "Design of experiments"
        - "Quasi-random search methods"
        - "Bayesian optimization (BO)"
        - "Expected improvement (EI)"
        - "Ax Platform"
        - "Honegumi template generator"
      learning_outcomes:
        - "Describe a materials discovery task using data science language and concepts"
        - "Adapt a Bayesian optimization script to find an optimal chocolate chip cookie recipe"
      tutorial:
        - "https://distill.pub/2020/bayesian-optimization/"
      assessments:
        - "Quiz: Match advanced opt terms with definitions"
        - "Quiz: Check all that apply (provide text description of a materials discovery task)"
        - "Quiz: Check all that apply (provide text description of a materials discovery task) (new Q)"
        - "Quiz: Enter some optimized number of score from the optimal chocolate chip cookie recipe based on fixed seeds"
        - "Pytest: assert required modules are present"
        - "Pytest: assert the the Ax object is instantiated correctly"
        - "Pytest: assert that the best parameters are correct for a fixed seed"
    # - module_name: "Mechanics"
    #   topics:
    #     - "Attaching existing data"
    #     - "Human-in-the-loop"
    #   learning_outcomes:
    #     - "Utilize the 'plumbing' needed by optimization scripts in real-world lab settings"
    #   assessments:
    #     - "Quiz: How do the needs of typical optimization packages differ from that of wetlab experiments?"
    #     - "Quiz: Match terms with definitions (e.g., human-in-the-loop, attaching existing data)"
    #     - "Quiz: What is the name of the row from honegumi for attaching existing data?"
    #     - "Pytest: Verify that data that was provided to the users is attached to an AxClient and that the suggested new experiment matches what's expected"
    #     - "Pytest: Verify that manually added data to a dictionary at the beginning of an optimization script (made by rerunning the script and manually adding) contains the experiments that should have been suggested"
    - module_name: "2.2 Multi-objective"
      tutorial_file: 2.2-multi-objective.md
      topics:
        - "Pareto fronts"
        - "Hypervolume"
        - "qNEHVI"
        - "Objective thresholds"
      learning_outcomes:
        - "Explain the significance of a Pareto front"
        - "Compare simple scalarization with expected hypervolume improvement"
        - "Explore the effect of setting objective thresholds"
      assessments:
        - "Quiz: Match terms with definitions"
        - "Quiz: Identify the Pareto front points based on a figure"
        - "Quiz: Calculate the Pareto front points based on a provided Python function and a given dataset"
        - "Quiz: Identify the hypervolume from the previous exercise using a provided Python function"
        - "Pytest: Check for a match of Pareto front data for a fixed seed"
        - "Pytest: Verify correct imports"
        - "Pytest: Verify that a Pareto frontier plot is generated using the right function (e.g., the output is a plotly figure)"
        - "Pytest: Verify syntax for setting objective thresholds"

    # - module_name: "Constrained optimization"
    #   topics:
    #     - "Linear constraints"
    #     - "Nonlinear constraints"
    #     - "Compositional constraints"
    #     - "Order constraints"
    #   learning_outcomes:
    #     - "Provide examples of materials discovery tasks with constraints"
    #     - "Adapt a Bayesian optimization script to include constraints"
    #   tutorial:
    #     - "Degrees-of-freedom, compositional linear constraint: https://chat.openai.com/share/841f8f67-2ee9-4546-a4d6-681f0e7c04fd (https://github.com/facebook/Ax/issues/727)"
    #   assessments:
    #     - "Quiz: Match terms with examples"
    #     - "Pytest: Verify that certain parameter sets pass or fail the constraint (i.e., check in the vicinity of the constraint)"
    #     - "Quiz: Report the optimized value for a given seed"

    # - module_name: "High-dimensional optimization"
    #   topics:
    #     - "Curse of dimensionality"
    #     - "SAASBO"
    #   learning_outcomes:
    #     - "Explain the curse of dimensionality"
    #     - "Compare the efficiency of expected improvement and SAASBO as a function of dimensionality"
    #   assessments:
    #     - "Quiz: Match terms with definitions (SAASBO, curse of dimensionality, discrepancy)"
    #     - "Quiz: Report the final efficiencies for EI and SAASBO for a given seed for three different dimensionalities"
    #     - "Pytest: Verify that the optimization history matches for a fixed seed"
    #     - "Pytest: Verify that the optimization traces are correct by checking the figure return type and accessing the raw data"

    - module_name: "2.3 Batch Optimization"
      tutorial_file: 2.3-batch.md
      topics:
        - "Conditioning"
        - "Batch optimization"
        - "Asynchronous optimization"
        - "Parallelism"
      learning_outcomes:
        - "Explain the effect of parallelism on optimization efficiency in terms of wall time and resource utilization"
        - "Explain what conditioning is in the context of batch and asynchronous BO"
        - "Adapt a Bayesian optimization script to use batch optimization"
        - "Adapt a Bayesian optimization script to use asynchronous optimization"
      assessments:
        - "Quiz: Match terms with definitions"
        - "Quiz: Select the cases that have asynchronous optimization"
        - "Quiz: Select the cases that have batch optimization"
        - "Quiz: Input the final optimized values for three cases: sequential, batch, and asynchronous optimization with fixed seeds"
        - "Pytest: Verify that the optimization history matches for a fixed seed"
        - "Pytest: Verify that the optimization traces are correct by checking the figure return type and accessing the raw data"

    - module_name: "2.4 Featurization"
      tutorial_file: 2.4-featurization.md
      topics:
        - "Domain knowledge integration"
        - "Contextual variables"
        - "Predefined candidates"
      learning_outcomes:
        - "Explain the advantages and disadvantages of featurization"
        - "Adapt a Bayesian optimization script to use predefined candidates with featurization"
        - "Adapt a Bayesian optimization script to use contextual variables"
      assessments:
        - "Quiz: Match terms with definitions"
        - "Quiz: Select the cases that have contextual variables (i.e., variables not directly controlled by user, but that provide contextual information)"
        - "Quiz: Check all that apply (provide text description of a materials discovery task)"
        - "Quiz: Input the final optimized values for three cases: no featurization, featurization (known by me) that performs better, featurization (known by me) that performs worse with fixed seeds"
        - "Pytest: Verify that the optimization history matches for a fixed seed"
        - "Pytest: Verify that the optimization traces are correct by checking the figure return type and accessing the raw data"
        - "Quiz: Input the final optimized values for three cases: without a contextual variable, with an important contextual variable, and with a red-herring contextual variable (could use one of the matsci-opt benchmarks or Vickers hardness, etc.)."
        - "Compare the optimization efficiency, runtime, and resource utilization for three cases: small number of predefined candidates, large number of predefined candidates, and continuous optimization"

    - module_name: "2.5 Multi-task" # / multi-task
      tutorial_file: 2.5-multi-task.md
      topics:
        - "Multi-task optimization"
        - "Cost-fidelity tradeoffs"
        # - "Knowledge gradient"
      learning_outcomes:
        - "Explain the effect of cost-fidelity tradeoffs on optimization"
        - "Explain when to use multi-fidelity vs. multi-task optimization vs. contextual optimization"
        - "Adapt a Bayesian optimization script to leverage data from a related task"
        # - "Assess the efficiency of expected improvement at fixed fidelities vs. knowledge gradient"
        # - "Adapt a Bayesian optimization script to use a knowledge gradient"
      assessments:
        - "Quiz: Match terms with definitions"
        - "Quiz: Select the cases that have multiple fidelities (i.e., variables where as cost increases, fidelity is expected to increase)"
        - "Quiz: Categorize several cases as multi-fidelity vs. multi-task per guidelines in https://github.com/facebook/Ax/issues/1038"
        - "Quiz: Input the final optimized values after a certain budget is used up for the following cases: fidelity fixed to lowest, fidelity fixed to middle, fidelity fixed to highest, variable fidelity via knowledge gradient"

    - module_name: "2.6 Benchmarking"
      tutorial_file: 2.6-benchmarking.md
      topics:
        - "Benchmarks"
        - "Surrogate models"
        - "Random forest regression"
        - "FAIR data"
        - "Model deployment"
        - "APIs"
      learning_outcomes:
        - "Explain the effect of noise on benchmarking tasks"
        - "Programatically upload a completed dataset to Figshare"
        - "Create a benchmark model with scikit-learn"
        - "Host a model on HuggingFace"
      assessments:
        - "Quiz: Match terms with definitions (homoskedastic noise, heteroskedastic noise, standard error metric, standard deviation, API, benchmark, model, FAIR data, surrogate model, random forest regression)"
        - "Quiz: Read the matsci-opt benchmarks paper and provide a DOI link to the figshare dataset"
        - "Quiz: Provide a link to the matsci-opt GitHub repo"
        - "Quiz: Provide a link to the HuggingFace model (TBD)"
        - "Pytest: Download a user's dataset via a DOI link and verify that the data is of the correct type and follows the correct schema"
        - "Pytest: Verify that the HuggingFace model can be accessed to return results"

robotics:
  course_shortname: "Robotics"
  course_title: "Autonomous Systems for Self-driving Labs"
  course_emoji: "🦾"
  registration_link: "https://learn.utoronto.ca/programs-courses/courses/4132-autonomous-systems-self-driving-labs"
  # waitlist_link: "https://2learn.utoronto.ca/public/student/studentRequestInformation.do?method=edit&type=0&courseNumber=134035513"
  orientation_ref: "3.0-orientation"
  description: "Embark on a journey into the world of robotics and automation for self-driving laboratories. This asynchronous, remote course equips you with the skills to control peristaltic pumps, linear actuators, automated liquid handlers, and solid dispensers using a microcontroller, a motor driver, and a workflow orchestration package. You'll also learn to control mobile cobots and perform spatial referencing and ID recognition via computer vision. The course will conclude with a solid sample transfer workflow using a multi-axis robot. Remotely accessible resources will be provided as necessary."
  media_command: "<video width='100%' controls autoplay muted><source src='./../../_static/ac-website/robot-loop.mp4' type='video/mp4'>Your browser does not support the video tag.</video>"
  media_caption: "Self-driving lab robotic platforms. 1. ADA at the University of British Columbia (C. Berlinguette, J. Hein, A. Aspuru-Guzik); 2. Artificial Chemist (M. Abolhasani, NC State University); 3. Robotically reconfigurable flow chemistry platform (C. Coley, MIT); 4. Chemputer (L. Cronin, University of Glasgow); 5. Mobile robot chemist (A. Cooper, University of Liverpool). Source: [https://acceleration.utoronto.ca/maps](https://acceleration.utoronto.ca/maps)"
  recommended_prerequisites: "The **recommended prerequisite** for this course is {{ hello-world }} (Course 1: Hello  World)"
  # I am also thinking about adding: **This course requires physical hardware and a 2.4 GHz WPA-2 wireless network**. If you do not have the hardware, you will need to purchase the physical hardware associated with “Introduction to AI for Discovery using Self-driving Labs” and the the [required components](https://github.com/ac-rad/digital-pipette) for the “Digital Pipette”, replacing the 6V DC power supply with the correct style for your country (e.g., European type C), if necessary. If you do not have the required wireless network, you can use a mobile hotspot in extended compatibility mode or a SIM-enabled router (see [recommendations](https://github.com/sparks-baird/self-driving-lab-demo/discussions/83) for more information).
  learning_outcomes:
    - "Design and execute software to manage a peristaltic pump's operations using a microcontroller and motor driver, demonstrating application and integration skills"
    - "Construct the \"Digital Pipette\" and develop software to manipulate the linear actuator, showcasing capabilities in hardware assembly and software programming"
    - "Operate an automated liquid handler, such as Science Jubilee or Opentrons, to accurately transfer liquid between vials, demonstrating proficiency in laboratory automation techniques"
    - "Exhibit the ability to control a mobile collaborative robot (cobot) using the ROS framework, reflecting advanced understanding and operational skills in robotics"
    - "Showcase the use of OpenCV and AprilTags for spatial referencing and ID lookup, illustrating advanced skills in computer vision and object identification"
    - "Configure and utilize ROS, AprilTags, and a multi-axis robot to execute solid sample transfers, demonstrating integrated skills in robotics programming and operation"
  competencies_skills:
    - "Motor drivers"
    - "Serial communication"
    - "Automated liquid handlers"
    - "Robotic control"
    - "Robotic simulation"
    - "Computer vision"
    - "Automated solid handlers"
  course_assessments_and_grading_schema: "{{ courses.hello-world.course_assessments_and_grading_schema }}"
  developers:
    - "Sterling Baird, PhD Materials Science and Engineering (Acceleration Consortium)"
  module_note: "Each module is intended to take approximately 3-4 hours, assuming that the recommended prerequisites have been met."
  modules:
    - module_name: "3.0 Orientation"
      tutorial_file: 3.0-orientation.md
      topics:
        - "Git"
        - "GitHub"
        - "Version control"
        - "GitHub Classroom"
        - "Codespaces"
      learning_outcomes:
        - "Describe the purpose of Git and GitHub"
        - "Create a GitHub account and a repository"
        - "Commit, push, and pull changes"
        - "Run a unit test and fix a simple Python function"
        - "Define continuous integration"

    - module_name: "3.1 Pumps and Pipettes"
      tutorial_file: "3.1-pumps-and-pipettes.md"
      topics:
        - "Workflow orchestration"
        - "Microcontrollers"
        - "Peristaltic pumps"
        - "Linear actuators"
        - "Motor drivers"
      learning_outcomes:
        - "Implement software to control a peristaltic pump via a microcontroller and a motor driver"
        - "Build the \"Digital Pipette\" and implement software to control the linear actuator"

    - module_name: "3.2 Serial communication"
      tutorial_file: 3.2-serial-communication.md
      topics:
        - "Mass balance"
        - "Serial communication"
        - "Reading data"
      learning_outcomes:
        - "Design and execute software to read data from a mass balance using serial communication"

    - module_name: "3.3 Liquid Handlers"
      tutorial_file: 3.3-liquid-handlers.md
      topics:
        - "Workflow orchestration"
        - "Jubilee"
        - "Opentrons"
      learning_outcomes:
        - "Perform liquid transfer between vials with an automated liquid handler (Science Jubilee and OT-2)"

    - module_name: "3.4 Mobile robotics"
      tutorial_file: 3.4-mobile-robotics.md
      topics:
        - "ROS"
        - "Isaac Sim"
        - "Asynchronous task execution"
        - "Prefect"
      learning_outcomes:
        - "Demonstrate control of a mobile cobot using frameworks such as the Robot Operating System (ROS) and Isaac Sim"
        - "Use a workflow orchestration package to manage asynchronous tasks"
        - "Define asynchrony in the context of hardware control for automonous laboratories"

    - module_name: "3.5 Computer vision"
      tutorial_file: 3.5-computer-vision.md
      topics:
        - "OpenCV"
        - "AprilTags"
      learning_outcomes:
        - "Demonstrate spatial referencing and ID lookup by using OpenCV and AprilTags"
        - "Use a motorized microscope and OpenCV to search for regions of interest in a sample"

    - module_name: "3.6 Solid sample transfer"
      tutorial_file: 3.6-solid-sample-transfer.md
      topics:
        - "Workflow orchestration"
        - "ROS"
        - "AprilTags"
        - "Multi-axis robotics"
      learning_outcomes:
        - "Use ROS, AprilTags, a multi-axis robot, and a workflow orchestration platform to perform solid sample transfer"

software-dev:
  course_shortname: "Software Development"
  course_title: "Software Development for Self-driving Labs"
  course_emoji: "🧑‍💻"
  registration_link: "https://learn.utoronto.ca/programs-courses/courses/4133-software-development-self-driving-labs"
  # waitlist_link: "https://2learn.utoronto.ca/public/student/studentRequestInformation.do?method=edit&type=0&courseNumber=134035551"
  orientation_ref: "4.0-orientation"
  short_description: ""
  description: "Elevate your software development skills in the context of self-driving laboratories. This asynchronous, remote course introduces software development concepts and best practices and productivity tools such as integrated development environments (IDEs) with VS Code, unit testing with pytest, continuous integration via GitHub actions, and documentation creation using Sphinx and Read the Docs. You'll also learn to deploy materials discovery campaigns on cloud servers or dedicated hardware and run offline simulations using cloud hosting."
  media_command: ""
  media_caption: ""
  recommended_prerequisites: "The **recommended prerequisite** for this course is {{ hello-world }} (Course 1: Hello World)"
  learning_outcomes:
    - "Enumerate and explain software development best practices along with their corresponding benefits, demonstrating understanding and recall"
    - "Identify and evaluate various productivity tools for developers, highlighting how they enhance efficiency, to demonstrate analytical and selection skill"
    - "Compose and execute unit tests using pytest to validate code functionality, demonstrating application and analysis skills in software testing"
    - "Generate comprehensive Python documentation utilizing Sphinx and Read The Docs, illustrating proficiency in documentation practices and tools"
    - "Design and deploy a continuous integration (CI) pipeline using GitHub Actions, showcasing the ability to integrate and automate software development processes"
    - "Construct a reusable project template using PyScaffold, demonstrating skills in enhancing project setup efficiency and standardization"
    - "Initiate and manage a cloud or local hardware server to execute a materials discovery campaign, demonstrating capabilities in server management and deployment for scientific computing"
    - "Set up and execute an offline simulation on a cloud hosting service, illustrating the ability to leverage cloud resources for complex computational tasks"
  competencies_skills:
    - "Software development literacy"
    - "Version control"
    - "Unit testing"
    - "Documentation"
    - "Compute hardware"
    - "Cloud computing"
  course_assessments_and_grading_schema: "{{ courses.hello-world.course_assessments_and_grading_schema }}"
  developers:
    - "Sterling Baird, PhD Materials Science and Engineering (Acceleration Consortium)"
    - "Sissi Feng, PhD Electrical and Computer Engineering (Acceleration Consortium)"
  module_note: "Each module is intended to take approximately 3-4 hours, assuming that the recommended prerequisites have been met."
  modules:
    - module_name: "4.0 Orientation"
      tutorial_file: 4.0-orientation.md
      topics:
        - "Git"
        - "GitHub"
        - "Version control"
        - "GitHub Classroom"
        - "Codespaces"
      learning_outcomes:
        - "Describe the purpose of Git and GitHub"
        - "Create a GitHub account and a repository"
        - "Commit, push, and pull changes"
        - "Run a unit test and fix a simple Python function"
        - "Define continuous integration"
    - module_name: "4.1 Deep dive into Git and GitHub"
      tutorial_file: 4.1-github-deep-dive.md
      topics:
        - "GitHub issues"
        - "Pull requests"
        - "Collaborative coding"
        - "Branches"
        - "Merge conflicts"
        # - "Project management"
      learning_outcomes:
        - "Open a GitHub issue on a repository"
        - "Create a new branch"
        - "Merge a GitHub pull request"
        - "Resolve a merge conflict"
    - module_name: "4.2 Setting up VS Code"
      tutorial_file: 4.2-vscode-setup.md
      topics:
        - "IDEs"
        - "Miniconda"
        - "VS Code extensions"
        - "Black formatting"
        - "Pylance"
        - "GitHub Copilot Chat"
        - "MicroPico"
        - "SSH"
        - "autoDocstring"
      learning_outcomes:
        - "Set up VS Code"
        - "Install Miniconda"
        - "Install VS Code extensions"
    - module_name: "4.3 Debugging in VS Code"
      tutorial_file: 4.3-vscode-debugging.md
      topics:
        - "Print statements"
        - "Setting breakpoints"
        - "Inspecting variables"
        - "Stepping through code"
        - "Debug console"
        - "Debug configurations"
      learning_outcomes:
        - "Use print statements to debug code"
        - "Set breakpoints"
        - "Inspect variables"
        - "Step through code"
        - "Use the debug console"
        - "Set up debug configurations"
    - module_name: "4.4 Unit testing"
      tutorial_file: 4.4-unit-testing.md
      topics:
        - "pytest"
        - "Test result interpretation"
        - "Debugging"
        - "Test-driven development"
      learning_outcomes:
        - "Explain the purpose of unit tests"
        - "Write unit tests for the light-mixing demo"
        - "Run and interpret unit tests to fix code"
        - "Explain test-driven development"
      tutorial:
        - "gentle introduction to unit tests: https://colab.research.google.com/gist/sgbaird/46f29843ac1634653a2f9a530eb78c74/gentle-intro-to-unit-tests.ipynb"
    # Coding best practices? (e.g., modularity, readability, PEP8, object-oriented programming, etc.)
    # Linting and code formatting? (e.g., black, flake8, isort, etc., especially VS Code Extensions)
    # VS Code extensions? (e.g., Python, Jupyter, Git, etc.)
    - module_name: "4.5 Automated docs"
      tutorial_file: 4.5-automated-docs.md
      topics:
        - "Markdown"
        - "Documentation as code"
        - "Docstrings"
        - "Sphinx"
        - "Readthedocs"
      learning_outcomes:
        - "Write documentation in Markdown"
        - "Explain what documentation as code means"
        - "Write a docstring for a Python function"
        - "Set up a readthedocs account and publish a readthedocs page"
      tutorial:
        - "GitHub-flavored Markdown tutorial"
    - module_name: "4.6 Continuous integration"
      tutorial_file: 4.6-continuous-integration.md
      topics:
        - "Continuous integration"
        - "GitHub actions"
        - "Unit tests"
        - "Documentation"
      learning_outcomes:
        - "Explain the purpose of continuous integration"
        - "Set up a GitHub actions workflow"
        - "Run unit tests and documentation builds on GitHub actions"
    - module_name: "4.7 Project templates"
      tutorial_file: 4.7-project-templates.md
      topics:
        - "PyScaffold"
        - "Cookiecutter"
        - "Project initialization"
        - "Project adaptation"
        - "Python packages"
        - "PyPi"
        - "Dependency management"
      learning_outcomes:
        - "Create a project template using PyScaffold"
        - "Add project content"
        - "Publish a Python package to PyPI"
        - "Outline the key benefits of dependency management during software development"
    - module_name: "4.8 Launching a free cloud server"
      tutorial_file: 4.8-cloud-server.md
      topics:
        - "Serverless computing"
        - "PythonAnywhere"
        - "Hugging Face"
        - "Deploying Applications"
      learning_outcomes:
        - "Launch a free cloud server"
        - "Use a container"
        - "Create a container"
        - "Deploy a materials discovery campaign on a cloud server"
    - module_name: "4.9 On-demand cloud simulations"
      tutorial_file: 4.9-cloud-simulations.md
      topics:
        - "Cloud computing"
        - "Setting up an AWS account"
        - "AWS Lambda"
        - "Docker containers"
        - "Apptainer"
        - "Prefect"
      learning_outcomes:
        - "Run an on-demand cloud simulation"
        - "Integrate a cloud simulation into a materials discovery campaign"

capstone:
  course_shortname: "Design Project"
  course_title: "AC Training Lab Design Project"
  course_emoji: "🏢"
  # registration_link: "https://learn.utoronto.ca/programs-courses/courses/4134-acceleration-consortium-training-lab-design-project"
  waitlist_link: "https://2learn.utoronto.ca/public/student/studentRequestInformation.do?method=edit&type=0&courseNumber=134035796"
  description: "Turn your self-driving lab expertise into a real-world project. During this course, you will propose, design, and build a self-driving laboratory at the AC training lab equipped with education- and research-grade equipment including liquid handlers, solid dispensers, Cartesian-axis systems, and mobile robotic arms. Prior to arrival, you'll create schematic figures, write white papers, and present your proposals to a team of scientists. During a week-long in-person experience, you'll implement your proposal and document your progress. After the visit, you will share your designs, data, and documentation to contribute to the public knowledge base."
  media_command: ""
  media_caption: ""
  recommended_prerequisites: "💡 {{ hello-world }}<br>📈 {{ data-science }}<br>🦾 {{ robotics }}<br>🧑‍💻 {{ software-dev }}"
  learning_outcomes:
    - "Create and illustrate a detailed schematic figure to propose a self-driving lab"
    - "Compose a concise white paper on the self-driving laboratory"
    - "Deliver a persuasive and clear presentation of the self-driving lab proposal to a team of scientists"
    - "Develop and implement a design project at the AC Training Lab, demonstrating applied knowledge, problem-solving, and project management skills"
    - "Compile a detailed project update, including proposed next steps, to demonstrate strategic planning and the ability to evaluate ongoing progress"
    - "Exhibit and disseminate the project's designs, data, and documentation publicly"
  competencies_skills:
    - "Scientific communication"
    - "Systems design"
    - "Dissemination"
    - "Interdisciplinary teamwork"
  course_assessments_and_grading_schema: "Performance in this course is assessed via rubrics that evaluate the quality of the proposal, design/build, and stages. The proposal rubric evaluates the schematic figure, white paper, and presentation. The design rubric evaluates the design, implementation, and documentation. The build rubric evaluates the build, implementation, and documentation. Each module is worth 100 points."
  developers:
    - "Sterling Baird, PhD Materials Science and Engineering (Acceleration Consortium)"
  module_note: "This course is expected to take approximately 40 hours to complete."
  modules:
    - module_name: "Project proposal"
      topics:
        - "Figures"
        - "White papers"
        - "Presentations"
      learning_outcomes:
        - "Propose a self-driving lab via a schematic figure"
        - "Write a white paper for the self-driving laboratory"
        - "Present the proposal to a team of scientists"
    - module_name: "Design and execution"
      topics:
        - "SDL design"
        - "Implementation"
        - "Documentation"
      learning_outcomes:
        - "Design and execute the project at the AC training lab"
        - "Provide a project update with proposed next steps"
    - module_name: "Dissemination"
      topics:
        - "Project update"
        - "Knowledge sharing"
        - "Data and documentation"
      learning_outcomes:
        - "Share the designs, data, and documentation publicly"