Introduction To Ai And Machine Learning With Go (Golang)

Learn the fundamentals of Artificial Intelligence and Machine Learning and apply them to your Go programs.

What you'll learn

Learn the basic principles of artificial intelligence

Learn AI search algorithms (BFS, DFS, GBFS, Dijkstra & A* Search)

Learn the basic principles behind machine learning

Learn about creating worlds with rules for artificial intelligence

Learn how to manage probability with artificial intelligence

Learn how to train a model using linear regression and multiple linear regression

Learn how to implement and use a neural network

Learn how to connect to and use remote models on services like Hugging Face

Learn how to integrate a Go application with LLMs like ChatGPT, and locally hosted LLMs

Requirements

A basic understanding of the Go programming knowledge

A basic understanding of the Python programming language

Ideally, a computer with a GPU (helpful, but not strictly necessary)

Description

Are you a Go developer ready to explore the exciting world of AI and machine learning? This course is your comprehensive guide, designed specifically for Gophers who want to add powerful AI skills to their toolkit. Much of the code in this course is written in Go, but some of it is written in Python, where it makes sense to do so, and this means that before taking this course you should have a basic understanding of both languages.We'll start with fundamental AI concepts, building a strong foundation with practical, hands-on projects. Then, we'll dive into the world of machine learning, tackling everything from classic regression models to modern neural networks. You'll learn how to leverage Go for high-performance AI applications, and discover how to integrate it with Python and cutting-edge tools like Hugging Face and LLMs for state-of-the-art solutions.What You'll LearnSearch Algorithms & Intelligent Agents: Master core AI search algorithms like A* and Dijkstra's by solving mazes and building a robot vacuum. Propositional Logic & Model Checking: knowledge based AI agents often need to make decisions based on available information in the world they operate in. Propositional logic and model checking are two different approaches to solving this problem.Uncertainty: Learn how AI agents handle randomness by creating a Battleship AI and a card-counting Blackjack player.Machine Learning Fundamentals: Get a practical understanding of linear regression by building models in both Python and Go to predict housing prices.Deep Learning & Neural Networks: Build a neural network from scratch for housing price prediction and a Convolutional Neural Network (CNN) for image classification.Natural Language Processing (NLP): Discover the power of NLP by creating an extractive summarization program in Go. You'll also learn to interface with external models from Hugging Face and harness the power of Large Language Models (LLMs) to create hybrid summarization systems.Large Language Models (LLMs): Learn how to connect your Go programs to Large Language Models like ChatGPT. We'll use a locally hosted LLM using Ollama, but the code we write will be 100% compatible with OpenAI, which is used to connect to most LLMs.Course RequirementsThis course is for intermediate to advanced Go developers. You should be comfortable with Go syntax and core concepts. A basic understanding of data structures like graphs and trees is also helpful, but not required. You should also have a basic understanding of Python.All you need is a computer running Windows, macOS, or Linux. While a GPU will speed up certain deep learning tasks, it is not essential; everything will run on a CPU.Why This Course?This isn't just another machine learning course; it's tailored for Go programmers. You'll learn how to build production-ready AI and machine learning applications that leverage Go's performance and concurrency. By the end, you'll have a portfolio of projects and the skills to confidently build your own intelligent applications.Ready to build the future of AI with Go? Enroll now and start your journey!

Overview

Section 1: Introduction

Lecture 1 Introduction

Lecture 2 A bit about me

Lecture 3 Installing Go

Lecture 4 Installing an IDE

Lecture 5 Setting up VS Code for Python

Section 2: Search and Artificial Intelligence Part I

Lecture 6 What we'll cover in this section

Lecture 7 Defining a maze

Lecture 8 Loading the maze from disk

Lecture 9 Uninformed Search

Lecture 10 Getting started with Depth First Search (DFS)

Lecture 11 Trying out our DFS algorithm

Lecture 12 Adding image output to our project

Lecture 13 Producing an animation of the maze solving process

Lecture 14 Implementing Breadth First Search (BFS)

Lecture 15 Implementing Dijkstra's Search

Lecture 16 Adding the Manhattan Cost to our generated images

Lecture 17 Informed Search

Lecture 18 Implementing Greedy Best First Search (GBFS)

Lecture 19 A* Search: an Overview

Lecture 20 Implementing A* Search

Lecture 21 Adding obstructions to our maze

Lecture 22 Calculating cost with obstructions

Lecture 23 Summary

Section 3: Search and Artificial Intelligence - Part II

Lecture 24 What we'll cover in this section

Lecture 25 Getting started with our robot vacuum

Lecture 26 Loading the Room configuration

Lecture 27 Getting started printing the room to the terminal

Lecture 28 Finishing up printing the room to the terminal

Lecture 29 Loading furniture and obstacles

Lecture 30 The Random Walk algorithm overview

Lecture 31 Setting up functions that every cleaning algorithm will need

Lecture 32 Implementing A* for the Random Walk algorithm

Lecture 33 Getting started with the Random Walk algorithm

Lecture 34 Bresenham's line algorithm and moving along a line until obstructed

Lecture 35 Finishing up the CleanRandomWalk function

Lecture 36 Trying out our code with CleanRandomWalk

Lecture 37 The SLAM algorithm

Lecture 38 Getting started with the SLAM algorithm

Lecture 39 Adding neighbors to the frontier

Lecture 40 Continuing with the SLAM algorith

Lecture 41 Adding a thorough frontier check and checking for sufficient coverage

Lecture 42 Finishing up and trying our SLAM algorithm

Lecture 43 The Spiral Algorithm

Lecture 44 Getting started with the Spiral algorithm

Lecture 45 Finding the room center and creating a spiral pattern

Lecture 46 Finishing up the Spiral alogorithm

Lecture 47 The Snaking (or Boustrophedon path) algorithm

Lecture 48 Getting started with the Snaking algorithm

Lecture 49 Finishing up the Snaking algorithm

Lecture 50 Adding obstacle recognition

Lecture 51 Complicating matters with a Cat

Lecture 52 Finishing up the Cat logic

Section 4: Knowledge Based Agents: Propositional Logic

Lecture 53 What we'll cover in this section

Lecture 54 Getting started with multiple rooms

Lecture 55 Getting the code working for multiple rooms, but without logic

Lecture 56 Defining our truth table and rules for propositional logic

Lecture 57 Getting started with our logical world

Lecture 58 Finishing up the methods for our logical world

Lecture 59 Getting started with our logic enabled robot

Lecture 60 Trying out our new logic aware robot and world

Lecture 61 Finishing up the propositional logic robot

Section 5: Knowledge Based Agents: Model Checking

Lecture 62 What we'll build in this section

Lecture 63 Getting started with our code

Lecture 64 Loading applicants from the CSV file

Lecture 65 Setting up the fairness property

Lecture 66 Setting up the risk property

Lecture 67 Finishing up our model checking logic and trying things out

Section 6: Artificial Intelligence and Uncertainty I

Lecture 68 What we'll cover in this section

Lecture 69 Getting started with our Battleship game

Lecture 70 Setting up the Human player

Lecture 71 Setting up the AI player

Lecture 72 Placing the AI player's ships

Lecture 73 Placing the Human player's ships

Lecture 74 Letting the Human player take a turn

Lecture 75 Getting started with letting the AI player take a turn

Lecture 76 Setting up huntModeBoosts

Lecture 77 Finishing up letting the AI player take a turn

Lecture 78 Displaying the heat map and trying things out

Lecture 79 Improving our heatmap functionality

Lecture 80 Sinking ships

Lecture 81 Trying out the finished game

Section 7: Artificial Intelligence and Uncertainty II

Lecture 82 What we'll cover in this section

Lecture 83 Getting started with our Blackjack game

Lecture 84 Clearing the screen, creating a deck of cards, and shuffling them

Lecture 85 The strategy our card counter will use

Lecture 86 Card counting abilties for our AI player

Lecture 87 Checking if the deck needs re-shuffled and creating players

Lecture 88 Dealing cards to all three players and calculating scores

Lecture 89 Displaying the players' hands

Lecture 90 Playing a round for the Human player

Lecture 91 Playing a round for the AI player

Lecture 92 Playing a round for the Dealer and trying things out

Section 8: Machine Learning in Python (supervised): Linear & Multiple Linear Regression

Lecture 93 What we'll cover in this section

Lecture 94 Getting started with our program: loading and pre-processing the data

Lecture 95 Prepare data for modeling, split data, and train the model

Lecture 96 Evaluating our model

Lecture 97 Print the results of our training to the console

Lecture 98 Display a visualization of the data

Lecture 99 Predict a house's price based on data outside our dataset

Lecture 100 Getting started with Multiple Linear Regression in Python

Lecture 101 Implement data processing capabilities

Lecture 102 Develop the model operations - Part I

Lecture 103 Develop the model operations - Part II

Lecture 104 Trying out the code we've written so far

Lecture 105 Visualization: Display Results

Lecture 106 Creating data for visualizations

Lecture 107 Creating a 2d visualization

Lecture 108 Creating a 3d visualization

Section 9: Machine Learning in Go (supervised): Linear & Multiple Linear Regression

Lecture 109 What we'll cover in this section

Lecture 110 Getting started with our program: parsing command line flags

Lecture 111 Setting up types, and loading and validating data

Lecture 112 Setting up the Linear Regression Type, and persisting model data

Lecture 113 Loading data and printing summary info

Lecture 114 Setting up a Model handler and trying out loading data

Lecture 115 Normalize Features

Lecture 116 Training the model

Lecture 117 Displaying trained model information

Lecture 118 Trying out training a model

Lecture 119 Saving and Loading a trained model

Lecture 120 Setting up a Predict method on the LinearRegression type

Lecture 121 Setting up the handlePrediction function

Lecture 122 Displaying Predictions

Lecture 123 Installing a sidecar application to create a visualization of the data (plot)

Lecture 124 Writing the Go code to call the sidecar application: Part I

Lecture 125 Writing the Go code to call the sidecar application: Part II

Lecture 126 Trying out our plotting functionality

Lecture 127 Updating our Python app to save to JSON format

Lecture 128 Loading a model trained in Python in our Go application

Section 10: Machine Learning: Neural Networks

Lecture 129 What we'll cover in this section

Lecture 130 Setting up a Python project for a Neural Network

Lecture 131 Loading and preprocessing our data

Lecture 132 Trying out loading data

Lecture 133 Setting up the rest of our command line flags

Lecture 134 Getting started with training our neural network

Lecture 135 Setting up the training loop

Lecture 136 Trying out the training loop

Lecture 137 Saving the trained model

Lecture 138 Loading a saved ONNX file and making predictions

Lecture 139 Trying out our prediction function

Lecture 140 Cats vs Dogs: Convolutional Neural Networks

Lecture 141 Getting started with our CNN

Lecture 142 Setting up GPUs, if available

Lecture 143 Getting started with training our model: loading data

Lecture 144 Defining our neural network

Lecture 145 Setting up the forward pass for our network

Lecture 146 Setting up the loss function, optimizer, and learning rate scheduler

Lecture 147 Setting up the train_model function

Lecture 148 Implementing early stopping

Lecture 149 Best model restoration

Lecture 150 Saving model state

Lecture 151 Setting up inference

Lecture 152 Trying things out

Section 11: Natural Language Processing: Extractive Summarization

Lecture 153 What we'll cover in this section

Lecture 154 Getting started with our text summarization package

Lecture 155 Setting up a simple application

Lecture 156 Getting started with the summarizer module

Lecture 157 Configuring our summarizer

Lecture 158 Getting started with extractive summarization

Lecture 159 Getting Named Entities

Lecture 160 Calculate sentence position weights

Lecture 161 Create a map of sentences containing important entities

Lecture 162 Find title keywords if available

Lecture 163 Create a graph representation for TextRank-like algorithm

Lecture 164 Analyze sentence relationships

Lecture 165 Named entity scoring

Lecture 166 Title keyword overlap

Lecture 167 Textrank-like score using similarity matrix

Lecture 168 Cohesion score, sentence scoring, and taking top-ranked sentences

Lecture 169 Extracting keywords

Lecture 170 Implementing GetResponse

Lecture 171 Setting up the web app

Lecture 172 Calling the summarizer package from the web app

Section 12: Natural Language Processing: Interfacing with Hugging Face

Lecture 173 Getting a Hugging Face API key

Lecture 174 Setting up a Taskfile

Lecture 175 Setting up Hugging Face in the summarizer package

Lecture 176 Setting up the summarizer function for Hugging Face

Lecture 177 Updating GenerateSummary for Hugging Face

Lecture 178 Setting up Hugging Face in the web app

Lecture 179 Trying things out

Section 13: Natural Language Processing: Summarizing text using LLMs

Lecture 180 Installing and configuring Ollama

Lecture 181 Setting up OpenAI in the summarizer package

Lecture 182 Updating GenerateSummary for OpenAI

Lecture 183 Update the web app for OpenAI

Lecture 184 Trying things out

Section 14: Natural Language Processing: Hybrid Summarization

Lecture 185 Setting up hybrid summarization in the summarizer package

Lecture 186 Updating GenerateSummary for Hybrid summaries

Lecture 187 Update the web app for Hybrid summaries

Lecture 188 Implementing CLI mode

Developers who want to see how AI & Machine Learning can improve their development skills while working in the Go programming language.