CAI4203: Deep Learning

Course Description

CAI4203 Deep Learning is the undergraduate course on neural networks — how they are built, how they are trained, why they work, and where they fail.

The course is offered at approximately five Florida institutions, including Florida Gulf Coast University, Florida International University, Florida Polytechnic University, the University of South Florida and the University of West Florida.

The University of West Florida places it in the Department of Computer Science at 3 semester hours, requires COP 3530 and MAS 3105, and describes a course introducing the fundamental concepts, architectures and applications of deep learning, covering both the theoretical foundations and practical implementation, emphasising neural networks, optimisation methods, and advanced architectures such as convolutional neural networks (CNNs) and recurrent neural networks (RNNs), with hands-on experience using popular frameworks such as TensorFlow or PyTorch to design, train and evaluate models for real-world tasks. Florida Gulf Coast University titles it Neural Networks and Deep Learning, also at 3 credits with a prerequisite of COP 3530, covering biological inspiration, network architectures and learning paradigms, unsupervised neural networks, single and multi-layer networks, recurrent networks, convolutional neural networks, generative models, deep reinforcement learning, transfer learning and pretrained models.

⚠ UWF's additional prerequisite of MAS 3105 — linear algebra — is the most informative difference between the two, and it is discussed in Special Information. It reflects a real curricular judgement about what this course requires.

The subject has an unusual property that shapes how it should be studied: it is simultaneously very new and very old. The mathematical core — a network of weighted sums and nonlinearities, trained by gradient descent using backpropagation — was established decades ago and has not fundamentally changed. What changed was scale: enough data, enough compute, and a set of engineering refinements that made deep networks trainable in practice. A student who understands backpropagation and stochastic gradient descent properly understands the mechanism behind systems that are described in the press as though they were unprecedented.

The second property worth stating at the outset is that deep learning is empirical to an extent that surprises students arriving from other computer science courses. Algorithms courses prove things. This field advances substantially by trying architectures and seeing what works, and theory frequently arrives afterwards to explain a result rather than predicting it. That is not a criticism, but it changes what competence looks like: a good practitioner is someone with well-developed judgement about what to try next when a model is not training, and that judgement is built by training a lot of models.

The third is that most of the work is not modelling. Students expect to spend the term designing architectures. In practice most time goes to data — obtaining it, cleaning it, checking it, splitting it correctly — and to debugging training runs that fail silently. A model that trains to a plausible-looking accuracy on a leaked test set is the characteristic beginner failure, and it is invisible unless you know to look.

Learning Outcomes

Required Outcomes

• Explain the structure of an artificial neuron and a feedforward network, and express a network's forward pass in matrix form.
• Explain and compare activation functions and the reasons for their use.
• Explain loss functions and select an appropriate one for a given task.
• Derive and explain backpropagation as the application of the chain rule, and compute gradients for a small network by hand.
• Explain gradient descent and its variants — stochastic, mini-batch, momentum, RMSProp, Adam — and their trade-offs.
• Diagnose and address overfitting and underfitting, and apply regularisation — weight decay, dropout, early stopping, data augmentation.
• Apply normalisation techniques and explain their effect on training.
• Explain and implement convolutional neural networks — convolution, pooling, stride, padding, receptive field — and apply them to image tasks.
• Explain and implement recurrent architectures — RNN, LSTM, GRU — and apply them to sequence tasks.
• Explain the attention mechanism and the transformer architecture.
• Apply transfer learning and fine-tune pretrained models.
• Build, train and evaluate models using PyTorch or TensorFlow.
• Construct a correct experimental protocol — train/validation/test splits, cross-validation, and avoidance of data leakage.
• Select and interpret evaluation metrics appropriate to the task and to class imbalance.
• Debug a failing training run systematically.
• Explain the limitations and failure modes of deep learning, including distribution shift, adversarial examples, spurious correlation and the absence of guarantees.
• Explain bias, fairness and accountability issues arising from deployed models.

Optional Outcomes

• Implement generative models — autoencoders, variational autoencoders, GANs, diffusion models.
• Apply deep reinforcement learning.
• Work with large language models — architecture, pretraining and fine-tuning.
• Apply graph neural networks.
• Apply self-supervised and contrastive learning.
• Apply interpretability methods.
• Deploy a model and address serving, latency and monitoring.
• Apply model compression — quantisation, pruning, distillation.
• Complete a substantial independent project or a competition entry.

Major Topics

Required Topics

• Foundations and framing. Machine learning within artificial intelligence, and deep learning within machine learning; supervised, unsupervised and reinforcement paradigms; the biological inspiration and its limits — the analogy to neurons motivated the field and is not a description of how these systems work; the historical arc — perceptron, the first AI winter, backpropagation, the second winter, and the scale-driven revival; what actually changed: data, compute and a set of engineering refinements, rather than a conceptual breakthrough.
• The feedforward network. The artificial neuron; layers and depth; matrix formulation of the forward pass, which is where linear algebra becomes non-optional; activation functions — sigmoid, tanh, ReLU and its variants, softmax — and why ReLU displaced the saturating functions; the universal approximation theorem and the important caveat that it says a network can represent a function, not that training will find it; why depth helps in practice.
• Training. Loss functions — mean squared error, cross-entropy — and their relationship to the task; backpropagation as the chain rule applied systematically, worked by hand on a small network at least once, which is the exercise that makes the rest of the course intelligible; automatic differentiation and computational graphs; gradient descent — batch, stochastic and mini-batch; optimisers — momentum, Nesterov, AdaGrad, RMSProp, Adam — and what each is compensating for; learning rate and schedules, which is the single most consequential hyperparameter; vanishing and exploding gradients and the architectural responses to them; weight initialisation, which matters more than students expect.
• Generalisation. The bias-variance framing and where it does and does not apply to deep networks; overfitting and underfitting, diagnosed from learning curves; regularisation — L1 and L2, dropout, early stopping, data augmentation; batch and layer normalisation; train/validation/test discipline and data leakage, which is the most common and most damaging methodological error in student projects and in published work; cross-validation; hyperparameter search.
• Convolutional networks. The motivation — parameter sharing, translation equivariance, local connectivity — and why a fully connected network on images is wasteful; the convolution operation, kernels, stride, padding, channels; pooling; receptive field; classic architectures — LeNet, AlexNet, VGG, ResNet and the residual connection, which is the idea that made very deep networks trainable; transfer learning and fine-tuning, which is how nearly all practical vision work is actually done; applications beyond classification — detection and segmentation in outline.
• Sequence models. Why sequential data needs different treatment; the recurrent network and backpropagation through time; the vanishing gradient problem in recurrence; LSTM and GRU and the gating mechanisms that address it; bidirectional and stacked recurrence; sequence-to-sequence models and the encoder-decoder structure; the attention mechanism and the problem it solved; the transformer — self-attention, multi-head attention, positional encoding — and why it displaced recurrence for most sequence tasks; word embeddings and representation learning.
• Frameworks and practical implementation. PyTorch or TensorFlow — tensors, autograd, modules, datasets and loaders, the training loop; GPU acceleration and why it matters; Google Colab or an equivalent as the practical compute route for students without hardware; experiment tracking; reproducibility and random seeds; reading and adapting existing model code, which is how the field actually operates.
• Working with data. Dataset construction, cleaning and inspection; splitting correctly, including the traps — temporal data, grouped data, and duplicate records that put the same item in train and test; class imbalance and its handling; preprocessing and normalisation; augmentation; the recurring finding that data quality dominates architecture choice for most practical problems.
• Evaluation and debugging. Accuracy and why it is frequently the wrong metric; precision, recall, F1, ROC-AUC and precision-recall curves, and choosing among them by what the errors cost; the confusion matrix; systematic debugging — overfit a single batch first, check the loss at initialisation, verify shapes, inspect the data, plot the learning curves; the specific diagnosis of a result that is too good, which is almost always leakage rather than success.
• Limits, failure modes and responsibility. Distribution shift and the failure of models deployed on data unlike their training set; spurious correlation — the well-documented cases where a model learned a background artefact or a scanner marking rather than the intended signal; adversarial examples; brittleness and the absence of guarantees; data and label bias, and how training data reproduces the conditions under which it was collected; fairness and the documented cases of disparate performance across groups; interpretability and its current limits; privacy and consent in training data; the professional point that a model's output is the engineer's responsibility, and "the model said so" is not an account of a decision.

Optional Topics

• Generative models — autoencoders, VAEs, GANs, diffusion models.
• Deep reinforcement learning — Q-learning, policy gradients.
• Large language models — pretraining, fine-tuning, prompting, retrieval augmentation.
• Graph neural networks.
• Self-supervised and contrastive learning.
• Interpretability and explainability methods.
• Deployment, serving, latency and monitoring in production.
• Model compression — quantisation, pruning, distillation.
• Multimodal models.
• Efficiency, energy use and the environmental cost of training.

Resources & Tools

• Deep Learning by Goodfellow, Bengio and Courville (MIT Press) — the standard reference, free online at deeplearningbook.org. Theoretically thorough; predates transformers, so supplement it for that.
• Dive into Deep Learning by Zhang, Lipton, Li and Smola — free at d2l.ai, interactive, with runnable code in PyTorch, TensorFlow and JAX. Arguably the best free resource for this course because it pairs the mathematics with working implementations.
• Deep Learning with Python by François Chollet — the most readable practical introduction; Keras-oriented and excellent on intuition.
• Neural Networks and Deep Learning by Michael Nielsen — free online, short, and the clearest explanation of backpropagation available anywhere. Read it in week two.
• Understanding Deep Learning by Simon Prince (MIT Press) — free PDF, recent, well illustrated, and covers transformers and diffusion properly.
• Probabilistic Machine Learning by Kevin Murphy — the comprehensive reference for the mathematical background.
• Frameworks and compute:
  • PyTorch — dominant in research and increasingly in industry; its tutorials are good.
  • TensorFlow / Keras — still widely deployed; Keras is the gentler entry.
  • Google Colab — free GPU access, and the reason a student without a graphics card is not excluded from this course. Kaggle Notebooks offers the same. Check whether your institution provides cluster access.
  • Hugging Face — models, datasets and the transformers library; the practical centre of gravity for pretrained models.
• Free courses worth using alongside: Andrej Karpathy's "Neural Networks: Zero to Hero" — building backpropagation and a transformer from scratch on video, and the single best supplement to this course; fast.ai's practical course; Stanford CS231n (vision) and CS224n (NLP) lecture notes, both public and both excellent.
• Data and practice: Kaggle — competitions, datasets and public notebooks; working through other people's notebooks is a legitimate and effective way to learn. Papers with Code; arXiv for current work, read with the awareness that it is not peer reviewed.
• Mathematics you will actually use: linear algebra — matrix multiplication, dimensions, and the ability to reason about shapes, which is the daily skill; multivariable calculus — partial derivatives and the chain rule, which is backpropagation; probability — distributions, expectation, and the cross-entropy loss. 3Blue1Brown's linear algebra and neural network video series is free and unusually good for building the geometric intuition.

Career Pathways

This is among the most directly employable courses in a computer science degree at present, and the guide is specific about what that does and does not mean.

• Data Scientists (SOC 15-2051) — the largest destination, and one where deep learning is one tool among several.
• Machine learning engineers (classified under SOC 15-1252, software developers) — building and deploying models in production, which is more software engineering than modelling and is where most of the jobs are.
• Computer and Information Research Scientists (SOC 15-1221) — research roles; generally requires a graduate degree.
• Software Developers (SOC 15-1252) — increasingly with ML components in ordinary product work.
• Computer Vision and NLP engineers — specialisations within the above.
• Data engineers (SOC 15-1243, 15-1244) — building the pipelines that make ML possible, an underrated and consistently in-demand role.
• MLOps and platform engineers — deployment, monitoring, versioning and infrastructure; a growing speciality.
• Biomedical and health informatics (SOC 15-1211 adjacent) — medical imaging and clinical prediction, with Florida's large health systems as employers.
• Defence and aerospace (SOC 17-2061, 15-1252) — the largest Florida employer of this skill set: sensor processing, autonomy, target recognition and simulation.
• Robotics and autonomous systems; quantitative finance; research scientist roles with a doctorate.

The Florida picture. The state's concentrations are defence and simulation in Orlando (Lockheed Martin, L3Harris, Northrop, and the large modelling and simulation cluster around UCF), aerospace on the Space Coast, healthcare informatics across the major systems, finance and technology in Miami and Tampa, and a growing startup sector in Miami. Florida Polytechnic, FIU, USF, UCF and UF all run substantial AI programmes, and UF in particular operates HiPerGator, one of the largest university AI supercomputers in the country, which supports research collaboration across the state system.

The honest career advice, which matters because this field is heavily hyped.

A single course does not make you a machine learning engineer. What it does is qualify you to keep learning, to contribute on a team, and to hold an informed conversation in an interview. The hiring bar for pure ML research roles is a graduate degree; the bar for ML engineering roles is strong software engineering plus ML competence — and the software engineering half is what most applicants underweight.

The three things that actually differentiate a graduate: a portfolio of projects you can explain, including what did not work and why, which interviewers ask about specifically; real software engineering skill — version control, testing, code that other people can read — because production ML is mostly engineering; and demonstrated ability to work with messy data, since clean benchmark datasets are not what the job involves. A student with one well-documented end-to-end project on real data is in a better position than one with a higher grade and no portfolio.

Special Information

⚠ Prerequisites differ, and the difference is a real curricular judgement

Institution	Title	Prerequisites
UWF	Deep Learning	COP 3530 and MAS 3105 (data structures + linear algebra)
FGCU	Neural Networks and Deep Learning	COP 3530 (data structures)

Both are 3 credits and cover the same material. The linear algebra requirement is the substantive difference and UWF has it right.

Why it matters concretely. A neural network's forward pass is a sequence of matrix multiplications. Backpropagation is the chain rule applied to that sequence. A student without linear algebra can follow framework code and cannot reason about it — and the most common practical error in this course, a shape mismatch between layers, is a linear algebra error that presents as a runtime exception. Every debugging session in this course is easier for a student who can think in terms of dimensions.

If your institution does not require linear algebra, take it anyway or learn it alongside. Matrix multiplication, dimensions, transpose, dot products, and enough intuition to reason about what a linear map does are sufficient — this is a few weeks of self-study, not a lost year, and 3Blue1Brown's series covers the intuition well.

Beyond the stated prerequisites, the practical assumptions are: strong Python — the course does not teach programming, and NumPy fluency in particular is assumed; multivariable calculus for the chain rule; and basic probability and statistics for the loss functions and evaluation. Students who struggle in this course are far more often struggling with Python or with linear algebra than with deep learning concepts.

⚠ Course content in this subject dates faster than any other in the curriculum

This is a genuine and unusual feature of the course, and students should plan around it.

Textbooks lag the field by two to four years. Goodfellow's Deep Learning, the standard reference, predates the transformer entirely. Architectures that dominated when a syllabus was written may be superseded by the time it is taught.

Two consequences. First, your instructor is probably supplementing with papers, blog posts and recent lecture material, and that is correct practice rather than disorganisation. Second, and more usefully: the fundamentals do not date. Backpropagation, gradient descent, regularisation, the experimental protocol, and the discipline of evaluating a model honestly are the same as they were a decade ago and will be the same a decade from now. Architectures are the fashion; the foundations are the course. A student who learns backpropagation properly can read a new architecture paper; a student who learned to call a library function cannot.

Also expect notable variation between sections. A course emphasising theory, one emphasising computer vision, one emphasising NLP and language models, and one emphasising deployment are all defensible designs. Read the syllabus if the emphasis matters to you.

Position in the curriculum

CAI4203 is a senior-level computer science elective, normally taken in the final year. The CAI prefix is the SCNS artificial intelligence prefix and is comparatively recent — its presence in a catalogue is a sign that a department has built out an AI concentration rather than teaching the material as a special topic.

It follows the programming and data structures sequence and normally sits alongside or after a general machine learning or artificial intelligence course, which is worth taking first where the option exists: deep learning is one family of methods within machine learning, and a student who meets it without the broader context tends to reach for a neural network on problems where a simpler model would be better, faster and more explicable. It pairs with data mining, computer vision, natural language processing, and the mathematics courses in linear algebra, probability and optimisation.

Course format and workload

Taught as a lecture with substantial programming assignments, normally with a term project. Assessment typically weights the programming work and the project heavily, with examinations on the theory.

Expect eight to twelve hours a week outside class, and the distribution is uneven in a way students should anticipate. Training runs take wall-clock time you do not control — a model that takes three hours to train cannot be started the night before, and a bug discovered at hour two costs the whole run.

⚠ Three practical warnings that come up every term:

• Start assignments early because of compute time, not because of difficulty. This is the most common cause of missed deadlines in this course and it is entirely predictable.
• Free GPU tiers have session limits and usage caps. Colab disconnects; work will be lost if you have not checkpointed. Save checkpoints and mount persistent storage from the first assignment.
• Debug in the right order. Overfit a single batch first — if a model cannot memorise ten examples, the bug is in the code and not in the hyperparameters. That one habit saves more time than any other.

Articulation and transfer

CAI4203 carries the same SCNS number across Florida public institutions and SCNS equivalency governs transfer of the credit. As an upper-division course it does not appear in A.A. programmes and is taken after transfer.

Two notes. The prerequisite difference above means a transfer student may arrive without linear algebra where the receiving programme expects it — check early. And because the field moves quickly, a receiving department evaluating this course for a specific requirement may ask what was covered; a syllabus from two years ago and one from this year can differ substantially. Keep the syllabus, and keep your project code — in this field the repository is better evidence than the transcript, for transfer and for hiring alike.

⚠ The honest framing of what deep learning can and cannot do

This belongs in the course because students arrive with expectations set by public coverage, and because a graduate who overstates what these systems do will cause harm in a job.

What they do well: pattern recognition in high-dimensional data — images, audio, text — where enough labelled examples exist and where the deployment data resembles the training data. That is a genuinely large and valuable class of problems.

What they do badly, and these are not temporary limitations awaiting more data: generalising outside the training distribution; providing guarantees about their behaviour; explaining their reasoning in a way that can be audited; establishing causation rather than correlation; and functioning with small data. They also reliably reproduce the biases in their training data, and the documented cases — models that learned a hospital's scanner artefact rather than the disease, or that performed markedly worse on some demographic groups — are the standard teaching examples for good reason.

The professional consequence. Deep learning is increasingly deployed in decisions that affect people — hiring, lending, medical diagnosis, criminal justice. An engineer who cannot say what a model's error modes are, what data it was trained on, and how its performance varies across groups is not qualified to deploy it in those settings. That is a technical competence as much as an ethical one, and it is what this course's evaluation and limitations material exists to build.

AI Integration

This course has the unusual property that AI is both its subject and a tool students will use to study it, and the two need separating carefully.

Where the tools genuinely help. Explaining concepts — a patient walk through backpropagation or the attention mechanism is a legitimate and effective use. Debugging — pasting a stack trace or a shape mismatch and asking what is wrong is fast and usually right, and it is what practitioners do. Boilerplate — training loops, data loaders and plotting code are repetitive and low-value to type. Reading papers — asking for an explanation of a section you did not follow. And code review of your own implementation.

⚠ Where they fail, and the failures here are specific.

Framework APIs change and generated code is frequently out of date. Deprecated calls, renamed arguments and signatures from an older version are common. The official documentation is authoritative; a plausible-looking call that does not exist is a normal outcome.

Generated training code often contains subtle methodological errors. The characteristic ones are data leakage — fitting a scaler before splitting, or splitting temporal data randomly — and evaluating on the test set repeatedly during development. The code runs, produces a good number, and is wrong. This is exactly the failure this course teaches you to detect, and it is a good reason to learn the protocol properly rather than delegating it.

Architecture and hyperparameter advice is generic. Suggestions come from what is common in the training data rather than from your data. The judgement about what to try next given a specific failing model is the practitioner skill, and it is built by doing it.

Recency. This field moves faster than model training data, so accounts of the current state of the art are unreliable. Papers with Code and arXiv are the check.

⚠ Academic integrity, and this course is a special case. Policies vary widely and you must read your instructor's — computer science departments range from prohibiting generated code to requiring students to use and critique it.

The argument specific to this course is worth stating without moralising. The programming assignments exist to build the debugging intuition that constitutes competence in this field. Deep learning debugging is unusually hard because a broken model does not crash — it trains, converges to something, and reports a number. Nothing tells you it is wrong. The ability to look at a learning curve and know that something is off is built by having been wrong many times, and it cannot be acquired any other way. A student who generates their assignments arrives at an interview unable to answer "what did you try when it wasn't converging?", which is the question interviewers in this field actually ask.

The reflexive point, which is worth raising in class. The systems you are using to study this course are the systems this course explains. A student who finishes it understands that the model producing confident code is a next-token predictor trained on a corpus, that it has no verification mechanism, and that its confidence is unrelated to its correctness — because those are properties of the architecture you have just spent a semester studying. That is a more durable form of AI literacy than any policy discussion, and it is one of the better reasons to take the course.