Explore

s24 AML3304 Day Lesson Plans

⁠

https://cestarcollege.adobeconnect.com/⁠

⁠

June 21

AM Class s1

s24 JUNE 21 AML 3304 s1 FRI AM

https://moodle.cestarcollege.com/moodle/course/view.php?id=22839⁠

⁠

https://cestarcollege.adobeconnect.com/rtvhlx6uh3d2/⁠

⁠

PM Class

https://moodle.cestarcollege.com/moodle/course/view.php?id=22843⁠

⁠

AML 3304 s3 FRI PM

Prepare for the Mid Term Exam after reading week break

Work on the Embeddings Assignment

June 14

Today's focus topic: The Build process for the AI language model (which is CI CD)

The application of GIT as a software development project management methodology - Git Issues and Git Actions

Hugging Spaces Lab

Today’s Work:

⁠

https://coda.io/@peter-sigurdson/harnessing-git-issues-and-github-actions-for-efficient-project-m⁠

⁠

https://coda.io/@peter-sigurdson/practice-lab-using-git-issues-and-actions⁠

⁠

Introduction to Managing Code with Git

Why Managing Code with Git is Essential

Welcome to our introductory lecture on managing code with Git.

As we embark on our journey to build AI applications, understanding and utilizing Git will be pivotal to our success.

Both for software engineering and as software engineering tool

Git, as a version control system, offers numerous advantages that are essential for efficient and effective development, particularly in the context of AI and machine learning.

Let's explore why Git is indispensable for our work and how it integrates with various tools and practices essential for AI application development.

1. Collaborative Coding with Git

**Version Control:** - **Purpose:** Version control systems like Git help track changes to your codebase, allowing multiple developers to work on the same project simultaneously without conflicts. - **Collaboration:**

Git enables seamless collaboration among team members. Every change is tracked, which means you can see who made what changes and when. - **Branching and Merging:** Git's branching model allows you to experiment with new features safely. You can create branches, make changes, and merge them back into the main branch once they're stable.

**Practical Application:** - **Example:** In a collaborative AI project, one team member might be working on the data preprocessing pipeline while another works on model training. Git allows both to work independently and merge their changes seamlessly.

2. Using Git Issues and Git Actions in IT Project Management

**Git Issues:** - **Purpose:** GitHub Issues is a robust tool to create, track, share:

tasks, bugs, and feature requests.

— AS well as having a knowledge sharing tool to share updated learning and understanding of how our Business Domain and SUD operate.

- **Project Management:**

It helps in organizing and prioritizing work, ensuring that all team members are on the same page regarding project progress and outstanding tasks.

The Tracability Matrix provides a visual Dashboard of the project’s health and progress.

Issues and Actions are knowledge inputs to keep our attention focused on which parts of the Tracability Matrix we need to focus on today.

**Git Actions:** - **Purpose:**

GitHub Actions is a powerful automation tool that integrates with your GitHub repository. Actions work with a Scripting language called YAML (Yet Another Markup Language) to cause actions to run in response to triggering events occuring.

- **Automation:** You can automate workflows for continuous integration (CI) and continuous deployment (CD), testing, and other repetitive tasks.

**Practical Application:** - **Example:** For our AI model, we can use GitHub Issues to track tasks such as "collect dataset," "preprocess data," "train model," and "evaluate model."

Actions can automatically run tests on every commit, ensuring that changes do not break the codebase.

3. Marshaling Code in a Git Repository for HuggingFace Spaces

**HuggingFace Spaces:**

- **Purpose:** HuggingFace Spaces provides a platform to deploy AI models and applications.

- **Integration:**

Managing your code in a Git repository makes it easier to deploy on platforms like HuggingFace Spaces, which often integrate directly with GitHub.

**Practical Application:** - **Example:**

By maintaining your code on GitHub, you can directly deploy your AI model to HuggingFace Spaces, making it accessible and usable by others in the community.

4. Continuous Integration and Continuous Deployment (CI/CD)

**CI/CD:**

- **Continuous Integration (CI):**

Automates the process of integrating code changes from multiple contributors into a shared repository several times a day.

Automated tests run with each integration to detect issues early.

- **Continuous Deployment (CD):**

Automates the deployment of applications to production environments, ensuring that every change that passes all stages of the production pipeline is released to users.

**Why CI/CD is Essential:**

- **Efficiency:** CI/CD pipelines help detect and address issues early, reducing the risk of integration problems.

- **Speed:** Automating the build, test, and deployment process speeds up the development cycle.

- **Reliability:**

Consistent and repeatable processes increase the reliability of deployments.

**Practical Application:**

- **Example:**

For our AI model, a CI pipeline can automate the testing of model performance with each new dataset or algorithm tweak, while a CD pipeline can deploy the latest stable model to a production environment or a HuggingFace Space.

### Conclusion

Managing code with Git is not just a best practice; it is essential for our AI application development.

It facilitates collaboration, enhances project management through issues and actions, enables seamless integration with deployment platforms like HuggingFace Spaces, and supports efficient CI/CD workflows.

** Feature Engineering **

By mastering Git, we ensure that our development process is smooth, efficient, and scalable, ultimately leading to the successful deployment of robust AI models.

As we proceed with our labs and projects, we will delve deeper into each of these aspects, gaining hands-on experience and understanding the critical role Git plays in the world of AI development.

Sync’ing local with Cloud GitHUB Repositories

⁠

https://coda.io/@peter-sigurdson/to-resolve-the-authentication-issue-youre-experiencing-with-push⁠

⁠

Introduction to Git and GitHub:

Explain the concepts of version control, Git, and GitHub.

Discuss the benefits of using version control systems like Git for collaborative coding.

Setting up a GitHub Repository:

Guide students on creating a new repository on GitHub.

Explain how to initialize the repository with a README file.

Cloning the Repository Locally:

Show students how to clone the GitHub repository to their local machine using the git clone command.

Making Local Changes:

Instruct students on how to make changes to files in the local repository using their preferred text editor.

Committing Changes:

Teach students how to stage and commit changes using the git add and git commit commands.

Pushing Changes to GitHub:

Demonstrate the process of pushing local changes to the remote GitHub repository using git push and using Personal Access Tokens (PAT) for authentication.

Pulling Changes from GitHub:

Explain how students can pull changes made in the remote repository to their local copy using git pull.

Testing and Synchronization:

Encourage students to test the synchronization between the local and cloud repositories by making changes in both and syncing them appropriately.

This lab should provide a hands-on experience for students to understand the workflow of syncing local and cloud repositories using Git and GitHub while also covering the use of Personal Access Tokens for authentication. Feel free to modify and expand on this outline based on your specific teaching goals and student needs. Let me know if you need more detailed instructions on any specific step!

The tools of Git and GitHub for Building the CI CD application:

This lab provides a comprehensive hands-on experience for students to understand the workflow of syncing local and cloud repositories using Git and GitHub while covering the use of Personal Access Tokens (PAT) for authentication.

---

Introduction to Git and GitHub

Version Control: - Definition: Version control is a system that records changes to files over time so that you can recall specific versions later. - Purpose: It allows multiple people to work on a project simultaneously, keeps a history of changes, and facilitates collaboration. - Examples: Git, Subversion, Mercurial.

Git: - Definition: Git is a distributed version control system designed to handle everything from small to very large projects with speed and efficiency. - Features: Tracks changes, allows for branching and merging, stores the entire history of the project.

GitHub: - Definition: GitHub is a web-based platform that uses Git for version control.

It hosts repositories, provides a web-based interface, and offers additional collaboration features. - Benefits: Facilitates collaborative coding, issue tracking, project management, code review, and integration with CI/CD pipelines.

Benefits of Version Control Systems: - Collaboration: Multiple developers can work on the same project simultaneously without conflicts. - History: Maintain a history of changes to revert to previous versions if needed. - Branching and Merging: Experiment with new features in branches and merge them into the main codebase when ready. - Backup: Acts as a backup of the entire codebase.

---

Setting up a GitHub Repository

Step-by-Step Guide:

1. Create a GitHub Account: Sign up at [GitHub](https://github.com/).

2. Create a New Repository:

- Click on the "+" icon in the top right corner and select "New repository." - Enter a repository name and description. - Choose the repository type (public or private). - Check "Initialize this repository with a README." - Click "Create repository."

---

Cloning the Repository Locally

Command: ```sh git clone https://github.com/your-username/your-repository.git ``` - Explanation: This command creates a local copy of the repository on your machine.

---

Making Local Changes

Instructions: 1. Navigate to the Repository: ```sh cd your-repository ``` 2. Edit Files: - Open files using your preferred text editor (e.g., VSCode, Sublime Text).

---

Committing Changes

Commands: 1. Stage Changes: ```sh git add . ``` 2. Commit Changes: ```sh git commit -m "Describe your changes here" ```

---

Pushing Changes to GitHub

Commands: 1. Push Changes: ```sh git push origin main ``` - Explanation: Pushes the committed changes to the remote repository on GitHub.

2. Authentication using PAT:

- Personal Access Token (PAT): Generate a PAT from your GitHub account settings and use it instead of your password when prompted.

Example Prompt: Username for 'https://github.com': your-username

Password for 'https://your-username@github.com': your-PAT

Pulling Changes from GitHub

Commands: 1. Pull Changes: ```sh git pull origin main ``` - Explanation: Fetches and merges changes from the remote repository to your local copy.

---

Using Personal Access Tokens (PAT)

Generating a PAT:

1. Log in to GitHub:

- Go to [GitHub](https://github.com/) and log in to your account.

2. Navigate to Settings:

- Click on your profile picture in the top right corner and select "Settings."

3. Access Developer Settings:

- In the left sidebar, scroll down and click on "Developer settings."

4. Create a New Token:

- Click on "Personal access tokens" and then click "Generate new token."

5. Configure Token Settings:

- Give your token a descriptive name.

- Select the scopes or permissions you need (e.g., `repo` for full control of private repositories).

- Click "Generate token."

6. Save the Token:

- Copy the generated token and save it securely. You won’t be able to see it again.

---

Testing and Synchronization

Activity:

- Simulate Collaboration: Make changes in both the local and remote repositories. - Sync Changes: Use `git pull` to bring changes from GitHub to your local repository and `git push` to send local changes to GitHub.

Experiment with Branching: 1. Create a New Branch: ```sh git checkout -b new-feature ``` 2. Make Changes in the New Branch: - Edit files and commit changes in the new branch. 3. Merge the Branch: ```sh git checkout main git merge new-feature ```

Use Issues and Actions: - Create issues for task tracking and explore GitHub Actions for CI/CD integration.

---

This comprehensive lab will provide students with a robust understanding of Git and GitHub, enabling them to handle version control effectively and authenticate using Personal Access Tokens.

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.