Getting Started with CS6601 Assignment 0: Python, Git, Jupyter & Gradescope Setup (Spring 2025)

Introduction: Why Assignment 0 Matters

In Spring 2025, OMSCS students taking CS6601 (Artificial Intelligence) begin their journey with Assignment 0. This isn't a typical problem set—it's a warm-up designed to ensure your local Python environment, Git workflow, and Jupyter notebooks are ready for the semester. Think of it as the pre-season training camp for an AI engineer: without a solid setup, you can't score points on later assignments. Let's walk through each step, from cloning repositories to making your first Gradescope submission.

Setting Up Your Python Environment

Before cloning any code, you need a working Python environment. The official CS6601 environment setup guide (linked in the README) walks you through installing Miniconda or Anaconda and creating a dedicated environment called ai_env. This isolates your dependencies, much like how a gaming console keeps its OS separate from game data—no conflicts, smooth performance.

Once Conda is installed, create the environment:

conda create -n ai_env python=3.10
conda activate ai_env

Verify Python is ready: python --version should show 3.10.x. This environment will host all packages for CS6601, including numpy, matplotlib, networkx, and pgmpy.

Getting the Repository: Git Basics

Georgia Tech provides enterprise GitHub at https://github.gatech.edu. Your repository URL uses your GT username (e.g., gburdell3). For Assignment 0, you'll clone the class repo and optionally create a private fork to avoid OSI violations.

Cloning the Assignment 0 Repository

Open a terminal, navigate to your projects folder, and run:

git clone https://github.gatech.edu/omscs6601/assignment_0.git

This downloads the starter code, including notebook.ipynb and requirements.txt. Enter the directory: cd assignment_0.

Creating a Private Fork (Optional but Recommended)

If you plan to modify code and push changes, fork the repo privately. Follow these steps (mirroring the official instructions):

1. Create a new private repository on github.gatech.edu (e.g., cs6601_a0).
2. Clone the bare class repo: git clone --bare https://github.gatech.edu/omscs6601/assignment_0.git
3. Mirror to your private repo: cd assignment_0.git && git push --mirror https://github.gatech.edu/gburdell3/cs6601_a0
4. Delete the bare clone: cd .. && rm -rf assignment_0.git
5. Clone your private repo: git clone https://github.gatech.edu/gburdell3/cs6601_a0
6. Add upstream remote: cd cs6601_a0 && git remote add upstream https://github.gatech.edu/omscs6601/assignment_0.git

Now you can pull updates from upstream without pushing there accidentally. Disable push to upstream using: git remote set-url --push upstream PUSH_DISABLED.

Installing Packages with pip

With your environment active and terminal in the repo directory, install dependencies:

pip install -r requirements.txt

This installs jupyter, numpy, matplotlib, networkx, pandas, and pgmpy. These are the core libraries for AI algorithms—numpy for matrix operations, networkx for graph structures, and pgmpy for probabilistic graphical models. After installation, run pip freeze to see the full list. It's like checking your inventory before a hackathon: you want to know what tools you have.

Launching Jupyter Notebook

Jupyter notebooks combine code, visualizations, and text in an interactive document. For Assignment 0, you'll complete tasks inside notebook.ipynb. Launch it with:

jupyter notebook

This opens a browser tab at http://localhost:8888. Click on notebook.ipynb. You'll see cells containing instructions and code stubs. Execute cells with Shift+Enter. The notebook environment is similar to Google Colab, but local—faster and more private.

Assignment 0: What You Need to Do

The notebook guides you through Python refresher exercises. You'll implement a priority queue (using heapq) and a simple submission script. Upon completion, you'll produce two files: first_submission.py and priority_queue.py. Upload these to Gradescope under the Assignment 0 entry. This submission is worth 2 points—small but essential for verifying your pipeline.

Priority Queue Implementation

A priority queue is a data structure that always returns the element with the highest (or lowest) priority. In CS6601, you'll use them for search algorithms like A*. Think of it like a ticket queue for a popular AI conference: VIP passes (high priority) get served first. Python's heapq module implements a min-heap. Your task is to wrap it with methods push, pop, and is_empty. Example stub:

import heapq

class PriorityQueue:
    def __init__(self):
        self._queue = []
        self._index = 0

    def push(self, item, priority):
        heapq.heappush(self._queue, (priority, self._index, item))
        self._index += 1

    def pop(self):
        return heapq.heappop(self._queue)[-1]

    def is_empty(self):
        return len(self._queue) == 0

This pattern ensures stable ordering when priorities tie.

Testing and Submission

After completing the notebook, run the provided test cells to verify your code. Then, follow the notebook's export instructions to generate the two .py files. Log into Gradescope via Canvas, find CS6601 Assignment 0, and upload both files. The autograder will run tests and give immediate feedback. If you see errors, check your environment or code—common issues include missing imports or incorrect function signatures.

Troubleshooting Common Pitfalls

• Environment not activated: Always run conda activate ai_env before installing packages or launching Jupyter.
• Port conflict: If Jupyter fails to start, try jupyter notebook --port=8889.
• Git push denied: Ensure you're pushing to your private repo, not the class upstream.
• ImportError: Reinstall packages with pip install -r requirements.txt --force-reinstall.

Conclusion: Ready for the Semester

Completing Assignment 0 ensures your toolchain works—Python, Git, Jupyter, and Gradescope. This foundation is critical for later assignments where you'll implement search algorithms, Bayesian networks, and reinforcement learning. By mastering these basics now, you avoid tech delays when deadlines loom. For more help, check the course's Ed Discussion or office hours. Good luck, and happy coding!