Explore

w25 AML3304 using GitHUB

These instructions are to get us ready to push PYTHON AI language model code to HuggingFace Spaces via GitHUB.

Lab Instruction Book: Setting Up and Using a GitHub Repository with Personal Access Token (PAT) Authentication

This lab guide will walk students through the process of creating a GitHub repository,

generating a Personal Access Token (PAT) for secure authentication, and

synchronizing a local repository with the GitHub cloud.

Follow each step carefully to ensure success.

⁠

Prerequisites

Git Installed: Ensure Git is installed on your system. You can download it from

git-scm.com⁠

GitHub Account: You must have a GitHub account. If you don’t have one, create it at

github.com⁠

Basic Command Line Knowledge: Familiarity with basic terminal commands is helpful.

⁠

Step 1: Create a New GitHub Repository

Go to

GitHub⁠

and log in with your credentials.

Create a Repository:

Click the green "New" button on the repositories page or navigate to https://github.com/new.

Fill in the repository details:

Repository Name: Enter a name for your repository (e.g., my-first-repo).

Description (optional): Add a short description.

Visibility: Choose between Public or Private.

Check the box for "Initialize this repository with a README" (optional but recommended for beginners).

Click "Create repository".

⁠

Step 2: Generate a Personal Access Token (PAT)

⁠

GitHub no longer supports password authentication for Git operations. Instead, you’ll use a PAT.

Navigate to PAT Settings:

Go to your GitHub profile and click on your avatar in the top-right corner.

⁠

Select Settings > Developer settings > Personal access tokens > Tokens (classic).

⁠

Generate a New Token:

Click "Generate new token" and select "Generate new token (classic)".

⁠

Add a Note (e.g., "Git CLI Token").

⁠

Set an Expiration Date (e.g., 30 days, 90 days, or No Expiration).

Under Scopes, check the following:

repo (for full control of private repositories).

workflow (if you plan to use GitHub Actions).

read:org (if working with organization repositories).

Click "Generate token".

Copy the Token:

Copy the token immediately. You won’t be able to see it again. Store it securely (e.g., in a password manager).

⁠

Step 3: Clone the Repository Locally

Copy the Repository URL:

Go to your repository on GitHub.

Click the green "Code" button and copy the HTTPS URL (e.g., https://github.com/username/my-first-repo.git).

Clone the Repository:

Open your terminal or command prompt.

Run the following command:

git clone https://github.com/username/my-first-repo.git

When prompted for a username and password:

Enter your GitHub username.

For the password, paste your PAT instead of your actual password.

⁠

Step 4: Link a Local Repository to GitHub

If you already have a local project and want to link it to GitHub, follow these steps:

Initialize Git in Your Local Directory:

Navigate to your project folder in the terminal:

javascript

cd path/to/your/project

Initialize Git:

javascript

git init

Add the Remote Repository:

Add the GitHub repository as the remote origin:

javascript

git remote add origin https://github.com/username/my-first-repo.git

Verify the Remote:

Check that the remote was added correctly:

javascript

git remote -v

⁠

Step 5: Push Changes to GitHub

Stage and Commit Your Changes:

Add all files to the staging area:

javascript

git add .

Commit the changes:

javascript

git commit -m "Initial commit"

Push to GitHub:

Push your changes to the remote repository:

javascript

git push -u origin main

When prompted for authentication, use your GitHub username and paste the PAT as the password.

⁠

Step 6: Pull Changes from GitHub

To synchronize your local repository with changes made on GitHub:

Pull Changes:

Run the following command:

javascript

git pull origin main

This will fetch and merge changes from the GitHub repository into your local repository.

⁠

Step 7: Automate PAT Usage (Optional)

To avoid entering your PAT every time, you can cache it securely:

Enable Credential Caching:

Run the following command:

javascript

git config --global credential.helper store

The next time you enter your PAT, it will be saved locally.

Test the Setup:

Make a small change to a file, commit it, and push it to GitHub to ensure the PAT is working correctly.

⁠

Step 8: Troubleshooting Tips

Error: Authentication Failed:

Ensure you’re using the correct PAT and that it has the required scopes.

Double-check the repository URL.

Error: Remote Repository Not Found:

Verify that the repository URL is correct and that you have access to it.

Error: Permission Denied:

Ensure your PAT has the repo scope for private repositories.

⁠

Conclusion

By following these steps, you’ve successfully created a GitHub repository, authenticated using a Personal Access Token, and synchronized your local repository with GitHub. You can now collaborate on projects securely and efficiently!

Using HuggingFace Spaces

Instructions: How to Push Python AI Language Model Code to Hugging Face Spaces via GitHub

This guide will walk you through the process of deploying your Python AI language model code to Hugging Face Spaces using GitHub.

Hugging Face Spaces is a platform for hosting and sharing machine learning demos, and it integrates seamlessly with GitHub for version control and deployment.

⁠

Prerequisites

Hugging Face Account: Create an account at

Hugging Face⁠

if you don’t already have one.

GitHub Account: Ensure you have a GitHub account and a repository for your project.

Python Environment: Your AI model code should be ready and tested locally.

Hugging Face CLI: Install the Hugging Face CLI for managing Spaces and repositories.

⁠

Step 1: Prepare Your Hugging Face Space

For next class, study these Lab Books:

⁠

https://coda.io/@peter-sigurdson/building-huggingface-spaces-with-streamlit-gradio⁠

⁠

Go to

Hugging Face Spaces⁠

and log in.

Create a New Space:

Click the "Create Space" button.

Fill in the details:

Space Name: Choose a name for your Space.

SDK: Select the appropriate SDK for your project (e.g., Gradio or Streamlit for web apps).

Visibility: Choose between Public or Private.

Click "Create Space".

Link Your Space to GitHub:

Once the Space is created, you’ll see an option to link it to a GitHub repository. Copy the GitHub repository URL for later use.

⁠

Step 2: Set Up Your GitHub Repository

Create a GitHub Repository:

Go to

GitHub⁠

and create a new repository for your project.

Initialize the repository with a README.md file.

Clone the Repository Locally:

Open your terminal and run:

javascript

git clone https://github.com/your-username/your-repo-name.git

Replace your-username and your-repo-name with your GitHub username and repository name.

Add Your Project Files:

Copy your Python AI model code and any necessary files (e.g., requirements.txt, app.py) into the cloned repository folder.

Commit and Push Your Code:

Navigate to the repository folder in your terminal:

javascript

cd your-repo-name

Stage and commit your changes:

javascript

git add .

git commit -m "Initial commit for Hugging Face Space"

Push the changes to GitHub:

javascript

git push origin main

⁠

Step 3: Configure Hugging Face Space to Use GitHub

Link GitHub Repository to Hugging Face Space:

Go back to your Hugging Face Space.

In the Space settings, find the option to link a GitHub repository.

Paste the URL of your GitHub repository and save the changes.

Set Up Deployment:

Hugging Face Spaces will automatically pull the latest code from your GitHub repository and deploy it.

Ensure your repository includes the following files:

app.py: The main script for your application (e.g., Gradio or Streamlit app).

requirements.txt: A list of Python dependencies required for your project.

⁠

Step 4: Test and Debug Your Space

Monitor Deployment:

After linking your GitHub repository, Hugging Face Spaces will automatically build and deploy your application.

Check the deployment logs in the Space settings to ensure there are no errors.

Test Your Application:

Open your Space URL (e.g., https://huggingface.co/spaces/your-username/your-space-name) and test your application.

Fix Any Issues:

If there are errors, update your code locally, commit the changes, and push them to GitHub:

javascript

git add .

git commit -m "Fix deployment issue"

git push origin main

Hugging Face Spaces will automatically redeploy the updated code.

⁠

Step 5: Maintain and Update Your Space

Update Your Code:

Make changes to your code locally, commit them, and push them to GitHub. Hugging Face Spaces will automatically redeploy the latest version.

Add New Features:

You can add new features or improve your application by updating the code in your GitHub repository.

Collaborate with Others:

Use GitHub’s collaboration features (e.g., pull requests) to work with teammates on your project.

⁠

Tips for Success

Use a README.md File: Include a detailed README.md file in your repository to explain how your application works.

Test Locally: Always test your application locally before pushing it to GitHub.

Monitor Logs: Use the deployment logs in Hugging Face Spaces to debug any issues.

By following these steps, you can successfully push your Python AI language model code to Hugging Face Spaces via GitHub and share your work with the community!

Want to print your doc?
This is not the way.

Try clicking the ⋯ next to your doc name or using a keyboard shortcut (

CtrlP

) instead.