You’ll be welcomed to the technical microcredential and begin connecting with fellow students, while exploring the navigation and tools of your Online Campus. Be alerted to key milestones in the learning path, and review how your results will be calculated and distributed.

You’ll be required to complete your student profile, confirm your email address for the delivery of your digital certificate, and submit a digital copy of your passport/identity document.

Please note that module titles and their contents are subject to change during course development.

Explore the key concepts, principles, and practices in AI and machine learning.

• Outline the evolution, types, and core concepts of artificial intelligence
• Explain ethical considerations and governance principles for responsible AI development and use
• Differentiate between core concepts of machine learning
• Use machine learning concepts to identify and interpret real-world examples of intelligent systems
• Experiment with Generative AI tools to generate various forms of media
• Apply prompt engineering techniques to produce effective outputs using Generative AI tools

Discover the languages, frameworks, and tools of web development, including the use of HTML, CSS, and JavaScript.

• Explain the key components of web and cloud development
• Discuss the differences between front-end and back-end development
• Apply HTML and CSS to create web pages
• Use CSS frameworks to create responsive web interfaces
• Implement dynamic behavior with client-side JavaScript
• Use JavaScript to manipulate the document object model hierarchy

Explore key aspects of applying Python fundamentals to drive business solutions.

• Explain basic Python data types, and when type conversion is needed
• Apply expressions, variables, and string operations
• Implement lists and tuples in Python
• Use dictionaries and sets in Python

Learn the fundamentals of Python programming, and working with data in Python.

• Describe conditions, branching, objects, and classes
• Explain exception handling, build a function, and work with condition statements
• Demonstrate how to read and write files using Python libraries
• Explain how to use Pandas
• Discuss the use of NumPy to create one and two dimensional arrays
• Explain APIs and how to work with different file formats using Python
• Discuss data collection and web scraping

Explore Python coding and packaging practices as well as creating and deploying web applications.

• Describe the phases of the application development life-cycle and the role of APIs
• Explain how to write and test Python code using an IDE, following style guidelines and static code analysis practices
• Discuss how to organize code using packages and files, and how to validate functionality with unit tests
• Apply routes, request/response objects, and error handling
• Use Flask to develop and deploy a functional AI-powered web application

Develop a foundational understanding of data utilization using Python.

• Identify various sources and file formats for data import into Python
• Explain the purpose and functionality of key Python libraries used for data analysis
• Demonstrate how to import data from different sources into Python using relevant libraries
• Demonstrate appropriate data wrangling techniques for managing missing data and data inconsistencies
• Solve a given dataset to determine its structure, data types, and potential data quality issues
• Calculate and interpret basic descriptive statistics for a given dataset
• Experiment with Pearson correlation and Chi-square tests to analyze relationships between variables in a dataset
• Support drawing meaningful conclusions about data relationships by interpreting the results of correlation and Chi-square tests

Develop a stronger ability to work with data using Python and apply this knowledge practically.

• Explain the concepts of simple and multiple linear regression
• Identify and implement simple and multiple linear regression models using Python and scikit-learn
• Interpret regression plots, residual plots, and distribution plots to evaluate model performance
• Interpret polynomial regression models and pipelines to assess their predictive accuracy
• Compare different models (SLR, MLR, Polynomial Fit) based on Mean Squared Error (MSE) and R-squared values
• Examine how developed regression models can support the prediction of car or laptop prices
• Select appropriate model evaluation techniques to assess the performance of regression models
• Select appropriate regularization techniques and hyperparameter tuning methods to optimize regression model performance and prevent overfitting
• Apply regression analysis techniques to predict real-world outcomes using a given dataset, providing justification for the model development process

Engage with an introduction to neural networks with PyTorch.

• Understand the fundamental concepts and operations of one-dimensional PyTorch tensors as well as the properties and applications of two-dimensional tensors
• Identify how PyTorch differentiates tensors using the “requires_grad” attribute and the “backward()” function to calculate and access gradients
• Recognize the process of creating a dataset object and applying transforms using PyTorch, as well as the steps involved in both creating and transforming datasets using this framework
• Interpret the parameters of a one-dimensional linear regression model built with PyTorch and apply it to make predictions using tensors
• Interpret the fundamental concepts of linear regression training and explain the step-by-step process of training a single-parameter linear regression model using PyTorch
• Examine how gradient descent is utilized within PyTorch and the process of training a 1D linear regression model with two parameters using PyTorch
• Test the application and implementation of Stochastic Gradient Descent (SGD) and DataLoader in PyTorch to observe its effect on convergence and training a 1D linear regression model
• Evaluate how PyTorch optimizers and the standard training loop update model parameters using loss gradients
• Support the importance of training, validation, and test datasets in machine learning model development and evaluation

Expand your knowledge of neural networks with PyTorch.

• Remember the purpose and basic concepts of multiple linear regression in the context of multidimensional data and different methods for making predictions using PyTorch
• Understand the training procedures for multiple linear regression, including the role of cost functions and gradient descent as implemented in PyTorch
• Identify the matrix operations, PyTorch syntax, prediction methods, and training steps for implementing and using multiple output linear regression models in PyTorch
• Interpret how logistic regression employs feature-based prediction and thresholding functions to classify data in varying dimensional spaces as class probabilities, and how these concepts are implemented using PyTorch
• Apply model evaluation and refinement techniques to assess the performance of machine learning models
• Develop deep neural networks and logistic regression models using PyTorch for classification and prediction tasks

Learn the exciting applications of deep learning and why now is an opportune time to dive into this field.

• Understand the foundational concepts and applications of deep learning, including the role of neural networks and the process of forward propagation for predictions
• Identify the core principles of gradient descent and backpropagation and the steps involved in the backpropagation algorithm for training neural networks
• Interpret the limitations of the sigmoid activation function and compare its application to modern activation functions like ReLU in neural network training
• Apply deep learning library concepts to differentiate between TensorFlow, PyTorch, and Keras
• Analyze the architecture of Keras classification models in the context of predicting categorical target variables using given predictors, and interpret the probabilistic outputs generated
• Examine the key characteristics and differences between shallow and deep neural networks, and analyze the architecture and functionalities of convolutional neural networks
• Support claims on neural network architectures for sequence-based tasks by referencing their mechanisms, applications, and Keras-based translation model development
• Develop the ability to classify aircraft damage using a pre-trained VGG16 model and generate captions using a Transformer-based pre-trained model (BLIP)

Learn about generative AI models and their applications.

• Identify the various types of generative AI models and their applications across different domains
• Explain how to mitigate AI hallucinations through data quality, manipulation avoidance, model evaluation, fine-tuning, vigilance, oversight, and context provision in prompts
• Interpret how transformer models utilize self-attention mechanisms to facilitate text generation in a chatbot application
• Demonstrate proficiency in tokenizing text within the PyTorch framework and accurately implement tokenization and indexing techniques
• Examine how PyTorch data loaders optimize data preparation and loading for generative AI model training and evaluate the management and processing of variable-length sequences in PyTorch NLP data loaders

Explore document classification with PyTorch and building a language model with a neural network.

• Recognize and describe different methods of converting words to features and identify the key steps involved in building a text classification model using PyTorch and torchtext
• Identify PyTorch implementation of linear classifiers, logistic regression, and n-gram models for language modeling and neural networks
• Interpret, compare, and apply Word2Vec (CBOW, Skip-Gram) and GloVe embeddings in PyTorch for text classification
• Interpret the functionality, training process, and evaluation metrics of encoder-decoder RNN models for translation tasks, including data preparation and model architecture
• Implement an understanding of Perplexity, ROUGE, BLEU, and METEOR metrics to evaluate the quality of text generated by generative NLP models
• Test the application of pre-trained GloVe embeddings and Word2Vec models in PyTorch for text classification and evaluate the effectiveness of a sequence-to-sequence translation model using Perplexity and BLEU scores

Learn about transformer applications for translation and their PyTorch implementation.

• Explain the importance and implementation of positional encoding, attention mechanisms, and self-attention in transformer models
• Implement a Transformer model using PyTorch's “nn.Transformer” modules for natural language processing tasks
• Interpret how transformer attention layers retain contextual relationships between words within a text classification model
• Test a trained text classification model using PyTorch and torchtext on a news dataset and evaluate its performance metrics

Learn even more about transformer applications for translation and their PyTorch implementation.

• Recognize the key components and processes involved in language modeling with decoders and GPT-like models, including self-supervised learning and causal attention masking
• Select appropriate pre-trained models from HuggingFace for specific natural language processing tasks
• Interpret how BERT encoder models utilize masked language modeling for pretraining and explain the data preparation pipeline in PyTorch to train these models for natural language processing tasks
• Implement and evaluate a simplified BERT model for Next Sentence Prediction and Masked Language Modeling tasks utilizing PyTorch and torchtext
• Examine the implementation of a transformer model for language translation using PyTorch, including data preprocessing, model design, training methodologies, and evaluation metrics

Gain an understanding of transformer and advanced fine-tuning for Large Language Models.

• Identify Hugging Face and PyTorch for NLP, demonstrating Hugging Face Transformers for text classification and generation
• Select and justify appropriate pre-trained transformer models and fine-tuning strategies for various natural language processing tasks
• Explain the distinctions between full fine-tuning and parameter-efficient fine-tuning methods for adapting large pretrained models and adapter layers within transformer-based neural networks
• Interpret the functionality and benefits of Low-Rank Adaptation (LoRA), Hugging Face, the techniques of Quantization and QLoRA for efficient fine-tuning of large language models in PyTorch
• Use soft prompt techniques such as Prompt-tuning, Prefix tuning, and P-tuning to guide AI language models for specific outputs
• Demonstrate the process of instruction tuning using Hugging Face and evaluating model performance with BLEU scores and a text generation pipeline
• Test the effectiveness of a reward model and test the effectiveness of a fine-tuned large language model in distinguishing preferred responses
• Examine the utilization of Proximal Policy Optimization (PPO) with Hugging Face and trainer configuration for fine-tuning large language models
• Select and apply appropriate techniques for fine-tuning large language models (LLMs) locally using InstructLab

Learn about generative AI models and their applications.

• Explain Retrieval Augmented Generation (RAG) for LLM output optimization, and how PyTorch and Hugging Face Transformers evaluate content appropriateness
• Identify the key concepts and practical applications of prompt engineering for Large Language Models (LLMs)
• Use LangChain components to develop applications utilizing large language models, including prompt templates, chains, agents, and document processing tools
• Implement a text classification model using PyTorch and Torchtext to categorize news articles from various sources
• Examine the effectiveness of different text splitting techniques in LangChain, evaluating their impact on the efficiency and accuracy of Retrieval-Augmented Generation (RAG) systems
• Experiment with different pre-trained embedding models to generate document embeddings and evaluate their impact on downstream tasks
• Select appropriate retriever types for specific information retrieval tasks based on document structure and retrieval requirements
• Compare fine-tuning language models using InstructLab with Retrieval-Augmented Generation (RAG) for information retrieval and suitability based on specific needs and contexts
• Select appropriate Gradio components to build a user interface for interacting with a large language model
• Construct an n-gram language model and a text classification model using PyTorch and torchtext for natural language processing tasks