Curriculum of our Android Studio, Java and TensorFlow course

Enroll now in our mobile machine learning masterclass to get all of these topics and learn from the comfort of your couch. Now dirt cheap at https://training.mammothinteractive.com/p/mobilemachinelearning/?product_id=509994&coupon_code=SPECIALBLOGCOUPON

Introduction to Machine Learning + Software

  • An interview with your instructor
  • Intro to the Course (9:56)
  • Update! Resources Folder

Intro to Android Studio

  • Intro and Topics List (2:25)
  • Downloading and Installing Android Studio (6:44)
  • Exploring Interface (12:12)
  • Setting up an Emulator and Running Project (6:43)

Intro to Java

  • Intro to Language Basics (2:46)
  • Variable Types (14:00)
  • Operations on Variables (10:49)
  • Array and Lists (9:26)
  • Array and List Operations (7:59)
  • If and Switch Statements (11:34)
  • While Loops (10:09)
  • For Loops (8:51)
  • Functions Intro (8:39)
  • Parameters and Return Values (7:05)
  • Classes and Objects Intro (12:13)
  • Superclass and Subclasses (11:42)
  • Static Variables and Axis Modifiers (7:27)

Intro to App Development

  • Intro to Android App Development (1:57)
  • Building Basic User Interface (12:15)
  • Connecting UI to Backend (6:12)
  • Implementing Backend and Tidying UI (9:09)

Intro to Machine Learning Concepts

  • Introduction to ML Concepts
  • Downloading and Installing PyCharm and Python (6:55)
  • Exploring PyCharm (7:48)

Python Language Basics

  • Intro and Topics List (2:40)
  • Intro to Variables (13:17)
  • Variables Operations and Conversions (12:35)
  • Collection Types (12:47)
  • Collections Operations (8:42)
  • Control Flow If Statements (12:50)
  • While and For Loops (10:44)
  • Functions (11:23)
  • Classes and Objects (15:40)
  • Source Code

Intro to TensorFlow

  • TensorFlow Intro (2:53)
  • Topics List (6:09)
  • Importing TensorFlow to PyCharm (4:25)
  • Constant Nodes and Sessions (9:01)
  • Variable Nodes (10:45)
  • Placeholder Nodes (7:35)
  • Operation Nodes (12:47)
  • Loss, Optimizers, and Training (11:56)
  • Building a Linear Regression Model (20:30)
  • Source Code

Machine Learning in Android Studio Projects

  • Introduction to Level 2 (5:15)

Introduction to Tensorflow Estimator

  • Introduction (3:08)
  • Topics List (4:12)
  • Setting up Prebuilt Estimator Model (15:15)
  • Evaluating and Predicting with Prebuilt Model (7:42)
  • Building Custom Estimator Function (10:12)
  • Testing Custom Estimator Function (7:00)
  • Summary and Model Comparison (9:46)
  • Source Code

Intro to Android ML Model Import

  • Intro and Demo (4:09)
  • Topics List (4:22)
  • Formatting and Saving Model (8:25)
  • Saving Optimized Graph File (14:48)
  • Starting Android Project (9:01)
  • Building UI (14:56)
  • Implementing Inference Functionality (9:14)
  • Testing and Error Fixing (11:01)
  • Source Files

Simple MNIST

  • Intro and Demo (3:50)
  • Topics List and Intro to MNIST Data (10:24)
  • Building Computational Graph (14:20)
  • Training and Testing Model (14:24)
  • Saving and Freezing Graph for Android Import (12:33)
  • Setting up Android Studio Project (13:07)
  • Building User Interface (15:58)
  • Loading Digit Images (10:02)
  • Formatting Image Data (10:59)
  • Making Prediction Using Model (7:32)
  • Displaying Results and Summary (13:13)
  • Source Files

MNIST With Estimator

  • Introduction (3:08)
  • Topics List (2:38)
  • Building Custom Estimator Function (15:34)
  • Building Input Functions, Training, and Testing (13:38)
  • Predicting Using Model and Model Comparisons (9:37)
  • Source Files

Build Image Recognition Apps

  • Introduction to Building Image Recognition Apps (6:34)

Weather Prediction

  • Intro and Demo (3:49)
  • Tasks List (4:36)
  • Retrieving the Data (14:00)
  • Formatting Data Sets (14:02)
  • Building Computational Graph (11:47)
  • Writing, Training, Testing, and Evaluating Functions (12:24)
  • Training, Testing, and Freezing the Model (9:48)
  • Setting up Android Project (8:05)
  • Building the UI (15:29)
  • Build App Backend and Project Summary (13:46)
  • Source Code

Text Prediction

  • Intro and Demo (4:13)
  • Tasks List (3:17)
  • Processing Text Data (13:18)
  • Building Data Sets and Model Builder Function (16:16)
  • Building Computational Graph (8:37)
  • Writing, Training, and Testing Code (15:11)
  • Training, Testing, and Freezing Graph (12:27)
  • Setting up Android Project (7:41)
  • Setting up UI (5:19)
  • Setting up Vocab Dictionary (8:34)
  • Formatting Input and Running Through Model (7:55)
  • Source Code

Stock Market Prediction

  • Intro and Demo (3:47)
  • Task List (5:17)
  • Retrieving Data via RESTful API Call (16:30)
  • Parsing JSON Data Pycharm Style (6:37)
  • Formatting Data (15:45)
  • Building the Model (13:26)
  • Training and Testing the Model (9:54)
  • Freezing Graph (10:06)
  • Setting up Android Project (6:07)
  • Building UI (8:25)
  • Requesting Data Via AsyncTask (8:25)
  • Parsing JSON Data Android Style (12:04)
  • Running Inference and Displaying Results (17:42)
  • Source Code

Image Analysis with Keras

  • Introduction to Level 4 (9:44)

Simple CIFAR-10

  • Intro and Demo (4:47)
  • Topics List (3:47)
  • Exploring CIFAR-10 Dataset (10:48)
  • Update! CIFAR_10 Android Fix
  • Formatting Input Data (13:13)
  • Building the Model (16:24)
  • Freezing Graph and Training Model (16:56)
  • Setting up the Android Project (16:43)
  • Setting up UI (9:02)
  • Loading and Displaying Image (6:33)
  • Formatting Image Data for Model Input (13:55)
  • Predicting and Displaying Results (13:26)
  • Summary and Outro (6:39)
  • Source Code

Face Detection

  • Intro and Demo (3:20)
  • Tasks List (3:09)
  • Loading Face and Non Face Images (15:56)
  • Reformatting Input Data (11:12)
  • Build Model + Write, Train & Test Scripts (19:12)
  • Freeze Graph + Train & Test Model (14:38)
  • Setting up Android Project (11:49)
  • Setting up UI (7:52)
  • Loading and Display Images (10:11)
  • Formatting Data and Running Inference (12:47)
  • Displaying Results and Summary (8:51)
  • Source Code

Emotions Detection

  • Intro and Demo (3:39)
  • Tasks List (2:34)
  • Loading and Formatting Data (11:13)
  • Build Training and Testing Datasets (6:52)
  • Building the Model (9:57)
  • Build Functions to Train, Test, & Predict (11:58)
  • Training and Testing the Model (11:06)
  • Setting up Android Project (6:33)
  • Importing and Displaying Images (6:25)
  • Convert Images and Run Inference (8:17)
  • Displaying Results and Summary (7:48)
  • Source Code

Increase Efficiency of Machine Learning Models

  • Intro to Increasing ML Efficiency (5:47)
  • Source Code

Introduction to Tensorflow Lite

  • Tensorflow Lite (10:19)

Text Summarizer

  • Introduction (6:22)
  • How a Model Is Built (13:08)
  • Training and Summarizing Mechanisms (9:31)
  • Training and Summarizing Code (7:44)
  • Testing the Model (5:27)
  • Source Code

Object Localization

  • Introduction (4:13)
  • Examining Project Code (15:05)
  • Testing with a Mobile Device (7:30)

Object Recognition

  • Introduction (7:30)
  • Examining Code (22:29)
  • Testing on Mobile Device (5:36)

Intro to Tensorboard

  • Introduction (2:55)
  • Examining Computational Graph In Tensorboard (13:46)
  • Analyzing Scalars and Histograms (13:01)
  • Modifying Model Parameters Across Multiple Runs (10:32)
  • Source Code

Advanced ML Concepts

  • Introduction (18:49)
  • Source Code

Advanced MNIST

  • Intro and Demo (3:42)
  • Topics List (3:41)
  • Building Neuron Functions (11:18)
  • Building the Convolutional Layers (11:51)
  • Building Dense, Dropout, and Readout Layers (14:38)
  • Loss & Optimizer Functions, Training, & Testing (19:51)
  • Optimizing Saved Graph (10:57)
  • Setting up Android Project (12:30)
  • Setting Up UI (10:58)
  • Load and Display Digit Images (6:14)
  • Formatting Model Input (13:52)
  • Displaying Results and Summary (11:11)
  • Source Files

Advanced CIFAR-100

  • Intro and Demo (3:18)
  • Tasks List (3:11)
  • Inputting and Formatting Data (10:50)
  • Building the Model (10:19)
  • Training, Testing, and Freezing Model (10:57)
  • Setting up Android Project (10:24)
  • Building UI (8:09)
  • Loading and Displaying Images (7:03)
  • Converting Image Data & Running Inference (7:37)
  • Summary and Outro (9:29)
  • Source Code

Image Recognition in iOS

  • Introduction and Demo (3:20)
  • Project Setup (6:59)
  • Displaying and Resizing Images (9:42)
  • Converting Image to Pixel Buffer (14:06)
  • Summary and Outro (8:07)
  • Source Code

Intro to iOS

  • Introduction (2:15)
  • Source Code

Xcode Intro

  • Downloading and Installing (6:22)
  • Exploring XCode’s Interface (15:40)

Swift Language Basics

  • Variables Intro (7:57)
  • Variable Operations (10:43)
  • Collections (8:57)
  • Control Flow (10:18)
  • Functions (5:28)
  • Classes and Objects (9:55)

iOS App Development Intro

  • Building App From Start to Finish (12:46)

Intro to CoreML

  • Introduction to CoreML (9:08)

iOS Tensorflow Model Import

  • Introduction (4:35)
  • Converting pb to mlmodel
  • File & Setting up Project (7:34)
  • Running Inference Through Model (9:58)
  • Testing and Summary (3:55)

Learn now in our master course with app developer Nimish Narang! 90% off today with this coupon: https://training.mammothinteractive.com/p/mobilemachinelearning/?product_id=509994&coupon_code=SPECIALBLOGCOUPON

What are neural networks?

Neural networks explained

Read below a sneak peek of the articles in our Mobile Machine Learning course with Nimish Narang.

Enroll in the course for 90% off

Neural networks are a network of interconnected nodes. Each node has weights and biases associated with it. Data flows through the network from the input to the output nodes.

Each neural network contains layers of nodes.

Each layer is connected to all the nodes in the next layer. Every input will travel through the network until it reaches the very end. It will contain certain values along the way that determine how important that particular pathway is.

In more general terms, neural networks are a set of algorithms designed to recognize patterns.

This makes them great at image classification and image recognition. To the machine or model that you build, and image is just a set of data, an array of values typically between 0 and 255 that represent pixel values. If it can represent certain patterns associated with certain outcomes, it can learn to solve a problem.

The name ‘neural network’ is derived from their structure of a network of nodes. It’s modeled around the human brain, which contains many different neurons each connected to each other and requiring activation to produce results.

Each network contains several layers. Each layer contains operations to either process inputs or map pathways through the network. These pathways produce specific outputs.

Each layer is a mini-network itself of many interconnected nodes. The number of nodes depends on the complexity of the problem you’re trying to solve. Each node is assigned a weight and a bias.

Weights are assigned an initial value that changes over time. When you train your model, you alter the weights. The weights are assigned specifically to a connection between nodes rather than one node.

A bias is a constant value assigned to each node.

How is the weight useful to us?

The weight determines which path to take once a node receives an input. More specifically: how important that path is. This repeats until we reach the end of the network.

At each layer an activation function will be attached to each node at the layer. Certain activation functions are better for certain tasks. An activation function is a way to sum up all the inputs of a layer. It will transform the sum depending on the function you use and will produce an output.

The output will propagate throughout the network until the end. At the end, you can sum all the input values, perform a function, and produce a meaningful output.

Machine learning example

For example, suppose the end sum of your activation function produces an output of 0.1 on the inputs. Suppose in this example, we’re using a neural network to determine if an image is of a face. The closer to 1 that the output value is, the more likelihood it is that the image has a face.

Based on this example, an output of 0.1 means we don’t have a face. If the sum of the weights after the activation function is 0.8, you probably have an image of a face.

For each node in the middle of the network, the input of a node is the output to another node. During training, when you receive inputs and feed in a bunch of data to a network over and over again, the weights will be adjusted in such a way that it starts to learn certain patterns and associate them with outputs.

The network adjusts the weights accordingly so that if you get a face image, the network will know to take certain pathways. Whereas if you get a non-face image, the network will know to take different pathways to the weights we’ve trained. The data runs through one side to the other until a pattern is recognized and we get similar data mapping to similar pathways.

Learn more with Nimish in Mobile Machine Learning: The Complete Masterclass

Machine learning concepts explained

Read below a sneak peek of the articles in our Mobile Machine Learning course with Nimish Narang.

Enroll in the course for 90% off

What is machine learning?

Machine learning is a machine’s ability to make decisions or predictions based on previous exposure to data and extensive training. In other words, if a machine (program, app, etc.) improves its prediction accuracy through training, it has “learned.”

Machine learning is not quite artificial intelligence (AI) because a machine with AI can reason and think and act intelligently.

However, no AI can make decisions based on training and previous exposure to data. AI uses machine learning, but machine learning doesn’t necessarily use AI.

How machine learning models work

Computational graphs consist of a network of connected nodes (often called neurons). Each of these nodes typically has a weight and a bias that helps determine, given an input, which path is the most likely.

This enables the model to make intelligent decisions based on previously learned pathways. Outputs of one node are inputs into another. Nodes can be the results of operations or just be there to hold a value.

Building a machine learning program

There are 4 main components to building a machine learning program: data gathering and formatting, model building, training, and testing and evaluating

Data gathering and formatting

Here you want to gather a lot of data for your model to learn from. This means getting a variety of examples to expose the model to many variations and to get lots of it (thousands).

All data should be formatted pretty much the same (images same size, same color scheme, etc.) and should be labelled. You should also divide data into mutually exclusive training and testing sets.

Model building

Figure out which kind of model scheme works best and what kinds of algorithms work best for the problem you’re trying to solve. Break the bigger goal into smaller tasks and solve each of them at a time. Decide which optimizer, activation, and loss functions you want to use to that best fit the data you enter in for training. This can include connections, nodes, neurons, and more.

Training a machine learning model

Here a model assigns weights and biases to neurons. This helps the model make decisions and choose from a few outputs given a specific set of inputs. The model can choose paths through the neural network or computational graph based upon the inputs for a particular run, as well as the weights and biases of neurons in the network.

In supervised learning, we show the model what the correct outputs are for a given set of inputs, and the model alters the weights and biases of neurons to minimize the difference between its output and the correct answer.

Testing and evaluating machine learning models

After the model has been trained and the weights and biases of each neuron or node are fixed, we feed in a new set of data to see how well the model performs and how accurate the predictions are. Although it depends on the task at hand, good models will be > 90% accurate and very good models > 98% accurate.

Learn more with Nimish in Mobile Machine Learning: The Complete Masterclass

 

Get 2 masterclasses in 1.

Learn development, design, artificial intelligence, and data science!

10 levels of coding to take you from newbie to expert and give you a thorough introduction to various fields in tech. Change your life and skyrocket your career with this ultimate course for all.

Click here to enroll

210 hours and bonus content

Level 1: Introduction to Coding Fundamentals
Level 2: Web Development
Level 3: Complete App Development
Level 4: Build Games and Art Assets
Level 5: Learn Artificial Intelligence
Level 6: Introduction to Machine Learning + Software
Level 7: Machine Learning in Android Studio Projects
Level 8: Build Image Recognition Apps
Level 9: Build Scientific Analysis Apps
Level 10: Increase Efficiency of Machine Learning Models
+ 130 bonus topics raised by our backers on Kickstarter. Thank you for supporting online education!

Glauco talks about upcoming Unity AI

We are nearing completion of Mobile Machine Learning and its stretch goal topics. Because we raised enough money to hit stretch goals, backers of every pledge level will get to learn with our game developer Glauco Pires!

Glauco has been working on Unity artificial intelligence (AI) courses. We will soon release to you these and Mobile Machine Learning.

Read below our interview with Glauco Pires

Glauco shares how he found his passion for gaming. He also gives advice for up-and-coming developers who want to make it in the games industry.

Q: What latest exciting projects have you been working on at Mammoth Interactive?

A: I’ve been cooking a couple of AI courses made in Unity. In these courses, you will use Unity on its own to make 3D games with the C# programming language.

Students will learn how how to take their games to the next level. You can take any game no matter how simple and make it instantly more efficient using AI.

Besides, I believe games are the best means of seeing the full potential of AI: the way characters, monsters and spaceships are able to move and behave is just magical (Well, it’s actually a mix of maths and algorithms 😉 we’ll talk about this).

Q: Why do you like working at Mammoth Interactive?

A: It’s always an amazing experience to work with Mammoth. The crew is easygoing, and we all work together to achieve our goals. Being able to reach hundreds of thousands of students and teach them our day-to-day craft is fulfilling. 

Also, even though I grew up using the Internet, it still amazes me that I work 10,000 kilometers away from the headquarters in the Brazilian hot weather 🙂

Q: Share something lighthearted from the past 2 months, related to your work.

A: The good thing about creating courses is the reach you can achieve with the Internet. One of the best things I’ve seen in my entire career was a review from a student, who lives in another country and was really satisfied about the lessons.

He is a father of two kids, and throughout the course, he showed them the results of his learning process. They even had the chance to compare the game he made with the games the kids played at their game consoles.

Being able to make a difference in people of all ages and provide fun, family moments like this is something that makes working with games really worth it.

Q: Why did you enter the game development field?

A: I’ve played games since I was a young child, from 2D platformers in the Sega Genesis to shooters and open-world adventure games in the Xbox One.

In my early teenage years, I got hooked to Counter-Strike (v1.0 back then). I became curious about how game maps were made. It took me dozens of hours just to be able to export a file from the map editor to the actual game, but later I learned how to work with collisions, textures, skyboxes and artificial intelligence (to make bots move).

Years later, I was sure I wanted to work with computer science, and then I thought, Hey, why not make games? Mixing the wishes of the naive kid and young adult versions of me made me dive into the world of game development, and I love it!

Q: What’s a production pitfall you’ve had to overcome recently?

A: Programming is something that I love doing: being able to communicate with a computational device, provide instructions and see the outcome opens your eyes for all the projects you can make and all the problems you can solve.

However, developers have to live with the fact that bugs will always appear, and we need to concentrate efforts into fixing them. I’ve recently spent a good amount of time trying to find what was wrong with a line of code: Is this architecture good, Did I forget to delete an object or Am I supposed to use a pointer? 

Turns out that I forgot to simply open and close parenthesis to call a function! It’s common to forget or confuse the usage of parentheses, curly braces (for scope definition) and semicolons because the more you work with something, the more you’ll expect for it to work. 

Q: What’s a challenge you’ve come across?

A: Building a game API/SDK. Sometimes depending on the software you’re using and the hardware limitations you have, there’s no choice but to build your own codebase to make games.

Working with Unity, Unreal and HTML5 is great because there are tons of assets, plugins and libraries available for you to use, but sometimes all you have is a canvas to draw pixels.

This means that all the functions you are used to work with (drawing images, lines, squares, collisions, AI, etc.) are completely absent from the development environment. Still, if you have experience working with multiple well-established game engines, chances are you have a pretty good idea of how your engine is supposed to look like, containing hierarchy, classes, primitives and more.

Q: What’s your advice for aspiring game developers?

A: Be curious! The game industry changes everyday: operational systems, technologies, game engines… Working with a certain programming language or tool today doesn’t mean you’ll keep using it in the next year.

Next time you play a game, watch an e-sport, or watch a tutorial, ask yourself: How did the developers make this feature, How is it possible for 100 people to play in the same world simultaneously, or How does this look so beautiful?

It doesn’t matter how experienced you are: being curious is going to make you ask questions and work towards finding answers that can be applied everywhere. 

Q: What’s your favorite recent developer project?

A: Making a simple game engine. All the experience I had in pretty much the past decade counts a lot into making this.

Q: What separates successful students in gamedev?

A: A single word: initiative. If you want to make something, find the means to do it! 

We live in an ultra-connected world completely different from ten years ago. You can find tools, courses and material for almost anything.

Q: What do you want to ask readers?

A: One of the things that brings us into the game industry is the wish to make a game just like one we love. Put yourself in the shoes of future-you 10 years from now. Imagine all the games that will have come out over the decade. Simple arcade games filled with colorful, nostalgic pixel art, hyper-realistic virtual reality masterpieces, blockbuster AAA games, you name it. Which of them do you wish you had made? 

Hint: think big. Imagine what would be your favorite. That’s the game you should make right now.

Thanks for supporting Glauco, Mammoth Interactive and Mobile Machine Learning!

from Mobile Machine Learning: The Complete Masterclass

from Mobile Machine Learning: The Complete Masterclass