English:The AI system lifecycle and computational abstractions - AI Year 7
Introduction

Follow an AI idea from a clear purpose through data, an inspectable learned lookup, evaluation and monitored use. Trace an original library example, see why a paused service refers a previously familiar input, and explain what a computational abstraction keeps and leaves out.
Map a complete system and choose an abstraction
Bridge from an input and output to a complete system
An input is information a program receives; an output is what it produces. A model is a representation used to make a prediction or suggestion. A complete AI system also needs a purpose, suitable data, preparation, an interface, evaluation, human decisions and a way to stop or change the service. A trained component does not supply all of those by itself.
Our original scenario is a library helper that suggests a science or story review tray for a fictional book record, or returns ASK for a librarian to consider. It does not decide whether a book is good, appropriate for a child or worth reading. A real library contains overlapping topics and richer information; two labels and one tag are deliberately limited classroom choices.
Choose an abstraction and name what it leaves out
A computational abstraction represents selected features of a situation while leaving others out. Here we keep one supplied topic tag, such as space or quest, and two possible labels. We omit full text, author, language, readership and many other details. That makes a small example traceable, but it also prevents the program from understanding an entire book.
Ask whether the abstraction preserves what matters for the task. A garden tag can occur in both science and story examples, so one tag may not distinguish the two. Do not erase conflicting examples to create an appearance of certainty. A better future design might use richer, appropriate information or a different task, but it would need new evaluation rather than an unsupported claim of improvement.
Use seven lifecycle stages as a thinking tool
| Stage | Question or action | Original classroom example |
|---|---|---|
| Frame | Define a useful purpose and limits | Suggest a catalogue review tray, never decide book quality. |
| Collect | Obtain appropriate examples and provenance | Use only six original fictional labelled records. |
| Prepare | Check fields and choose an abstraction | Retain one topic tag; keep its limitations and conflicting examples. |
| Train | Derive a model from the examples | Count observed labels for each tag. |
| Evaluate | Compare predictions with predeclared expectations | Use five separate record identifiers and keep ASK distinct from automatic labels. |
| Deploy | Allow only an evaluated, approved version into its intended context | Create a private classroom object, with a manual fallback; no real service is launched. |
| Monitor | Check continuing use and withdraw when needed | Pause when review demand exceeds the preset classroom capacity rule. |
These seven stages form one useful classroom lifecycle, not a claim that every project follows a single compulsory linear process. Evaluation may reveal a need to return to framing or data preparation. Monitoring can lead to withdrawal and further review instead of automatic retraining. A real organisation must also address the permissions, responsibilities and operating context that our private example does not implement.
The program trace below labels these conceptual stages. Some implementation work is combined: fit validates training fields and constructs counts in the same function. The trace is not a separate workflow engine or evidence that a real service passed organisational approval. It lets you explain the selected representation and follow changes in a small, inspectable model and service state.
Fit a small model evaluate it and inspect the complete program
Connect a verified introduction with a small learned model
CodeAI: AI, What is Machine Learning? Use the actual creator example to distinguish deriving a model from examples from treating a computer as a person. Our classroom component below learns a tiny lookup of label counts. It is not a neural network, decision tree or large language model, and it does not infer a new book's meaning from its text.
| Training record | Supplied topic tag | Teacher-prepared label |
|---|---|---|
| T1 | space | science |
| T2 | space | science |
| T3 | quest | story |
| T4 | quest | story |
| T5 | garden | science |
| T6 | garden | story |
Fitting these six records gives space two science examples, quest two story examples, and garden one of each. Our explicitly conservative rule returns a label only when that tag has one observed label kind. A mixed tag returns ASK, even if later examples give one label more votes. An unseen or invalid tag also returns ASK. This is a limited learned lookup combined with a human-designed referral policy, not a calibrated probability.
Evaluate against expectations before allowing use
The five evaluation record identifiers below are separate from training identifiers. Some share known feature values, which is allowed in this classroom test; this does not establish broad generalisation to all books or unseen topic tags. Expected outputs are prepared before the demonstrated run, and no test record is added to the training list.
| Evaluation record | Input tag | Expected policy output | Actual demonstrated output |
|---|---|---|---|
| E1 | space | science | science |
| E2 | quest | story | story |
| E3 | space | science | science |
| E4 | garden | ASK | ASK |
| E5 | music | ASK | ASK |
All five outputs match these fixed policy expectations. Three of five are automatic labels, while two of five are referrals. Reporting five out of five as universal AI accuracy would hide those referrals and overstate the evidence. The classroom activation rule requires matched expectations, the same model identity, a deliberate approval flag and no more than half of the evaluation cases needing review.
Trace normal, ambiguous and unknown cases
For space, the learned count has only science, so the proposed label is science while the classroom service is active. For garden, two label kinds remain, so the output is ASK. For music, the model has no record, so the output is ASK. Hint: inspect the keys of the learned label-count entry rather than guess from the spelling of the tag. Partial step: garden has both science and story. Worked conclusion: the referral protects a limit of this abstraction; it is not proof that the book has no valid category.
Inspect and run the complete original Python example
Use an approved local Python environment with a teacher, or trace the supplied code and actual result on paper. The code uses only original fictional records and standard Python facilities. No account, remote model, browser session or public deployment is used. The approval flag is a toy condition, not a substitute for real permissions; the checksum checks model identity, not who has authority to approve it.
"""Offline classroom abstraction. No real catalogue, account, model API or deployment."""
from copy import deepcopy
import hashlib
import json
TRAIN = [
("T1", "space", "science"), ("T2", "space", "science"),
("T3", "quest", "story"), ("T4", "quest", "story"),
("T5", "garden", "science"), ("T6", "garden", "story"),
]
TEST = [
("E1", "space", "science"), ("E2", "quest", "story"),
("E3", "space", "science"), ("E4", "garden", "ASK"),
("E5", "music", "ASK"),
]
LABELS = {"science", "story"}
def fit(records):
"""Learn a small tag-to-label-count lookup from supplied fictional examples."""
if type(records) is not list or not records:
raise ValueError("Training records required")
counts, identifiers = {}, set()
for row in records:
if type(row) not in (tuple, list) or len(row) != 3:
raise ValueError("Three training fields required")
rid, tag, label = row
if type(rid) is not str or not rid or rid in identifiers:
raise ValueError("Unique training identifiers required")
if (type(tag) is not str or not tag.isascii() or not tag.isalpha()
or not tag.islower() or len(tag) > 12 or type(label) is not str or label not in LABELS):
raise ValueError("Unsupported training tag or label")
identifiers.add(rid)
own = counts.setdefault(tag, {})
own[label] = own.get(label, 0) + 1
return counts
def fingerprint(model):
return hashlib.sha256(json.dumps(model, sort_keys=True).encode()).hexdigest()
def classify(model, tag):
if type(tag) is not str or tag not in model:
return "ASK"
labels = model[tag]
# A conflicting feature does not become certain just because one label has more votes.
return next(iter(labels)) if len(labels) == 1 else "ASK"
def evaluate(model, cases):
predictions = [classify(model, tag) for _, tag, _ in cases]
return dict(model_sha256=fingerprint(model), total=len(cases),
matched=sum(got == row[2] for got, row in zip(predictions, cases)),
review=predictions.count("ASK"), predictions=predictions)
class ClassroomService:
"""A private Python object. The approval flag is a toy condition, not real account authority."""
def __init__(self, model, report, approved=False):
self.model = deepcopy(model)
self.expected_hash = fingerprint(model)
self.active = (approved is True and report["model_sha256"] == self.expected_hash
and report["total"] > 0 and report["matched"] == report["total"]
and 2 * report["review"] <= report["total"])
self.reason = "active" if self.active else "not approved or checks incomplete"
def withdraw(self, reason="withdrawn for review"):
self.active = False
self.reason = reason
def route(self, tag):
if fingerprint(self.model) != self.expected_hash:
self.withdraw("model changed after evaluation")
return classify(self.model, tag) if self.active else "ASK"
def monitor(self, tags):
if type(tags) is not list or not tags:
self.withdraw("no usable monitoring batch")
return dict(predictions=[], review=0, total=0, active=False, reason=self.reason)
predictions = [self.route(tag) for tag in tags]
review = predictions.count("ASK")
# Preset classroom capacity rule: pause when more than half need review.
if 2 * review > len(predictions):
self.withdraw("review demand above preset capacity")
return dict(predictions=predictions, review=review, total=len(predictions),
active=self.active, reason=self.reason)
def demonstrate():
trace = [{"stage": "FRAME", "state": "Suggest a review tray, never judge book quality"}]
data = deepcopy(TRAIN)
trace.append({"stage": "COLLECT", "state": "six fictional labelled records"})
# fit validates identifiers, tags and labels; raw records remain available.
model = fit(data)
trace.append({"stage": "PREPARE", "state": "one tag feature, two labels, conflicting garden retained"})
trace.append({"stage": "TRAIN", "state": model})
report = evaluate(model, TEST)
trace.append({"stage": "EVALUATE", "state": report})
service = ClassroomService(model, report, approved=True)
trace.append({"stage": "DEPLOY", "state": {"active": service.active, "scope": "private object only"} })
monitoring = service.monitor(["space", "garden", "music"])
trace.append({"stage": "MONITOR", "state": monitoring})
return dict(trace=trace, route_after_pause=service.route("space"))
if __name__ == "__main__":
print(json.dumps(demonstrate(), indent=2))The demonstrated execution produces the counts and five outputs shown above. Keep expected and actual results separate if you run a changed version. Do not claim a real catalogue was classified or an operational service launched: DEPLOY in this trace means that a private Python object becomes active under the stated classroom conditions.
Monitor boundaries withdraw and transfer the lifecycle
Monitor the system rather than only the model
CodeAI: AI, Training Data & Bias. Use the verified creator recording to ask how data choices influence what a system can do. Our six records are invented, not a representative survey of books or readers, and the referral-count example is not a measurement of bias against a real group.
The monitoring batch contains space, garden and music. Before the capacity decision, the private service returns science, ASK and ASK. Two of three cases need review. The preset classroom capacity rule pauses the service when more than half require review, so it becomes inactive. A later space input now returns ASK too, because the service is paused even though the underlying model still has its earlier science count.
This is a concrete counterexample to the claim that the trained model is the whole system. The same learned model can sit inside an active or inactive service with different resulting routes. Data flow, rules, human decisions, review capacity and withdrawal matter. The monitoring trigger reports review demand for these three cases, not a diagnosis of every cause or proof that the model suddenly became inaccurate.
Test a boundary and distinguish evidence from a guarantee
Exactly one referral in a two-case batch is half, so it does not exceed this preset capacity boundary. Two referrals in a three-case batch do exceed it. An empty or unusable monitoring batch triggers withdrawal with a no-data reason rather than a false claim of healthy monitoring. These are rules chosen for an original teaching example, not universal production thresholds.
The example also checks whether the service's model differs from the model identity evaluated earlier. A changed model requires a new evaluation instead of silently inheriting the old result. This simple checksum comparison is not a complete security system. Real authentication, permissions, data governance, operations and independent assurance remain outside this private classroom program.
Locate failures at the stage where they begin
A wrong purpose begins at framing. Unapproved examples are a collection problem. A missing field definition or over-coarse tag is a preparation and abstraction problem. A counting defect belongs to model construction. Test examples accidentally used for fitting compromise evaluation. Allowing an unapproved version into use concerns deployment. Ignoring an overloaded review queue concerns monitoring and operating procedures.
One symptom can involve several stages. A high ASK count might reflect new tags, conflicting examples, a changed task or a poor representation. Keep the actual input, state, expected output and observed output, then investigate rather than automatically blame a learner or add more rows. Preserving a previous version and a manual review route makes comparison and withdrawal clearer.
Transfer the lifecycle without reusing the wrong assumptions
Imagine a new fictional music archive whose task is to suggest instrumental or vocal review. You can reuse the questions about purpose, provenance, representation, evaluation and monitoring. You cannot reuse the library's science/story labels or assume its space/quest tags are meaningful for music. Some pieces contain both voices and instruments, so the new task may need multiple labels or another review policy.
Create appropriate original examples, declare expected behaviour before testing and justify a proportionate human fallback. A paper trace or successful small program provides evidence for the cases checked; it does not establish professional deployment, compliance, general reliability or practical competence in every real setting.
Interactive Tasks
Quiz: Test Your Knowledge
Why is a trained model only part of an AI system? (The system also needs data evaluation interfaces human decisions and monitoring) (!A model automatically supplies every permission and operating procedure) (!A model removes the need to define a task) (!One correct output proves every future result)
What is the selected abstraction in the original library example? (One supplied topic tag and two possible review labels) (!The full meaning of every book) (!Every reader identity and private interest) (!A complete real library catalogue)
What does the fitted lookup contain for garden? (One science example and one story example) (!A guarantee that every garden book is a story) (!No training record of any kind) (!A calibrated probability of perfect accuracy)
Why does garden return ASK under the stated policy? (Its supplied tag has conflicting label kinds) (!The program has proved the book is worthless) (!The tag automatically grants publication rights) (!Every unknown input must be called science)
What do the five demonstrated evaluation outputs establish? (Five fixed policy expectations match with three automatic labels and two referrals) (!Every future book will be classified accurately) (!Five new training records were added during evaluation) (!The service was publicly deployed)
What happens in the three-case monitoring batch? (Two referrals exceed half so the private service pauses) (!The model retrains itself on real reader data) (!The system deletes every book record) (!A half-threshold is proved universal for every organisation)
Why does a later space input return ASK after the pause? (The service is inactive even though the learned counts remain) (!The word space has changed its meaning automatically) (!Every training record has been silently removed) (!A real librarian account has been disconnected)
Which batch is exactly at the stated review boundary? (One referral among two cases) (!Two referrals among three cases) (!Three referrals among four cases) (!An empty batch claimed as healthy)
What does the model checksum establish in this example? (Whether the model matches the evaluated identity) (!Who has real authority to approve a service) (!That the model is fair in every context) (!That all data licences have been verified automatically)
What must change when transferring the method to a music archive? (Reconsider the purpose labels features examples and evaluation) (!Keep the library labels regardless of the new task) (!Assume the old test proves the new domain) (!Remove monitoring because the setting is different)
Memory Game
| Abstraction | A selected representation that leaves other detail out |
| Framing | Defining a purpose and limits |
| Training | Deriving a model from examples |
| Evaluation | Comparing outputs with predeclared expectations |
| Monitoring | Checking continuing system behaviour and conditions |
| Withdrawal | Stopping a service and using an agreed fallback |
Drag and Drop
| Agree the purpose and what the helper must not decide | Problem framing |
| Choose a tag representation and retain a conflicting example | Data preparation |
| Count labels associated with each training tag | Model fitting |
| Compare held-out record outputs with fixed expectations | Model evaluation |
| Pause when review demand exceeds a preset rule | System monitoring |
Crossword Puzzle
| MODEL | What selected representation is one system component? |
| FEATURE | What input detail can a topic tag represent? |
| TRAINING | What process derives counts from labelled examples? |
| EVALUATE | What do you do when comparing outputs with expectations? |
| MONITOR | What action checks continuing use? |
| WITHDRAW | What can you do when the service must stop? |
LearningApps
Optional extra practice. Choose an appropriate activity with your teacher. If the external collection is unavailable, use the native activities and independent tasks in this course.
Cloze Text
Open Tasks
Easy
- Order the lifecycle: Explain the seven classroom stages and place one possible failure at the stage where it begins.
- Name an abstraction: State what the library topic-tag representation keeps, what it omits and one question it cannot answer.
- Read the learned counts: Explain why space and quest receive labels while garden receives ASK under the stated policy.
- Separate model and service: Use the paused space case to explain how the same learned counts can produce a different service route.
Standard
- Trace five evaluation cases: Write expectations first, trace the program or use a supported actual run, and keep three automatic labels separate from two referrals.
- Investigate the capacity boundary: Compare one referral in two cases with two in three. Record the actual service state and explain the preset rule.
- Diagnose a stage failure: Choose a wrong task, unapproved data, coarse feature, leaked test, changed model or overloaded review case; explain the earliest relevant stage and a proportionate response.
- Keep a versioned evidence log: Record source data, model identity, expected and actual outputs, activation conditions, monitoring result and a limitation without inventing a real deployment.
Advanced
- Improve the abstraction: Propose appropriate additional fictional information for an ambiguous tag, preserve the original version and declare new evaluation cases before judging the change.
- Challenge a misleading success score: Explain why five matched policy outputs are not universal accuracy, and report automatic coverage, referrals, tested cases and untested limits clearly.
- Transfer to a music archive: Redefine purpose, labels and features for original instrumental/vocal examples, including a mixed case and a human review route.
- Design a proportionate system review: Connect lifecycle stages, human responsibilities, monitoring capacity and withdrawal. Distinguish a classroom trace, actual program run and evidence still needed before a real service.
Learning Check
- Explain the lifecycle: What seven stages are used here and why can a project revisit them?
- Interpret the abstraction and model: What do the six training records permit the lookup to represent?
- Report evaluation honestly: How should the demonstrated five-case result be described?
- Trace monitoring and withdrawal: Why does the later space input return ASK?
- Check boundaries and identity: What should the stated boundary and model-change cases do?
- Transfer the system questions: How would you adapt the approach to a new music archive?
Worked checks and assessment guidance
- The classroom map uses framing, collection, preparation, training, evaluation, deployment and monitoring. They organise questions about purpose, examples, representation, a derived model, evidence, use and continuing operation. They are not a compulsory universal linear process; problems can require returning to earlier stages, and validation/counting can share one implementation function.
- Space has two science labels, quest two story labels, and garden one of each. The representation retains one supplied tag and excludes most book information. The conservative policy labels a tag with one observed label kind and refers mixed, unseen or invalid tags. It does not read a book, learn a neural network or establish calibrated confidence.
- The actual code gives science, story, science, ASK and ASK, matching all five fixed expectations. Three of five are automatic labels and two of five are referrals. These are separate record identifiers from fitting, with some repeated feature values. This small policy check does not establish general accuracy, real-user performance or automatic classification of every book.
- The monitoring batch first returns science, ASK and ASK. Two of three need review, exceeding the preset half-capacity rule, so the private object becomes inactive. It then routes a later space input to ASK despite unchanged learned counts. The changed service state, not a new training result, explains the difference.
- One referral in two is exactly half and does not exceed the rule; two in three does. An empty or unusable batch withdraws rather than claiming healthy evidence. If the service model changes from the evaluated identity, it withdraws and refers. The toy approval flag and checksum are not real account authorisation or complete security assurance.
- Reuse lifecycle questions and evidence discipline, but reconsider purpose, labels, appropriate features, original examples and expected outcomes. Instrumental/vocal categories may overlap. Do not reuse science/story labels or treat old library tests as proof of the new task. Preserve versions, define a human fallback and state what remains untested.
Learning evidence
Retain an explained seven-stage system map, one abstraction choice and omission, original data provenance, the derived counts, model identity, expected and actual outputs, three-of-five automatic coverage and two-of-five referrals, the monitoring boundary and withdrawal trace, and a justified new-context plan. Distinguish conceptual stages, paper tracing and an actual limited program run. No real deployment, reader judgement, universal reliability, calibrated confidence, practical certification or complete curriculum coverage follows from this example.
OER and Wikipedia
DfE Computing: Key Stage 3 supports designing, using and evaluating computational abstractions; this AI lifecycle application and Year 7 placement are editorial enrichment. Google: Production ML systems supports the distinction between a model and the wider data, testing, serving and monitoring ecosystem. Relevant primary sections read 15 November 2026. The seven-stage classroom map, records, code, thresholds, trace, examples and assessments here are original, not a claim to implement Google's production system.
International books at Kent Library.jpg, Roc0ast3r, CC0. Original photograph unchanged; it illustrates a library context, not the fictional data or a real deployment at the photographed library.
https://www.youtube.com/watch?v=OeU5m6vRyCk — CodeAI: AI, What is Machine Learning? https://www.youtube.com/watch?v=x2mRoFNm22g — CodeAI: AI, Training Data & Bias. Original verified creator recordings embedded unchanged; publisher identity, playability, embedding permission and preview bytes checked. No endorsement, copied transcript, video redistribution or relicensing is implied.
The complete small Python program was actually executed with the original fixtures. A local standard-library demonstration is not a large language model run or a public service. No pupil records, real catalogue, remote model API, credentials, paid generation or physical device is used. The checksum is an identity comparison and the boolean approval is only a classroom condition.
Linked learning areas
aiMOOC Projects
Schulfach+


aiMOOCs


aiMOOC Projekte


MOOCwiki · Deutsch
Nach dem Lernen ist vor dem Lernen
Entdecke direkt den nächsten Lernkurs. Weitere Inhalte erscheinen, wenn Du weiter nach unten scrollst.
Zur MOOCwiki-HauptseiteMediathek
Mediathek wird aus dem Wiki geladen ...
Keine passenden Inhalte gefunden. Bitte ändere Suche oder Filter.
NEWSLernweltNOAH fragen