FIT5202 Data Processing for Big Data
FIT5202 Overview
- Monash University
- S2 2026
- 11 chapters
- Information Technology
FIT5202 Data Processing for Big Data is Monash University's postgraduate big-data unit in the Faculty of Information Technology, and it is organised around three themes: Volume (parallel databases and parallel algorithms), Complexity (machine learning at scale in Spark MLlib), and Velocity (real-time streaming with Kafka and Spark Structured Streaming).
- Assessed by Assignment 1 — Analysing Road Safety Data 15% · Assignment 2 Part A — Building ML Models 15% + 4 more
- Key terms Speed-up vs scale-up, Data partitioning, Data skew (Zipf), Cost model (network/shuffle)
- How to prepare Treat FIT5202 as three theme-toolkits rather than a reading unit.
- Most asked Where can I find past exam papers or practice for FIT5202?
How FIT5202 is assessed
| Component | Weight | Format |
|---|---|---|
| Assignment 1 — Analysing Road Safety Data | 15% | Individual; parallel data processing in PySpark; opens ~Week 4, due ~Week 6 |
| Assignment 2 Part A — Building ML Models | 15% | Individual; Spark MLlib feature engineering + classification, due ~Week 11 |
| Assignment 2 Part B — Streaming Application | 15% | Individual; Kafka producer + Spark Streaming + consumer (ZIP of three notebooks), due ~Week 14 |
| Weekly Quizzes (Weeks 2-11) | 5% | Ten online quizzes (0.5 each); no GenAI |
| Lab Attendance (Sessions 2-11) | 5% | Marked lab participation; 80% attendance = full mark: min(5, raw x 1.25) |
| Final Examination | 45% | E-assessment, 2h10m, closed book, scientific calculator; Weeks 1-12; Q1 MCQ + Q2-6 written |
What FIT5202 covers
FIT5202 is taught in three themes and this eleven-chapter map follows the teaching schedule through all of them.
Chapters 1–4 cover the Volume theme — the big-data V's, parallel databases and partitioning, parallel join and parallel sort/group-by; Chapters 5–8 cover the Complexity/machine-learning theme — featurization, decision-tree classification, k-Means clustering and collaborative filtering in Spark MLlib; Chapters 9–11 cover the Velocity/streaming theme — Kafka and Spark Structured Streaming, stream joins and granularity reduction.
Assessment runs through Moodle as Assignment 1, a two-part Assignment 2, weekly quizzes and marked labs, capped by a 45% final examination that is assessable across Weeks 1–12.
Introduction to Data Processing for Big Data
Big-data V's · volume/complexity/velocity · why parallelism (Week 1)Week 1 of Monash FIT5202 Data Processing for Big Data frames the whole unit: the big-data problem described by the V's (volume, variety, velocity, veracity, value), the three unit themes — Volume, Complexity and Velocity — and why a single machine cannot cope so parallel and distributed processing is needed.
- The 5 V's of big data — Volume, Variety, Velocity, Veracity, Value
- The three unit themes: Volume (Weeks 1–4), Complexity/ML (Weeks 5–8), Velocity/streaming (Weeks 9–11)
- Why single-machine processing fails: data-size scale (MB→GB→TB→PB→EB) and the case for parallelism
- Data partitioning → parallel scans → I/O parallelism (partition, then process in parallel)
- MapReduce (Map = filter, Reduce = aggregate) and why cheap nodes need fault tolerance (MTBF)
- Hadoop = MapReduce + HDFS; Apache Spark = in-memory batch (Spark Core) + real-time (Spark Streaming)
Parallel Databases & Parallel Search
Data partitioning (round-robin/hash/range) · parallel search · speedup/skew (Week 2)Week 2 of Monash FIT5202 formalises the Volume theme: shared-nothing parallel database architectures, the three data-partitioning strategies — round-robin, hash and range — and how partitioning decides which processors a search must activate.
- Shared-nothing (vs shared-memory, shared-disk) parallel database architectures
- Data partitioning: round-robin (even, no grouping), hash (localises exact-match), range (localises range queries)
- Parallel search in two steps: partition the data, then search locally in each partition
- Processor activation: which processors a query must touch depends on partitioning method + query type
- Speed-up = uniprocessor time / multiprocessor time; scale-up = small-system time / larger-system time
- Parallel obstacles: start-up and consolidation, interference and communication, and skew
Parallel Join
Divide-and-broadcast · disjoint partitioning · hash join · join cost model (Week 3)Week 3 of Monash FIT5202 covers parallel join — the most communication-heavy Volume operation.
- Parallel join in two steps: data partitioning, then a local join in each partition
- Divide-and-broadcast: divide one table into disjoint fragments, broadcast (replicate) the other to all
- Disjoint partitioning (hash or range): co-partition both tables so matching keys meet on one processor
- Local (serial) join methods: nested-loop, sort-merge, and hash join (build on the smaller table, probe with the larger)
- Cost model C_total = C_CPU + C_I/O + C_network; the network/shuffle term dominates in big data
- Divide-and-broadcast cost phases: scan, select, broadcast (data transfer), receive, store
Parallel Sort & Parallel Group-By
Parallel merge/redistribution sort · parallel aggregation · two-phase group-by (Week 4)Week 4 closes the Volume theme of Monash FIT5202 with parallel external sorting and parallel aggregation.
- Serial external sort-merge: Pass 0 sort phase, then (B−1)-way merge passes with a B-page buffer
- Counting passes: #runs = ⌈file pages / buffer pages⌉, then repeatedly merge (B−1) at a time
- Parallel Merge-All Sort (local sort + one final K-way merge — the merge is a bottleneck)
- Parallel Binary-Merge Sort (pairwise pipelined merge)
- Parallel Redistribution Binary-Merge and Redistribution Merge-All (redistribute to spread the merge)
- Parallel Partitioned Sort (range-redistribute, then independent local sort — no merge needed; skew risk)
Machine Learning: Featurization
Supervised/unsupervised · features & vectors · Spark MLlib pipeline · train/test (Week 5)Week 5 opens the Complexity theme of Monash FIT5202: machine learning at scale in Spark MLlib.
- Supervised (classification, regression) vs unsupervised (clustering, association) learning
- Features, feature vectors and the ML pipeline: featurization → training → evaluation → best model
- Spark MLlib and the ML Pipeline abstraction (transformers vs estimators)
- Featurization = Extraction + Transformation + Selection
- Extractors: CountVectorizer (token-count vectors), TF-IDF, Word2Vec
- TF-IDF: IDF(t,D) = log[(|D|+1)/(DF(t,D)+1)], TFIDF = TF·IDF (rare-but-frequent = important)
Machine Learning: Classification
Decision trees · entropy & information gain · evaluation (precision/recall/F1) (Week 6)Week 6 of Monash FIT5202 covers classification: decision trees built with the ID3 splitting criterion (entropy and information gain, log base 10 as taught), pruning and maxDepth, random forests and boosting, parallel/distributed tree learning, and classifier evaluation with the confusion matrix (accuracy, precision, recall, F1).
- Classification = predicting discrete categories (spam/not, churn/not, fraud/not)
- Decision-tree terminology: root, splitting, decision node, leaf, pruning, branch, homogeneity
- Entropy H(S) = Σ pᵢ·log(1/pᵢ) as a measure of uncertainty (log base 10 in the taught examples)
- Information gain IG(S,A) = H(S) − Σ (|Sᵢ|/|S|)·H(Sᵢ); split on the largest gain (ID3)
- maxDepth and overfitting; pruning to generalise
- Random forest (majority vote), bagging (bootstrap aggregating) and gradient boosting
Machine Learning: Clustering
k-Means algorithm · distance measures · choosing k · parallel k-Means (Week 7)Week 7 of Monash FIT5202 covers unsupervised clustering with the k-Means algorithm: initialise k centroids, assign each point to the nearest centroid (by Euclidean distance), update each centroid to its cluster mean, and iterate to convergence.
- Clustering = unsupervised grouping of similar objects (similar within, dissimilar between clusters)
- Euclidean distance d(a,b) = √Σ(aᵢ − bᵢ)² as the similarity measure
- k-Means: initialise k centroids, assign to nearest, update to cluster mean, iterate
- Convergence: stop when no point changes cluster (stable memberships)
- Choosing k (the elbow method)
- Parallel k-Means (data parallelism): share per-cluster sums and counts to form a global centroid
Machine Learning: Collaborative Filtering
User/item-based CF · cosine similarity · matrix factorization (ALS) (Week 8)Week 8 of Monash FIT5202 covers recommender systems: content-based versus collaborative filtering, user-based and item-based CF using cosine similarity, predicted ratings as a similarity-weighted aggregate, and model-based CF via matrix factorization (Spark MLlib's ALS).
- Recommender approaches: content-based vs collaborative filtering (memory-based vs model-based)
- User-based CF: find similar users, predict from their ratings, recommend top-N
- Cosine similarity over co-rated items: sim(u,u') = Σ rᵤᵢ·rᵤ'ᵢ / (√Σ rᵤᵢ² · √Σ rᵤ'ᵢ²)
- Predicted rating rᵤᵢ = k·Σ sim(u,u')·rᵤ'ᵢ with k = 1/Σ|sim(u,u')|
- Item-based CF as the transpose view of user-based CF
- Model-based CF: matrix factorization R ≈ U × V with r latent features (rank)
Stream Data Processing
Batch vs stream · Kafka topics/partitions · Spark Structured Streaming · windows (Week 9)Week 9 opens the Velocity theme of Monash FIT5202: batch versus stream processing, Apache Kafka (topics, partitions, producers, consumers and offsets), Spark Structured Streaming, event time versus processing time, and tumbling versus sliding windows over unbounded data.
- Batch vs stream processing; a data stream as an unbounded, ordered sequence
- Apache Kafka: topics, partitions, segments, producers, consumers, brokers and offsets
- The offset as the unique per-partition message id; Kafka does not track who consumed what
- Spark Structured Streaming and the producer–processor–consumer pattern
- Event time vs processing time (network delay makes them differ)
- Time-based windows (fixed duration; tuple count varies with arrival rate)
Stream Join Processing
Stream-stream & stream-static joins · windowed joins · watermarking (Week 10)Week 10 of Monash FIT5202 covers joining data streams: the symmetric hash join (SHJ) for two streams, the M-join for multiple streams, and windowed stream–stream joins where unbounded state must be bounded.
- Stream–static vs stream–stream joins; why unbounded state must be bounded
- Symmetric Hash Join (SHJ): each stream keeps its own hash table
- SHJ arrival handling: probe the other table, then insert into your own
- M-Join for multiple streams: remove expired tuples, probe all other tables, hash into your own
- Time-based window stream joins (tuple slide, time slide)
- Time-slide over basic windows (e.g. 1 basic window = 1 minute; window = 6; slide = 2)
Granularity Reduction in Data Streams
Sampling · sketches · sensor-array aggregation · load shedding (Week 11)Week 11 closes the Velocity theme of Monash FIT5202: reducing the granularity (volume) of streams through windowed aggregation and sampling, mixed levels of granularity (temporal and spatial), and sensor arrays with their reduce/merge/normalize aggregation methods.
- Granularity as level of detail: level-0 raw data (high granularity) vs aggregated higher levels
- Overlapped windows, NO reduction (slide = 1 record → moving average, #outputs = #inputs)
- Overlapped windows, WITH reduction (slide > 1 record)
- Non-overlapped (tumbling) windows, WITH reduction (slide = window size)
- Sampling to reduce volume (random with/without replacement, stratified, balanced)
- Mixed levels of granularity: temporal-based and spatial-based
It is a method-and-cost-model unit — the marks live in naming the right parallel algorithm or ML method, applying the taught cost model or formula, keeping the direction words straight (speed-up versus scale-up, over- versus under-estimate), and interpreting the result.
Monash runs FIT5202 assessment through Moodle as Assignment 1 (15%), a two-part Assignment 2 (Part A 15% + Part B 15%), weekly quizzes (5%) and marked lab attendance (5%), capped by a Final Examination worth 45% in the end-of-semester exam period.
Two threshold hurdles apply — an in-semester hurdle and a final-exam hurdle — so steady work across the whole semester matters, and the FIT5202 result feeds the Weighted Average Mark (WAM) that later Monash data-science units build on.
Worked example · free
Entropy and information gain for a decision-tree split
- +2Dataset entropy H(S) = Σ pᵢ·log₁₀(1/pᵢ) with p(Yes) = 9/14 and p(No) = 5/14. H(S) = (9/14)·log₁₀(14/9) + (5/14)·log₁₀(14/5) = 0.643·0.1924 + 0.357·0.4472 = 0.1237 + 0.1597 = 0.283.
- +1Sunny branch (3 Yes, 2 No): H = (3/5)·log₁₀(5/3) + (2/5)·log₁₀(5/2) = 0.6·0.2218 + 0.4·0.3979 = 0.1331 + 0.1592 = 0.292.
- +1Overcast branch (4 Yes, 0 No) is pure, so H = 0. The Rainy branch (2 Yes, 3 No) is the mirror of Sunny, so H = 0.292.
- +1Weighted entropy after the split H(S, Outlook) = Σ (|Sᵢ|/|S|)·H(Sᵢ) = (5/14)·0.292 + (4/14)·0 + (5/14)·0.292 = (10/14)·0.292 = 0.209.
- +1Information gain IG(S, Outlook) = H(S) − H(S, Outlook) = 0.283 − 0.209 = 0.074. In ID3 you compute this for every attribute and split on the one with the largest gain.
Key terms
- Speed-up vs scale-up
- Speed-up = uniprocessor time / multiprocessor time (same task, less time); scale-up = small-system time / larger-system time on a proportionally larger task (bigger task, same time). Linear speed-up grows with the processor count; linear scale-up equals 1.
- Data partitioning
- Splitting a table across processors so scans run in parallel. Round-robin spreads records evenly (load-balanced, no semantic grouping); hash sends a record to hash(key) mod N (localises exact-match queries); range assigns by value ranges (localises range queries).
- Data skew (Zipf)
- Uneven distribution of records across processors, modelled by a Zipf degree θ (0 = no skew, 1 = highly skewed). Skew creates one overloaded processor that dominates elapsed time and undercuts the speed-up of joins and sorts.
- Cost model (network/shuffle)
- The optimizer's estimate C_total = C_CPU + C_I/O + C_network of an execution plan. In big data the network (shuffle) term usually dominates, so parallel joins and group-bys are judged mainly on how much data they move between processors.
- Information gain
- The drop in entropy after splitting on an attribute A: IG(S, A) = H(S) − Σ (|Sᵢ|/|S|)·H(Sᵢ). ID3 builds a decision tree by choosing, at each node, the attribute with the largest information gain.
- Cosine similarity
- The angle-based similarity of two rating vectors over co-rated items, sim(u, u') = Σ rᵤᵢ·rᵤ'ᵢ / (√Σ rᵤᵢ² · √Σ rᵤ'ᵢ²). It drives user-based collaborative filtering: the most similar users predict a target user's missing ratings.
FIT5202 FAQ
Is FIT5202 hard?
It is broad rather than deeply mathematical. The unit spans three themes — parallel databases and algorithms (speed-up, partitioning, joins, sorting), machine learning in Spark (entropy and information gain, k-Means, collaborative filtering) and real-time streaming (Kafka, windows, stream joins) — plus three programming assignments in PySpark.
The maths is mostly logs, sums and cost models a scientific calculator can handle, so the challenge is keeping every algorithm, its cost model and its direction words straight across twelve weeks. Students who keep the weekly quizzes and labs warm on Moodle, rather than cramming through SWOTVAC, tend to find it manageable.
Can AI help me with FIT5202?
Yes, as a study aid rather than an answer machine. Sia is an AI tutor trained on how FIT5202 is actually taught and assessed: it can walk you through an entropy-and-information-gain split, explain why the network shuffle cost dominates a parallel join, trace a k-Means iteration or a symmetric-hash-join step by step, and check your reasoning on a practice problem.
It does not complete graded assessment for you — the three assignments, quizzes and exam are your own work — and Monash University academic-integrity rules apply, including the no-GenAI rule in quizzes and the exam.
Where can I find past exam papers or practice for FIT5202?
Start on Moodle, where the unit posts the Week-12 recap, the eAssessment information and any released practice material, and rework the weekly quizzes and lab tasks — they are the closest match to the exam's style.
This guide also includes a re-authored practice exam that mirrors the final's shape (a multiple-choice question plus written-response questions across parallel algorithms, Spark ML and streaming) with fresh numbers, and you can ask Sia to generate extra practice in the same style and then explain each step. Confirm exactly what is officially provided on your Semester-2 Moodle.
What are the FIT5202 hurdles and assessment rules?
Assessment is 55% in-semester (Assignment 1 15%, Assignment 2 Parts A + B 30%, weekly quizzes 5%, marked lab attendance 5%) and a 45% final examination. Two threshold hurdles apply: an in-semester hurdle (you must reach at least 45% of the in-semester marks) and a final-exam hurdle (you must score at least 45% on the exam itself).
Monash's standard also expects an overall pass — confirm the exact thresholds, and the exact hurdle wording, on your Semester-2 Moodle and in the unit guide. Missing a hurdle can mean failing (NH) even with a strong mark on the other side, so cover every theme.
What is the FIT5202 exam like?
The final is an e-assessment on the Monash eAssessment platform, about 2 hours 10 minutes, closed book, with a scientific calculator permitted (a basic calculator may not be enough for the log and cost-model arithmetic). It is assessable across all material from Weeks 1–12 and has six questions — Q1 is multiple choice and Q2–Q6 are hybrid/written-response — with all questions to be answered.
Budget roughly 20 minutes per question across the six, and confirm the exact duration, rules and permitted items on Moodle before the day.
Questions students ask in each FIT5202 chapter
- Why can't a single machine just process big data?
- Because volume outgrows one machine's memory, disk and I/O bandwidth, and processing time grows with the data. The unit's answer is to partition the data across many commodity processors and scan the partitions in parallel, turning one long scan into many short ones. That is the motivation for parallel databases (Weeks 2–4) and for Spark. Chapter 01 · Introduction to Data Processing for Big Data
- How do I decide which partitioning strategy to use?
- Match it to the dominant query. Use hash partitioning when exact-match lookups dominate (they hit one processor), range partitioning when range queries dominate (they hit a contiguous few), and round-robin when you mainly want even load with full scans. There is no universal best — the exam rewards justifying the choice by query type. Chapter 02 · Parallel Databases & Parallel Search
- When should I use divide-and-broadcast versus disjoint partitioning?
- Use divide-and-broadcast when one table is small enough to replicate cheaply — you broadcast the small table and every processor joins locally with no key-matching worries. Use disjoint (hash) partitioning when both tables are large, so co-partitioning on the join key moves far less data than broadcasting a big table. The decision is a cost-model comparison dominated by network traffic. Chapter 03 · Parallel Join
- How do I count external-sort passes quickly?
- Start with the Pass-0 run count ⌈file pages / buffer pages⌉. Then repeatedly divide by the merge fan-in (B−1), rounding up, counting one pass each time until you reach a single run. Add the Pass-0 sort as one pass. Reserving a buffer page for output is the detail people forget. Chapter 04 · Parallel Sort & Parallel Group-By
- Why does TF-IDF down-weight common words automatically?
- Because a word appearing in every document has DF = |D|, making IDF(t,D) = log[(|D|+1)/(|D|+1)] = log(1) = 0, so its TF-IDF is zero regardless of frequency. Words that appear in few documents get a positive IDF and higher weight. This is why TF-IDF favours discriminating terms without a hand-built stop-word list. Chapter 05 · Machine Learning: Featurization
- Why does FIT5202 use log base 10 for entropy?
- Because the taught worked examples were computed in base 10 (for example H(9 Yes, 5 No) ≈ 0.283), so reproducing those numbers requires base 10. Information theory often uses base 2 (bits), but for this unit's exam use base 10 so your entropy and gain values match the marking scheme. State the base you use. Chapter 06 · Machine Learning: Classification
- How does k-Means decide a point's cluster?
- It assigns each point to the cluster whose centroid is closest by Euclidean distance. In one dimension that is just the smallest |x − centroid|. After all points are assigned, each centroid moves to the mean of its members, and the process repeats until no point switches cluster. Chapter 07 · Machine Learning: Clustering
- Why compute cosine similarity only over co-rated items?
- Because a similarity is only meaningful where two users have both expressed a preference. Including items only one of them rated would compare a rating against a missing value. So you restrict the sums in the cosine formula to the items both users rated, then use those similarities to weight predictions. Chapter 08 · Machine Learning: Collaborative Filtering
- What is the difference between a tumbling and a sliding window?
- Both have a fixed size, but a tumbling window's slide equals its size, so windows do not overlap and each item belongs to exactly one window. A sliding window's slide is smaller than its size, so windows overlap and an item can appear in several windows. Tumbling reduces the output rate; sliding keeps it near the input rate. Chapter 09 · Stream Data Processing
- Why does a stream join need a hash table on each side?
- Because tuples that should join can arrive at different times and in either order. If only one stream were hashed, a tuple arriving on the other stream before its partner would be lost. Keeping a symmetric hash table on each stream means whichever tuple arrives first is stored, ready to be probed and matched when its partner arrives. Chapter 10 · Stream Join Processing
- How do I classify a windowed granularity-reduction scheme?
- Compare the slide to the window size. If the slide is one record (or one time unit), consecutive windows overlap and outputs equal inputs — overlapped, no reduction (a moving average). If the slide is larger than one record but smaller than the window, it is overlapped with reduction. If the slide equals the window size, the windows are tumbling (non-overlapping) with reduction. Chapter 11 · Granularity Reduction in Data Streams
How to study for the exam
Treat FIT5202 as three theme-toolkits rather than a reading unit. For Volume, drill the recurring calculations until they are automatic — speed-up versus scale-up, processor activation under round-robin/hash/range partitioning, external-sort passes, and the divide-and-broadcast cost model — and always state which cost term dominates.
For Complexity, rehearse the entropy-and-information-gain split (log base 10, as taught), a k-Means iteration, precision/recall/F1 from a confusion matrix, and cosine-similarity prediction, each end to end with units. For Velocity, be able to trace a tumbling-versus-sliding window, a symmetric-hash-join arrival sequence, and a sensor-array reduce-then-merge.
Keep the weekly Moodle quizzes and marked labs warm week by week rather than cramming in SWOTVAC, because both hurdles reward breadth: make sure you can start every theme's question before deepening the ones you find hardest.
When a step will not click, ask Sia to re-explain that single line a different way and set you a fresh practice question in the same style — it teaches the method and checks your reasoning, and it never substitutes for your own graded work.
Your AI Information Technology tutor for FIT5202
Stuck on a hard FIT5202 question? Sia is AskSia’s AI Information Technology tutor — ask any FIT5202 Data Processing for Big Data question and get a clear, step-by-step explanation grounded in how the course is actually taught and assessed. Read this whole study guide free, then take your hardest questions to Sia.