Introduction to Machine Learning and Deep Learning

In 2016 the Google supercomputer AlphaGo beat the world champion of the board game Go, a highly complex mathematical game. This milestone demonstrated the possibilities of Artificial Intelligence and set the scene for new technologies which are now transforming our lives, from the way we drive to the way we buy clothes. Thanks to recent advances in graphics acceleration hardware and neural network development tools, the benefits of Artificial Intelligence are within reach for any business. This presentation introduces the underlying theory of Machine Learning and Deep Learning and explains how to practically apply it. Topics covered include the training process, model types, development tools, common pitfalls and real-life examples. Attendees will walk away with a kick start to help them apply Machine Learning and Deep Learning in their projects.

What this presentation is about and why it matters

Peter McLaughlin’s talk, "Introduction to Machine Learning and Deep Learning," explains the practical ideas behind teaching computers to learn instead of hand-coding every rule. He contrasts classic rules-based systems (Deep Blue) with modern data-driven approaches (AlphaGo) to show why, for many signal-processing problems, building a model from data is more scalable and flexible than writing rules. For engineers working with signals (images, audio, sensor streams), this matters because the industry is shifting from hand-crafted feature pipelines and filters toward learned representations that can absorb far more raw information and adapt to changing conditions. The talk covers the training loop, model types (supervised vs unsupervised; classification vs regression), deep learning’s ability to work from raw pixels/samples, and common deployment pitfalls such as overfitting, bias, and hidden business costs.

Who will benefit the most from this presentation

• Signal-processing engineers who want to apply ML/DL to image, audio, or sensor tasks (e.g., detection, classification, regression).
• Early-career engineers or students with basic DSP/math background who need a practical introduction to model workflows and trade-offs.
• Project leads evaluating whether to use rules-based algorithms or machine learning for industrial automation.
• Engineers transitioning from feature-based pipelines (hand-crafted descriptors, filters) to neural-network-based solutions.

What you need to know

The talk is introductory but technical. To get the most from it, you should be comfortable with:

• Basic linear algebra and vectors (signals represented as vectors or matrices).
• Elementary probability and statistics (distributions, mean, variance, conditional probability).
• Core DSP concepts: sampling, filtering, feature extraction (edges, texture descriptors, spectral features).
• Basic programming experience (Python or similar) and familiarity with the idea of a dataset (training/validation/test splits).

Two short equations used in the talk are helpful to recall:

• Linear model (simple regression / perceptron view): $y = \mathbf{w}^\top \mathbf{x} + b$, where $\mathbf{x}$ is the input feature vector and $\mathbf{w}$ and $b$ are learned parameters.
• Mean squared error (a common loss): $L = \frac{1}{N}\sum_{i=1}^N (y_i - \hat{y}_i)^2$, which the optimizer minimizes by updating weights.

Also be aware of these workflow ideas: extract or ingest features (machine learning often uses hand-crafted descriptors; deep learning often ingests raw signals), choose model class, train using a loss and an optimizer, validate on held-out data, and evaluate real-world cost of errors before deployment.

Glossary

• Model — a mathematical simplification of data that maps inputs (signals/features) to outputs (labels or values).
• Feature — a number or set of numbers extracted from a signal (e.g., spectral energy, texture descriptor, pixel values) used as model input.
• Supervised learning — training where each input has a labeled target (e.g., defective/not defective); common for detection and regression tasks.
• Unsupervised learning — discovering structure (clusters, latent factors) in unlabeled signals; useful for anomaly detection and dimensionality reduction.
• Classification — predicting discrete classes from signal inputs (e.g., material A vs B).
• Regression — predicting continuous values from signals (e.g., liquid level, temperature).
• Loss function — a scalar that measures prediction error during training (e.g., MSE, cross-entropy) and guides optimization.
• Overfitting — when a model learns training-specific noise and fails to generalize to new signals; a central deployment risk.
• Optimizer — algorithm (SGD, Adam, etc.) that updates model parameters to reduce loss during training.
• Inference — running a trained model on new signals to produce predictions; practical constraints include latency and compute cost.

Final thoughts

Peter’s talk strikes a useful balance between conceptual framing and practical advice. He uses clear real-world examples (chess vs Go, industrial vision tasks) to explain why data-driven models can outperform hand-coded rules for complex or changing signal problems, and he emphasizes the engineering realities: data quality, compute trade-offs, validation practices, and business costs. If you work on signal-processing systems and are wondering whether to hand-tune filters and descriptors or start building learned pipelines, this presentation is a concise, pragmatic primer that will help you decide where to invest effort and how to avoid common traps. It’s especially helpful for engineers who want to move quickly from idea to a monitored prototype: narrow the problem, do a quick sniff test, and iterate.

This overview is AI-generated from the session transcript. Spot an issue? Let us know.