Byte-Sized IoT Series Learning Path

https://project.bigdatatrunk.com Quality Corporate and Classroom Training in Bay Area CA Wed, 06 May 2026 11:48:38 +0000 en-US hourly 1 https://wordpress.org/?v=7.0 AI for Coding https://project.bigdatatrunk.com/courses/ai-for-coding/ https://project.bigdatatrunk.com/courses/ai-for-coding/#respond Wed, 28 Jan 2026 07:56:23 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=63059 This immersive 3-hour hands-on training explores how AI-powered coding tools enhance software development.

The post AI for Coding first appeared on Big Data Trunk.

]]>

AI for Coding

Deprecated: Creation of dynamic property OMAPI_Elementor_Widget::$base is deprecated in /home2/schooli5/public_html/project/wp-content/plugins/optinmonster/OMAPI/Elementor/Widget.php on line 41

This immersive 3-hour hands-on training explores how AI-powered coding tools enhance software development.

Free E-learning Course

Download Brochure

Book a Strategy Call

Overview
Audience
Prerequisites
Curriculum

Description:

This immersive 3-hour hands-on training explores how AI-powered coding tools enhance software development. Participants will start with a foundational understanding of AI in coding, followed by a hands-on exploration of free AI coding assistants such as GitHub Copilot (Free Tier), Codeium, and Tabnine. Through instructor-led exercises, attendees will apply AI for code generation, debugging, optimization, and documentation. The session includes a step-by-step setup, practical use cases, and strategies for integrating AI into everyday coding workflows. By the end of this training, participants will be able to leverage AI tools to enhance coding efficiency, reduce errors, and accelerate development—all without requiring a paid subscription

Duration:

Half day

Course Code: BDT 426

Learning Objectives:

After this training, participants will be able to:

Describe how AI-powered coding tools assist in software development.
Explore and set up free AI coding assistants for hands-on coding tasks.
Apply AI tools for code completion, debugging, and performance optimization.
Evaluate the strengths and limitations of different AI coding assistants.

Programmers and developers with basic coding experience
Tech enthusiasts exploring AI-powered coding assistance
Students and professionals looking to enhance productivity with AI

Basic programming knowledge (Python, JavaScript, or similar)
Access to a browser for signing up and using free AI coding tools

Course Outline:

Module 1: Foundations of AI-Assisted Coding

Understanding AI in Software Development
- AI’s role in modern programming workflows
- Strengths and limitations of AI-powered coding tools
- Ethical considerations in AI-assisted coding
Exploring Free AI Coding Tools
- GitHub Copilot (Free Tier) – Autocompletion & suggestions
- Codeium (Completely Free) – Full AI coding assistant
- Tabnine (Free Tier) – AI-assisted code predictions
- Google Gemini for Code – AI-generated coding assistance

Module 2: Practical Usage & Optimization

Setting Up & Optimizing AI Coding Assistants
- Hands-on: Signing up and configuring GitHub Copilot
- Hands-on: Customizing AI tools for better code suggestions
- Best practices for integrating AI into daily programming tasks
- Real-world case studies on AI in software development

Module 3: Hands-On AI Coding Use Cases

Enhancing Coding Productivity

- Hands-on: AI-assisted code autocompletion & refactoring
- Hands-on: AI-generated documentation and explanations
AI for Debugging & Troubleshooting
- Hands-on: Detecting and fixing bugs with AI coding tools
- Hands-on: Performance optimization through AI-driven code reviews
AI for Code Generation & Learning
- Hands-on: Generating complex functions and algorithms with AI
- Hands-on: Converting pseudocode into working scripts
- Hands-on: AI-generated test cases and debugging strategies

Training material provided: Yes (Digital format)

The post AI for Coding first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/ai-for-coding/feed/ 0 Introduction to PyTorch and Large Language Models https://project.bigdatatrunk.com/courses/introduction-to-pytorch-and-large-language-models/ https://project.bigdatatrunk.com/courses/introduction-to-pytorch-and-large-language-models/#respond Fri, 02 May 2025 18:20:58 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=58829 This hands-on course introduces the fundamentals of deep learning, neural networks, and PyTorch—one of the most widely used deep learning frameworks.

The post Introduction to PyTorch and Large Language Models first appeared on Big Data Trunk.

]]>

Overview
Audience
Prerequisites
Curriculum

Description:

This hands-on course introduces the fundamentals of deep learning, neural networks, and PyTorch—one of the most widely used deep learning frameworks. Participants will build foundational knowledge of deep learning principles, explore the PyTorch ecosystem, and apply these skills through practical exercises. The course will also introduce large language models (LLMs), explaining the concepts of pre-training, fine-tuning, and practical use cases leveraging open-source models from Hugging Face.

By the end of the day, learners will have built and trained deep neural networks, and will know how to load and interact with powerful pretrained large language models using PyTorch.

Duration: 1 Day

Course Code: BDT500

Learning Objectives:

After this course, you will be able to:

Understand the basics of neural networks and deep learning.
Write and train deep neural networks using PyTorch.
Understand the structure and training process of large language models (LLMs).
Fine-tune a pretrained model for a specific task.
Use Hugging Face to access and use open-source models.

AI/ML beginners, data scientists, developers, and students interested in deep learning and NLP

Basic Python programming experience. No prior deep learning knowledge required.

Course Outline:

Introduction to Deep Learning and Neural Networks

What is deep learning?
Neural network architecture
Key components: neurons, layers, activation functions
How machines "learn" patterns

Introduction to PyTorch

What is PyTorch?
Core PyTorch concepts:
1. Tensors
2. Autograd
3. Neural network modules
Setting up your environment (brief walkthrough)
Hands-on: Tensor operations and basic computations in PyTorch

Building Neural Networks with PyTorch

Defining models using Module
Loss functions and optimizers
Training loops explained
Hands-on: Build and train a simple deep learning model

Large Language Models (LLMs) Fundamentals

What are LLMs?
Transformer architecture
Popular LLMs: GPT, BERT
Representation models vs. generative models
Tokens and embeddings
Practical challenges: dataset size, computational requirements, ethical issues

Using Pretrained Models with Hugging Face

Introduction to the Hugging Face ecosystem
Exploring transformers library
Loading and using a model
Hands-on: Text classification with a pretrained model

Fine-tuning Pretrained Models

Overview of fine-tuning
Fine-tuning a Hugging Face model on custom data (small dataset)
Hands-on: Fine-tuning exercise

Best Practices and Real-World Applications

Choosing the right model for your task
Monitoring training and evaluating performance
Real-world examples: Chatbots, document summarization, code generation

Training material provided: Yes (Digital format)

The post Introduction to PyTorch and Large Language Models first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/introduction-to-pytorch-and-large-language-models/feed/ 0 Byte-Sized Deep Learning Series: Model Persistence with Keras https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-model-persistence-with-keras/ https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-model-persistence-with-keras/#respond Fri, 02 May 2025 18:15:40 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=58815 Once you've built and trained your model, what's next? You need to persist it so that it can be used later without retraining — whether that’s for evaluation, deployment, or inference on new data.

The post Byte-Sized Deep Learning Series: Model Persistence with Keras first appeared on Big Data Trunk.

]]>

Overview
Prerequisites
Audience
Curriculum

Description:

Once you've built and trained your model, what's next? You need to persist it so that it can be used later without retraining — whether that’s for evaluation, deployment, or inference on new data.
In this session, we will explore model persistence using Keras and TensorFlow.
You’ll learn how to **save models in the H5 format and TensorFlow’s Saved Model format, and you’ll understand when and why you might choose one format over the other.
We will also dive into TensorFlow model serving to deploy your model for real-time predictions on mobile or edge devices.
Finally, you'll get a chance to put it all together in a hands-on lab, where you will save and load models, ensuring that you can deploy your trained models wherever they are needed.

This session is perfect for anyone looking to move from model creation to deployment, and it will prepare you for the challenges of deploying machine learning models in real-world applications.

Duration: 90 mins

Course Code: BDT499

Learning Objectives:

After this course, you will be able to:

Introduction to Model Persistence
Saving models with Keras
Loading models for inference
TensorFlow Saved Model Format and Benefits
Model serving with TensorFlow

Learners who want to take their models beyond the training environment and deploy them on different platforms (mobile, edge, etc.)

Deep learning practitioners and students who are familiar with building and training models with Keras/TensorFlow. Ideal for those looking to understand model persistence (saving and loading models) and learn how to serve models for inference in production environments

Course Outline:

Introduction to Model Persistence
- What is model persistence? Saving trained models for later use
- Why model persistence is crucial
- Different model formats: H5, TensorFlow Saved Model
Saving models with Keras
- How to save a model in H5 format with Keras
- Differences between H5 and the TensorFlow Saved Model
- Saving architecture, weight, and training configuration
- Hands-on: Persist model with Keras
Loading models for inference
- How to load Keras model from disk
- Check if the model is loaded properly and ready for making predictions
- Hands-on: Load model with Keras and check validity
TensorFlow Saved Model Format and Benefits
- Saved Model Format: TensorFlow’s Default model format
- What does it preserve?
- Benefits: More flexible deployments in TensorFlow serving
TensorFlow Model Serving
- What is TensorFlow Model Serving?
- TensorFlow lite and TensorFlow.js: mobile and web applications
- Serving models on mobile or edge devices

Training material provided: Yes (Digital format)

Hands-on Lab: Instructions will be provided to install Jupyter notebook and other required python libraries. Students can opt to use ‘Google Colaboratory’ if they do not want to install these tools

The post Byte-Sized Deep Learning Series: Model Persistence with Keras first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-model-persistence-with-keras/feed/ 0 Byte-Sized Deep Learning Series: Neural Networks – Overfitting, Underfitting https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-neural-networks-overfitting-underfitting/ https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-neural-networks-overfitting-underfitting/#respond Fri, 02 May 2025 18:10:33 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=58798 In deep learning, a model can either underfit (not learn enough from the data) or overfit (memorize the data, losing the ability to generalize).

The post Byte-Sized Deep Learning Series: Neural Networks – Overfitting, Underfitting first appeared on Big Data Trunk.

]]>

Overview
Prerequisites
Audience
Curriculum

Description:

In deep learning, a model can either underfit (not learn enough from the data) or overfit (memorize the data, losing the ability to generalize).
In this 90-minute session, we will dive deep into the concepts of overfitting and underfitting, with a special focus on how to address overfitting in your neural networks.
You will learn various techniques like L2 regularization, dropout, early stopping, and model checkpointing to improve your model’s ability to generalize. These methods can significantly improve model performance, especially when working with limited data or large, complex models.
We’ll provide practical, hands-on examples using Keras to apply these techniques to a real-world dataset, so you can directly see how to improve your model’s accuracy and prevent overfitting.

Duration: 90 mins

Course Code: BDT498

Learning Objectives:

After this course, you will be able to:

Introduction to Overfitting and Underfitting
Using L2 Regularization in Keras
Using Dropout layer
Early Stopping and Model check points

Learners familiar with Keras and basic model training

Intermediate deep learning students who have experience building neural networks. Ideal for those seeking to understand how to prevent overfitting and improve model generalization on new data

Course Outline:

Introduction to Overfitting and Underfitting
- Understand what overfitting is and underfitting in neural networks
- How to recognize overfitting and underfitting
- Key challenges: balancing variance and bias
Handle Overfitting: L2 Regularization
- Understand what is L2 Regularization?
- Implementing L2 Regularization with Keras (keras.regularizers.l2())
- Hands-on: Adding L2 Regularization to layers in a model
Handling Overfitting: Dropout Layer
- What is a dropout layer?
- Understanding dropout rate
- Hands-on: Adding a dropout layer to the model
Handing Overfitting: Early Stopping and Model Checkpoint
- What is early stopping?
- Understanding monitor and patience parameters
- What is model checkpointing?
- Save the best weights with model checkpointing
- Hands-on: Using both early stopping and model checkpointing during training

Training material provided: Yes (Digital format)

The post Byte-Sized Deep Learning Series: Neural Networks – Overfitting, Underfitting first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-neural-networks-overfitting-underfitting/feed/ 0 Byte-Sized Deep Learning Series: Understanding Transfer Learning https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-understanding-transfer-learning/ https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-understanding-transfer-learning/#respond Fri, 02 May 2025 18:05:07 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=58785 Deep learning models are data-hungry; but what if you could leverage a pre-trained network to solve your problem with much less data?

The post Byte-Sized Deep Learning Series: Understanding Transfer Learning first appeared on Big Data Trunk.

]]>

Overview
Prerequisites
Audience
Curriculum

Description:

Deep learning models are data-hungry; but what if you could leverage a pre-trained network to solve your problem with much less data?

In this 90-minute session, we’ll explore transfer learning, a powerful technique that enables you to use knowledge gained from one task and apply it to another.

You’ll learn about the types of transfer learning (fine-tuning vs feature extraction), the benefits of transfer learning, and how to implement these strategies using Keras and pre-trained models.

We’ll dive into feature extraction, where we use frozen pre-trained layers, and fine-tuning, where we allow some layers to be updated during training.

Through hands-on examples on an image dataset, you’ll see how to apply transfer learning to boost model performance with less data and fewer resources.

Whether you’re tackling a new classification problem or trying to improve an existing model, this session will equip you with the knowledge to use transfer learning effectively in your projects.

Duration: 90 mins

Course Code: BDT497

Learning Objectives:

After this course, you will be able to:

Introduction to Transfer Learning
Feature Extraction with Pre-Trained model
Fine-Tuning pre-trained models

Learners familiar with Keras/TensorFlow basics and willing to apply pre-trained models to real-world problems

Machine learning practitioners and deep learning students with a solid understanding of neural networks. Ideal for those looking to improve model performance quickly by leveraging pre-trained networks

Course Outline:

Introduction to Transfer Learning
- What is Transfer Learning? Reusing knowledge from one model for a different task
- Types of Transfer Learning: Feature Extraction, Fine Tuning
- Benefits of transfer learning
Feature Extraction with Pre-Trained Models
- The idea: using a pre-trained model as a fixed feature extractor
- Understand how feature extraction works
- Freezing weights, removing layer and adding a layer
- Hands-on: Perform feature extraction when performing image classification
Fine-Tuning a Pre-Trained Model
- Fine tuning: unfreezing a few top layers and allowing them to train
- Understand when to fine tune and how to fine tune
- Hands-on: Fine tune a model for image classification

Training material provided: Yes (Digital format)

The post Byte-Sized Deep Learning Series: Understanding Transfer Learning first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-understanding-transfer-learning/feed/ 0 Byte-Sized Deep Learning Series: Training Optimization of Neural Networks https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-training-optimization-of-neural-networks/ https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-training-optimization-of-neural-networks/#respond Fri, 02 May 2025 17:59:06 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=58771 Building a neural network is only the beginning — training it successfully is where real deep learning expertise shines.

The post Byte-Sized Deep Learning Series: Training Optimization of Neural Networks first appeared on Big Data Trunk.

]]>

Overview
Prerequisites
Audience
Curriculum

Description:

Building a neural network is only the beginning — training it successfully is where real deep learning expertise shines.
In this 90-minute session, you’ll learn the critical hyperparameters that control how your model learns, including optimizers, loss functions, evaluation metrics, and callbacks.
We’ll explore popular Keras optimizers like SGD, Adam, and RMSprop, discuss why choosing the right loss function matters, and learn how to track performance using metrics.
You’ll also see how callbacks (like Early Stopping and ModelCheckpoint) can automate smarter training workflows.

Beyond that, we'll dive into key design decisions: How many epochs to train for? How many layers and neurons should your network have?
By the end, you'll be able to train models more effectively, spot when things are going wrong, and tune hyperparameters for better performance.

If you want to turn "good enough" models into great ones, this session is a must!

Duration: 90 mins

Course Code: BDT496

Learning Objectives:

After this course, you will be able to:

Key training hyper parameters
Choosing optimizers and loss functions
Tracking training progress and metrics
Making training smarter with Callbacks

Learners familiar with concepts like model layers, activation functions, and compiling a model

Machine learning students and practitioners who know how to build basic Keras models. Ideal for those who want to go beyond "default settings" and fine-tune their training process for better results

Course Outline:

Training Hyper Parameters
- What are hyper parameters?
- Understanding various hyper parameters for neural networks
- Epochs, Number of layers, number of neurons
Choosing Optimizers and Right Loss Function
- What an optimizer does: updating weights to minimize loss
- Key Keras Optimizers: SGD, Adam, RMSprop
- Learning rate: most important optimizer parameter
- Why does loss function matter?
- Loss functions: Binary, Categorical Cross Entropy, Mean Squared Error
Tracking training progress and metrics
- Metrics ≠ Loss, metrics tell you “How good” the model is from user’s perspective
- Common metrics: accuracy, precision, recall, AUC, MSE
Making training smarter with Callbacks
- What are callbacks: functions trigged during training
- Keras callbacks: Early Stopping, Model Check point, Reduce LR on Plateau
- Hands-on: Use different callbacks during model training

Training material provided: Yes (Digital format)

The post Byte-Sized Deep Learning Series: Training Optimization of Neural Networks first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-training-optimization-of-neural-networks/feed/ 0 Byte-Sized Deep Learning Series: Handling Text Data with Keras https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-handling-text-data-with-keras/ https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-handling-text-data-with-keras/#respond Fri, 02 May 2025 17:51:03 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=58757 Unlock the secrets of working with text data using Keras!
In this 90-minute hands-on session, you'll learn essential text preprocessing steps like tokenization, padding, and vocabulary building, and see how to turn words into numbers using embedding layers.

The post Byte-Sized Deep Learning Series: Handling Text Data with Keras first appeared on Big Data Trunk.

]]>

Overview
Prerequisites
Audience
Curriculum

Description:

Unlock the secrets of working with text data using Keras!
In this 90-minute hands-on session, you'll learn essential text preprocessing steps like tokenization, padding, and vocabulary building, and see how to turn words into numbers using embedding layers.
You'll also explore the powerful TextVectorization layer — and put it all together by building a simple sentiment analysis model!
If you're ready to bring language understanding into your ML skillset, this is the perfect place to start!

Duration: 90 mins

Course Code: BDT495

Learning Objectives:

After this course, you will be able to:

The challenge of text data in ML/DL
Text preprocessing: Tokenization, Padding, Vocabulary
Embedding Layers & Word Embeddings
Using the Keras TextVectorization Layer

Learners familiar with Python, TensorFlow, and Keras basics (e.g., Sequential models, layers)

Machine learning students and practitioners who understand basic model-building and want to extend their skills to text and NLP tasks. Ideal for those who want to build their first text classification model.

Course Outline:

The Challenge with Text Data in ML/DL
- Why text is hard: variable length, vocabulary size, semantics
- The goal: turn text into numeric tensors for neural networks
Text Preprocessing: Tokenization, Padding, Vocabulary
- Tokenization: building text into words or sub words
- Vocabulary building: Assigning unique integers to tokens
- Padding: Making sequences the same length
- Hands-on: Using Tokenizer, pad sequences
Embedding Layers and Word Embeddings
- Why embeddings? (dense vector representations of words)
- Keras Embedding layer: Turning tokenized input into dense vectors
- Hands-on: Add an embedding layer to a dummy model (inspect output shapes)
Using the Keras TextVectorization Layer
- Overview: What is TextVectorization?
- Preprocessing text
- How it handles tokenization, vocabulary and sequence length
- Hands-on: Use TextVectorization in the neural network

Training material provided: Yes (Digital format)

The post Byte-Sized Deep Learning Series: Handling Text Data with Keras first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-handling-text-data-with-keras/feed/ 0 Byte-Sized Deep Learning Series: Image Classification with CNN https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-image-classification-with-cnn/ https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-image-classification-with-cnn/#respond Fri, 02 May 2025 17:43:22 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=58743 How do computers "see" and recognize images?
This session will introduce you to Convolutional Neural Networks (CNNs): the deep learning architecture that powers technologies like facial recognition, autonomous vehicles, and medical image analysis.

The post Byte-Sized Deep Learning Series: Image Classification with CNN first appeared on Big Data Trunk.

]]>

Overview
Prerequisites
Audience
Curriculum

Description:

How do computers "see" and recognize images?

This session will introduce you to Convolutional Neural Networks (CNNs): the deep learning architecture that powers technologies like facial recognition, autonomous vehicles, and medical image analysis.

You'll start by understanding why CNNs are essential for image tasks and how they cleverly use filters and feature maps to detect patterns like edges, shapes, and objects.

We’ll demystify the core concepts behind CNNs, explaining kernels, convolutions, pooling, and flattening in a simple and intuitive way.

You’ll use critical Keras layers such as Conv2D, MaxPooling2D, and Flatten, and learn how to design an efficient model architecture.

Duration: 90 mins

Course Code: BDT494

Learning Objectives:

After this course, you will be able to:

Challenges with Artificial Neural Networks Dense layers with Images
How do Convolutional Neural Networks (CNNs) work?
Essential CNN building blocks in Keras
Creating a CNN network for image classification

Learners familiar with TensorFlow/Keras basics (Sequential models, training/fitting)

Machine learning practitioners with basic experience building simple dense (fully connected) neural networks. Ideal for those ready to transition from tabular/text data to vision tasks.

Course Outline:

Why Convolutional Neural Networks (CNNs)
- Challenges with Keras Dense layers for images
- Local patterns and spatial dimensions
How CNNs work: Filters, Kernels, Feature Maps
- Filters and Kernels: small windows sliding over input
- Feature Maps: What the network “sees” at different stages
- Convolution: Feature Extraction
- Pooling: Down sampling feature maps
Essential CNN building blocks in Keras
- Conv2D layer: setting filters, kernel sizes, strides
- MaxPooling2D layer: down sampling feature maps
- Flatten layer: Transitioning from 2D feature maps to dense output
CNN for image classification
- Loading image dataset
- Building a CNN model
- Compiling the model
- Training the model and evaluating test data
- Hands-on: Performing image classification with CNN

Training material provided: Yes (Digital format)

The post Byte-Sized Deep Learning Series: Image Classification with CNN first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-image-classification-with-cnn/feed/ 0 Byte-Sized Deep Learning Series: Demystifying Neural Networks https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-demystifying-neural-networks/ https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-demystifying-neural-networks/#respond Thu, 01 May 2025 18:24:13 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=58692 Step into the world of deep learning by building your first Artificial Neural Network!

The post Byte-Sized Deep Learning Series: Demystifying Neural Networks first appeared on Big Data Trunk.

]]>

Overview
Prerequisites
Audience
Curriculum

Description:

Step into the world of deep learning by building your first Artificial Neural Network!
In this 90-minute, beginner-friendly session, you’ll uncover how neural networks learn, why activation functions are critical, and how to build a real model using TensorFlow and Keras.
If you know machine learning basics but want to start constructing real deep learning models, this is the perfect launchpad.

Duration: 90 mins

Course Code: BDT493

Learning Objectives:

After this course, you will be able to:

Demystifying Artificial Neural Networks (ANNs)
How do ANNs learn?
Building a basic ANN

Must have some python programming experience and NumPy. Students must be comfortable with TensorFlow basics

Machine learning enthusiasts and practitioners who are familiar with basic ML concepts (e.g., models, datasets, training loops). Students new to deep learning and neural networks, wanting a clear and intuitive understanding of how networks learn

Course Outline:

Demystifying Artificial Neural Networks
- What is a neural network? How does it mimic the brain?
- Core components of neural network: neurons, layers, weights, biases
- Understanding Forward and Backward pass
How do networks learn? Loss and Optimization
- The learning goal: minimizing the loss function
- Loss functions: MSE, Cross Entropy
- Optimizers: Adam, SGD
- Hands-on: Creating and Visualizing Loss
Building first neural network with Keras
- A brief introduction to Keras high-level API
- Build a simple neural network
- Compiling the model (specifying Loss and Optimizer)
- Hands-on: Build a simple neural network

Training material provided: Yes (Digital format)

The post Byte-Sized Deep Learning Series: Demystifying Neural Networks first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-demystifying-neural-networks/feed/ 0 Byte-Sized Deep Learning Series: Introduction to TensorFlow https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-introduction-to-tensorflow/ https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-introduction-to-tensorflow/#respond Thu, 01 May 2025 07:24:06 +0000 https://www.bigdatatrunk.com/?post_type=lp_course&p=58661 Unlock the power of TensorFlow by mastering its most fundamental building block: Tensors!

The post Byte-Sized Deep Learning Series: Introduction to TensorFlow first appeared on Big Data Trunk.

]]>

Overview
Prerequisites
Audience
Curriculum

Description:

Unlock the power of TensorFlow by mastering its most fundamental building block: Tensors!
In this 90-minute hands-on session, you’ll dive deep into creating, manipulating, and performing operations with tensors: the essential data structures behind every modern machine learning model.
By the end of the session, you’ll have the skills to confidently work with tensors of all shapes and sizes, preparing you for building real-world deep learning models.

Duration: 90 mins

Course Code: BDT492

Learning Objectives:

After this course, you will be able to:

Brief introduction to TensorFlow
Understanding Tensors
Accessing and manipulating Tensor data
Mathematical operations on Tensors
Activation Functions on Tensors

Must have some python programming experience and NumPy. Students must also be familiar with Machine Learning Concepts

Machine learning enthusiasts and practitioners who are familiar with basic ML concepts (e.g., models, datasets, training loops). Learners who want to start building deep learning models and need a solid foundation in TensorFlow tensors.

Course Outline:

Getting started with TensorFlow?
- What is TensorFlow? Why TensorFlow for ML?
Understanding Tensors
- What are Tensors? How are they different for NumPy Arrays?
- Types of Tensors: constant, random, zeros, ones, eye
- Tensor data types: float32, int32
- Hands-on: Creating Tensors
Accessing and Manipulating Tensor Data
- Indexing and Slicing Tensors
- Reshaping Tensors
- Adding and removing dimensions to Tensors
- Hands-on: Working with Tensors
Mathematical Operations on Tensors
- Element-wise operations: add, subtract, multiply, divide
- Matrix operations: matrix multiplication and dot products
- Aggregations: sum, mean, argmax, argmin
- Hands-on: Mathematical operations on Tensors
Activation Functions on Tensors
- Learn about different types of activation functions on Tensors
- Apply activation functions: ReLU, Sigmoid, Tanh, etc
- Visualize the output of the functions on Tensors
- Hands-on: Modifying Tensors

Training material provided: Yes (Digital format)

The post Byte-Sized Deep Learning Series: Introduction to TensorFlow first appeared on Big Data Trunk.

]]> https://project.bigdatatrunk.com/courses/byte-sized-deep-learning-series-introduction-to-tensorflow/feed/ 0