We have a method (08-01) and we have learned from other people's projects (08-02). What remains is the question Diego asks at every budget meeting: "And how is this going to change in two years?". This lesson answers with caution. AI moves fast and any lesson that gives dates and figures goes stale before it is published, so here we will not give them: we will classify each trend as established (already in production and not going away), emerging (works in many places but its final form is yet to be decided) or speculative (there is serious debate about whether and when it will happen), and for each one we will say what it means in practice. We will cover foundation and multimodal models; agents that use tools and plan, with which the agent of 02-01 comes back to centre stage; generative AI in the enterprise and its risks; explainable AI, with a runnable example on the returns predictor; regulation and governance; AI at the edge and small models, with a quantisation done by hand; neurosymbolic AI and reasoning; AI in science; the debate on AGI and safety; and the impact on employment and on the skills of a junior profile. And we will land it in a one-to-three-year roadmap for NovaMarket. It matters because the professional who leaves this course will work with the AI of three years from now, not today's: they need judgement to separate what must be learned now from what is enough to follow from a distance.
Contents
- How to read a trend: established, emerging, speculative
- Foundation and multimodal models
- AI agents that use tools and plan
- Generative AI in the enterprise: copilots, automation, code and risks
- Explainable AI (XAI): SHAP and LIME at the level of ideas, and a runnable example
- Regulation and governance: AI Act, audits, model cards, watermarks
- AI at the edge and small, efficient models
- Neurosymbolic AI and reasoning
- AI and science
- The debate on AGI and AI safety
- Impact on employment and skills of the junior professional
- NovaMarket's one-to-three-year roadmap
- Summary table: trend → status → practical implication
- Common Mistakes and Tips
- Exercises
- Conclusion
- How to read a trend: established, emerging, speculative
In 01-01 we saw that AI winters arrive after periods of over-expectation. The best vaccine is to distinguish degrees of certainty. We will use three labels:
| Label | Meaning | What to do with it |
|---|---|---|
| Established | It is in production in many organisations, there are mature tools and it does not depend on a pending breakthrough | Learn it and use it now |
| Emerging | It works and is spreading, but the final form (tools, standards, good practice, cost) is still changing | Try it in bounded pilots; do not build the business on it without a plan B |
| Speculative | There is serious debate among experts about whether, how and when it will happen | Follow it with judgement; do not take irreversible decisions based on it |
The same trend can have parts under different labels: large language models are established as a text tool and emerging as autonomous agents.
- Foundation and multimodal models
A foundation model is a large, general-purpose model pretrained on massive data (05-05), which is then adapted to specific tasks with instructions, RAG or fine-tuning. The established trend is that fewer and fewer projects train from scratch: you start from a foundation model (of language, vision, audio) and specialise it. The emerging trend is multimodality: the same model processes and generates text, images, audio, video and structured data, so that the border between "the assistant's text model" and "the photo CNN" blurs.
Practical implications:
- Value shifts from training to your own data, integration and evaluation: whoever has good data about their business and knows how to measure has the advantage, not whoever has the biggest GPU.
- A vendor dependency appears (models served through an API): variable cost, version changes that alter results, data leaving the company. Open alternatives and locally run models must be evaluated (07-03).
- Evaluation gets harder: there is no AUC for "answers well"; you need your own test sets and human review (08-01, phase 5).
For NovaMarket: the assistant (use case 7) already relies on a foundation model with RAG; multimodality will let the customer send the photo of the defective product in the same chat and the system join the photo classification (use case 9) with the diagnosis and the return rules.
- AI agents that use tools and plan
In 02-01 we defined the agent as something that perceives, decides and acts to maximise a performance measure, and in 05-05 we saw that an LLM can be used as an agent: it receives a goal, decides which tool to call (search a database, run code, query an API, write an email), observes the result and repeats until done. The emerging trend is that these agents plan multi-step tasks, keep memory and collaborate with each other. The agent of 02-01, which looked like a textbook concept, comes back to centre stage: the LLM is the decision function and the tools are the actuators.
Status: established in bounded tasks with few tools and human supervision (an assistant that looks up the status of an order and creates a ticket); emerging in long, open-ended tasks; speculative in broad autonomy without supervision.
What does not change, and is worth keeping in mind:
- The PEAS of 02-01 is still the design tool: which performance measure, which environment, which actuators (every tool is an actuator with consequences!) and which sensors.
- Every action with an effect on the world (a refund, an email, a change in stock) needs permissions, limits and logging: it is human-in-the-loop (02-04) applied to agents.
- Errors chain: an agent that gets step 2 wrong drags the error through to step 8. Evaluation by complete tasks, not by isolated answers, is mandatory.
For NovaMarket: the natural evolution of the assistant is an agent that, faced with "my NovaSound arrived broken", looks up the order, classifies the photo, applies the return rules (06-02) and prepares (does not execute) the return request for a person to confirm. Every tool it is given is a business and risk decision.
- Generative AI in the enterprise: copilots, automation, code and risks
Three established uses and one emerging:
- Copilots for knowledge tasks: drafting, summarising, translating, searching internal documentation (RAG). Established; the return depends on people learning to use them and to verify.
- Code generation: assistants that complete, explain and refactor code and write tests. Established in day-to-day development; it changes how the programmer works (more review, more design, less typing), it does not eliminate them.
- Process automation with natural language: classifying and routing emails and tickets (the routing of 06-04 with an LLM as classifier), extracting data from documents, generating product descriptions. Established in low-risk tasks with supervision.
- Generation of commercial content and images/video at scale: emerging, with open questions of rights, brand and quality.
Risks the company must manage: hallucinations (08-02, case 5); data leakage to external services (a clear policy on what can be pasted into an external chat); copyright and licences of the generated content and of the training data; dependency and variable cost; homogenisation and loss of quality if nobody reviews; and the effect on people (02-04): training, redefinition of roles, transparency about when a customer is talking to a machine.
For NovaMarket: descriptions for the 12,000 products generated and reviewed by the content team; review summaries (use case 4) for the product team; an internal copilot with RAG over the warehouse procedures; and a simple rule: no customer data in external tools without a data-processing agreement.
- Explainable AI (XAI): SHAP and LIME at the level of ideas, and a runnable example
As models get more complex and regulation demands explanations (02-04, GDPR and AI Act; 06-04, the explanation as part of the system), explainable AI (XAI) goes from academic field to project requirement. Status: established for tabular models; emerging for deep networks and LLMs.
Two families of explanations:
- Global: which features matter in general. The coefficients of the logistic regression (04-04), the importance in trees and forests, and permutation importance: shuffle a column at random and measure how much the metric gets worse; if it does not get worse, the column did not matter (for that model).
- Local: why this order got this probability. In the logistic regression it is enough to multiply each (already transformed) feature by its coefficient and see what it contributes to the logit. For opaque models there are general methods: LIME fits a simple (linear) model around the specific case, by perturbing it, and explains that local model; SHAP distributes the prediction among the features according to game theory (Shapley values: the average contribution of each feature over all possible combinations), with consistency guarantees and mature libraries. The common idea: any model can be explained locally by approximating it with something simple near the case.
Runnable example on the returns predictor of novamarket_ai/, with no additional libraries:
# Run from the root of novamarket_ai/ (with the package installed or PYTHONPATH=src)
import numpy as np, pandas as pd
from sklearn.inspection import permutation_importance
from novamarket.train import train
pipe, auc, ctx = train(n=3000, seed=42) # the usual predictor (AUC 0.844)
Xte, yte = ctx["Xte"], ctx["yte"]
# 1) GLOBAL explanation: permutation importance (how much AUC do I lose if I shuffle this column?)
r = permutation_importance(pipe, Xte, yte, scoring="roc_auc", n_repeats=10, random_state=42)
importances = pd.Series(r.importances_mean, index=Xte.columns).sort_values(ascending=False)
print("AUC drop when permuting each feature:")
print(importances.head(6).round(3).to_string())
# 2) LOCAL explanation for an order in the "review" queue: contribution of each column to the logit
prep, model = pipe.named_steps["prep"], pipe.named_steps["model"]
i = int(np.argmax((ctx["prob_test"] >= 0.2) & (ctx["prob_test"] < 0.5))) # first order in the band
x = prep.transform(Xte.iloc[[i]])
x = x.toarray() if hasattr(x, "toarray") else x
contributions = pd.Series(x[0] * model.coef_[0], index=prep.get_feature_names_out())
print(f"\nOrder {Xte.index[i]}: prob = {ctx['prob_test'][i]:.3f} "
f"(amount €{Xte.iloc[i]['amount']}, {Xte.iloc[i]['delivery_days']:.0f} delivery days, "
f"{Xte.iloc[i]['category']}, new_customer={Xte.iloc[i]['new_customer']})")
print("Contributions that push most (positive = more risk):")
print(contributions.sort_values(key=abs, ascending=False).head(5).round(2).to_string())Actual output:
AUC drop when permuting each feature: amount 0.132 new_customer 0.119 delivery_days 0.040 category 0.013 num_items 0.009 previous_orders 0.003 Order 2314: prob = 0.402 (amount €289.71, 6 delivery days, home, new_customer=0) Contributions that push most (positive = more risk): num__amount 1.91 num__delivery_days 0.65 nom__category_home -0.21 num__num_items 0.20 bin__weekend -0.19
Explanation:
- Permutation importance works on the full
Pipelineand the original columns: shufflingamountmakes the AUC drop 0.13 points (from 0.844 to about 0.71);new_customer, 0.12;delivery_days, 0.04. The rest hardly matter, andpostcode_zonedoes not appear among the top six: consistent with the fact that in the fictional data it has no influence, and exactly what an auditor would want to see (02-04). - The local explanation says why order 2314 is in the review band with probability 0.40: an amount of €290 (contribution +1.91 to the logit) and six delivery days (+0.65) push upwards; being home goods (−0.21) and being bought at the weekend (−0.19) push a little downwards; and it is not a new customer. It is the sentence Diego's reviewer should see next to the order: "medium risk due to high amount and slow delivery". With SHAP you would get the same for a forest or a network, with the same reading.
For NovaMarket: the local explanation goes into the "review" queue of predict_batch.py (a reason column with the two largest contributions) and into the model card; and when the recommender or the photo classifier use opaque models, SHAP and its equivalents for images will be part of the deliverable, not an extra.
- Regulation and governance: AI Act, audits, model cards, watermarks
In 02-04 we presented the European AI Regulation (AI Act) with its risk levels. The established trend is that it applies progressively (the prohibitions first, the high-risk obligations and those for general-purpose models later, with deadlines best checked in the official source at any given moment) and that it drags along an ecosystem of technical standards, guidance and audits. What it is going to ask of a company like NovaMarket, without dates:
- Inventory of AI systems in use and classification by risk (the table of the nine use cases in 02-04 is that inventory).
- Documentation: model cards and datasheets (08-01), impact assessment for anything that affects people, decision log.
- Transparency: informing people when they interact with an AI (the assistant) and marking generated content; watermarks (invisible signals in generated text, image, audio or video) and content-provenance standards are emerging technically but established as a requirement.
- Effective human oversight and internal or external audits of the higher-risk systems; AI literacy for staff.
- Outside Europe, different frameworks (more sectoral or voluntary), which complicates things for anyone operating in several countries.
Status: established that it will have to be complied with; emerging exactly how (harmonised standards, certifications). Practical implication: doing from now on what we have already done in 08-01 (documenting, measuring per group, reviewing) is the cheap way to arrive prepared.
- AI at the edge and small, efficient models
Against the race for ever larger models, an equally real trend runs in the opposite direction: small, efficient models run close to the data (edge: the phone, the warehouse camera, the delivery driver's handheld), for three reasons: latency, privacy (the data does not leave the device, 02-02 cloud vs device) and energy cost (02-04, sustainability). Established techniques: distillation (a small model learns to imitate a large one), pruning (removing weights that add nothing) and quantisation (storing the weights with fewer bits, for example 8-bit integers instead of 32- or 64-bit reals), as well as specialised hardware. Emerging: small language models that run on a laptop or a phone with sufficient quality for many tasks.
Quantisation can be understood in ten lines on our own model:
import numpy as np
from novamarket.train import train
pipe, auc, ctx = train()
model, prep = pipe.named_steps["model"], pipe.named_steps["prep"]
w = model.coef_[0] # 21 weights in float64 (8 bytes each)
# Symmetric 8-bit quantisation: an integer in -127..127 and ONE scale factor are stored
scale = np.abs(w).max() / 127
w_int8 = np.round(w / scale).astype(np.int8) # 21 one-byte integers
w_recovered = w_int8 * scale # what the quantised model "sees"
X = prep.transform(ctx["Xte"]); X = X.toarray() if hasattr(X, "toarray") else X
z_orig = X @ w + model.intercept_[0]
z_quant = X @ w_recovered + model.intercept_[0]
p_orig, p_quant = 1 / (1 + np.exp(-z_orig)), 1 / (1 + np.exp(-z_quant))
print(f"Weight size: {w.nbytes} bytes -> {w_int8.nbytes} bytes (+ 1 scale)")
print(f"Maximum probability difference: {np.abs(p_orig - p_quant).max():.4f}")
print(f"Orders that change queue (edges 0.2 and 0.5): "
f"{(np.digitize(p_orig, [0.2, 0.5]) != np.digitize(p_quant, [0.2, 0.5])).sum()} of {len(p_orig)}")Actual output:
Weight size: 168 bytes -> 21 bytes (+ 1 scale) Maximum probability difference: 0.0082 Orders that change queue (edges 0.2 and 0.5): 3 of 750
The weights take up eight times less space and the probability changes by at most 0.008; only 3 of 750 orders cross a queue boundary (the ones that were right on the edge). In a logistic regression with 21 weights the saving is anecdotal; in a network of billions of parameters it is the difference between needing a server with a GPU or fitting on a phone, with the same kind of small, measurable loss. The lesson is the method: quantise and measure how many decisions change, never assume "it is the same".
For NovaMarket: the incident-photo CNN (use case 9) quantised and run on the delivery driver's handheld, offline, to classify the photo at the moment of collection; and a purchasing criterion: before paying for a large model through an API, test whether a small local one solves the task with the necessary quality and at a fraction of the energy cost.
- Neurosymbolic AI and reasoning
In 06-04 we saw that rules and models complement each other: the model's probability as a fact for the rule engine, the review band, rule-based validation of the assistant's answers. The trend (emerging in research, established in engineering practice) is that this combination is being formalised: language models that call symbolic tools (calculators, databases, logic engines, the planners of module 3) instead of "reasoning" on their own; knowledge graphs that anchor the answers; and models trained to produce verifiable step-by-step chains of reasoning. Speculative: whether these techniques will lead to reliable general reasoning or remain useful patches.
Practical implication: when a task demands exactness (arithmetic, deadlines, policies, inventory), the model is not asked to solve it from memory: it is asked to call the right tool. It is what we did in 06-04 and what the assistant-agent of section 3 does with the return rules.
- AI and science
AlphaFold (08-02, case 3) is the most cited example of an established trend: AI as a scientific instrument, to predict protein structures, propose new materials and drug candidates, speed up physical and weather simulations, analyse astronomical or medical images at scale. Emerging: "autonomous laboratories" in which a system proposes hypotheses, designs experiments and a robot runs them. Speculative: AI as an autonomous discoverer of theories.
For a junior professional the lesson is twofold: data science applied to business and scientific AI share method (08-01) and tools (module 7); and techniques born in science (attention over structured data, simulation models) later reach industry: NovaMarket's demand forecasting (use case 2) will benefit from pretrained time-series models and cheaper simulations.
- The debate on AGI and AI safety
In 02-02 we distinguished narrow AI, general AI (AGI) and superintelligence, and we said that everything deployed today is narrow however broad it may look. The public debate about whether AGI is near, far or badly defined is speculative in the precise sense of section 1: there are serious experts in every camp. Without sensationalism, the positions can be summarised like this:
| Position | Central idea | What it proposes |
|---|---|---|
| Optimistic continuist | Scaling current models, with more data, compute and tools, will lead to general capabilities | Invest, deploy, adjust regulation along the way |
| Technical sceptic | Current models lack understanding, robust reasoning and a world model; new ideas will be needed | Research other avenues (neurosymbolic, learning from less data), do not extrapolate |
| Safety-concerned | Whenever it happens, very capable systems poorly aligned with what we want could cause serious harm that is hard to reverse | Alignment research, evaluations before deployment, international governance |
| Focused on present harms | The real risk is already here: bias, surveillance, disinformation, concentration of power, labour and environmental impact | Regulation and auditing of what exists today (02-04), before distant scenarios |
What a professional should retain: (1) the four positions are not mutually exclusive and many people hold several at once; (2) AI safety in the broad sense (systems doing what is intended, being robust against manipulation and not causing harm) is an established engineering discipline that starts with modest things like the ones we have done: adversarial tests on the assistant, limits on an agent's actions, human review, logging; (3) the AGI debate should not decide NovaMarket's budget for next year, and irreversible decisions ("lay off the customer-service team because the agent will do it all") are not taken on speculation.
- Impact on employment and skills of the junior professional
Established: generative AI changes tasks within jobs (drafting, programming, customer service, analysis) faster than it eliminates or creates whole jobs, and the net effect varies a lot by sector and by how each organisation manages it (02-04, labour impact). Emerging: which new profiles stabilise (data and ML engineering, AI evaluation and governance, agent design, "model operations"). Speculative: the aggregate long-term effect on employment.
What a junior profile who wants to work with AI should learn, in the light of the whole course:
| Skill | Why | Where it was covered |
|---|---|---|
| Solid programming (Python, SQL) and good practice (tests, Git, environments) | Everything else rests on this; copilots require being able to read and review code | Module 7 |
| ML fundamentals and evaluation with business criteria | Without a metric in euros and a baseline there is no project | Modules 4 and 8 |
| Data: quality, leakage, bias, governance | Most of the work and of the failures is here | 02-03, 04-03, 08-01 |
| Critical use of foundation models: prompting, RAG, evaluation, limits | The newest tool and the most misused | 05-05, 08-02 |
| Ethics, regulation and explainability as part of the design | Legal and business requirement | 02-04, 06-04, this lesson |
| Project method and communication with the business | Translating between Diego and the model | 08-01 |
| Continuous learning | Tools change; the method, much less | Module 10 |
The differentiating skill is not "knowing the latest library", but knowing how to define a problem, measure it, doubt the data and explain the result. It is what machines do worst and what this course has tried to teach.
- NovaMarket's one-to-three-year roadmap
Marta and Diego translate the trends into a roadmap without exact dates, by horizon:
| Horizon | Use case | Trend that affects it | Status | What to prepare |
|---|---|---|---|---|
| Short (≈ 1 year) | 3. Returns predictor | XAI, governance | Established | reason column in the "review" queue (section 5), model card reviewed every quarter, monthly parity between zones |
| Short | 7. Assistant | Foundation models + RAG, regulation (transparency) | Established | "You are talking to an assistant" notice, weekly sampling of conversations, external-data policy |
| Short | 4. Reviews | Generative AI in the enterprise | Established | Review summaries per product for the team, with review |
| Medium (1-2 years) | 7 + 8 + 9. Assistant-agent | Agents with tools, neurosymbolic, multimodal | Emerging | Bounded tools (look up order, classify photo, apply rules, prepare return), permissions and logging, evaluation by complete tasks |
| Medium | 9. Incident diagnosis | AI at the edge, multimodal | Emerging | Quantised CNN on the delivery driver's handheld; validation at Getafe; measure decisions that change |
| Medium | 2. Demand forecasting | Pretrained time-series models, AI and science | Emerging | Compare against the current baseline with MAE in units and euros; do not switch without a clear win |
| Medium | 1. Recommender | Foundation models (product embeddings), regulation (profiling) | Established/emerging | Collaborative baseline (08-02), A/B on revenue, information to the customer and option to object |
| Long (2-3 years) | 5 and 6. Routes and assignment | Optimisation + learned models, reinforcement in simulation | Emerging/speculative | Simulator of the warehouse and the routes before any learned policy; never learn on real customers |
| Cross-cutting | All | AI Act and audits, sustainability, skills | Established | Inventory of systems by risk, impact assessment of those affecting people, team training, "small model first" criterion |
- Summary table: trend → status → practical implication
| Trend | Status | Practical implication |
|---|---|---|
| Foundation models | Established | Start from a pretrained model; the value is in your own data, integration and evaluation; watch vendor dependency |
| Multimodality | Emerging | Design flows where text and image are handled together; do not redo everything yet |
| Agents with tools | Established (bounded) / emerging (open-ended) / speculative (broad autonomy) | PEAS, permissions, limits, logging; evaluate complete tasks; human supervision |
| Generative AI in the enterprise | Established | Copilots and low-risk automation with review; data policy; training |
| Explainable AI | Established (tabular) / emerging (deep, LLM) | Global and local explanation as a deliverable; SHAP/LIME when the model is opaque |
| Regulation and governance | Established (that it will come) / emerging (how) | Inventory, model cards, impact assessment, transparency, watermarks |
| Edge and small models | Established (techniques) / emerging (small LLMs) | "Small model first"; quantise and measure; privacy and energy |
| Neurosymbolic and reasoning | Emerging / speculative | The model calls the exact tool; rule-based validation |
| AI and science | Established / emerging | Methods that will reach industry; data stored properly today |
| AGI and safety | Speculative (AGI) / established (practical safety) | Do not decide on speculation; tests, limits and review today |
| Employment and skills | Established (change of tasks) / speculative (aggregate effect) | Continuous training; method, data, evaluation and communication as differentiating skills |
Common Mistakes and Tips
- Confusing emerging with established. A pilot that works in a demo is not a basis for reorganising a department. Label each trend before deciding.
- Chasing novelty instead of the problem. The roadmap starts from the nine use cases and asks which trend affects them, not the other way round.
- Taking for granted that the large model is better. Try the small or local one first, quantise and measure how many decisions change, as in section 7.
- Treating explainability as decoration. It is a legal requirement for anything that affects people and a debugging tool: permutation importance uncovers leakage and useless columns.
- Giving an agent tools without limits. Every tool is an actuator; permissions, quotas and logging from day one.
- Deciding on the AGI debate. Neither panic nor faith justifies irreversible decisions; practical safety (tests, review, limits) is for today.
- Tip: set aside a fixed time (for example, one hour a week) to read primary sources (papers, official documentation, legal texts) rather than headlines; module 10 will tell you where.
Exercises
Exercise 1: explaining the review queue
Extend score_batch from 08-01 (without changing the model) so that the output includes a reason column with the two features that push each order's probability up the most, following the local explanation of section 5. State what text the reviewer would see for order 2314 and what limitation this explanation has if in the future the model were a forest.
Exercise 2: classifying proposals
Diego receives four proposals: (a) an agent that answers and executes refunds automatically; (b) review summaries generated by an LLM for the product team; (c) replacing the current demand forecasting with a time-series foundation model; (d) facial recognition in the physical shop to "recognise regular customers". Classify each by status (established/emerging/speculative), by risk (02-04) and by decision (do now, pilot, wait, do not do), with a one-sentence justification.
Exercise 3: quantise and measure
Repeat the quantisation of section 7 with 4 bits (integers from −7 to 7) instead of 8 and note the maximum probability difference and how many orders change queue. Above what number of changes would Diego say it is not acceptable, and with what criterion would you decide it yourself?
Solutions
Solution 1. In score_batch, after computing prob, get the transformed matrix Xt = model.named_steps["prep"].transform(orders[columns]) (converted to dense if sparse), multiply each row by model.named_steps["model"].coef_[0] and take, per row, the two column names (get_feature_names_out()) with the largest positive contribution; strip the prefixes (num__, nom__) and join them with " + " in the reason column. For order 2314 the reviewer would see something like amount (+1.9) + delivery_days (+0.7), that is, "high amount and slow delivery". Limitation: the contribution x · coefficient only makes sense in a linear model; with a forest it would have to be replaced by SHAP (or LIME) keeping the same output format, something worth anticipating in the design now (an explain(model, X) function with the same signature for both cases).
Solution 2. (a) Agent that executes refunds: emerging as an agent, medium-high risk because of the economic and customer impact; decision: pilot only the version that prepares and does not execute (human-in-the-loop) with permissions and logging; executing automatically, not for now. (b) Review summaries: established, minimal risk (internal use, no decisions about people); do now with light review and no personal data in the external service. (c) Time-series foundation model: emerging, low risk; pilot in shadow against the current baseline with MAE in units and in euros, and only replace if it wins clearly (08-01). (d) Facial recognition of customers: technically established, but high risk (biometrics, severe restrictions under the AI Act and GDPR, 02-04 and 08-02); decision: do not do; the answer starts with legal and the impact assessment, and almost certainly ends in a voluntary loyalty programme.
Solution 3. With 4 bits the scale is abs(w).max() / 7 and w_int4 = round(w / scale) in the range −7..7 (it can be stored as int8 even though only 4 bits are used). The loss is much greater: in the course environment the maximum probability difference rises from 0.008 to 0.155 and 43 orders out of 750 change queue (against 3 with 8 bits): with only fifteen levels, the small weights are rounded to zero or to a value very different from the real one. The criterion is not a magic number but cost: each order that changes queue has an expected cost (a "flag" that becomes "review" costs a €3 review; a "review" that becomes "approve" risks a €30 return with the order's probability). Diego would accept the quantisation if the saving (here nil; in a large model, servers and energy) exceeds that expected cost at the daily volume, and you would decide it by measuring the business cost on the test set with the quantised model (04-05) and comparing it with the original, exactly as two models are compared.
Conclusion
We have looked ahead with the three labels of section 1 in hand. Established: foundation models as the starting point, generative AI as copilot and low-risk automation, explainability for tabular models (the permutation importance and the local explanation we ran on the predictor: amount and new customer rule, and order 2314 is in the band because of a high amount and slow delivery), regulation that will have to be complied with, efficiency techniques such as quantisation (eight times less memory and 3 orders out of 750 that change queue), AI as a scientific instrument and the change of tasks within jobs. Emerging: multimodality, agents that plan and use tools (the agent of 02-01 at the centre once again), formalised neurosymbolic AI, small language models, the concrete shape of audits. Speculative: AGI, the broad autonomy of agents and the aggregate effect on employment, with serious positions in every direction and one rule: do not take irreversible decisions on speculation. For NovaMarket, a roadmap that starts with what is established in its most mature use cases and reserves what is emerging for bounded pilots; for the junior professional, a map of skills in which method, data, evaluation and communication weigh more than the latest library.
With this we close module 8: a method for taking projects from idea to production (08-01), the experience of those who did it well and badly (08-02) and a compass for what is coming (08-03). Modules 3 to 8 have given the theory, the code and the judgement; what remains is to consolidate it hands-on, solving problems from start to finish without the lesson holding your hand. That is module 9, Exercises and Practice: search and optimisation algorithms in 09-01, machine learning practice in 09-02, neural network projects in 09-03 and, in 09-04, the capstone project in which you will apply the method of 08-01 to a case of your own, from idea to prototype.
Fundamentals of Artificial Intelligence (AI)
Module 1: Introduction to Artificial Intelligence
Module 2: Basic Principles of AI
- Fundamental Concepts: Agents, Environments and Rationality
- Types of Artificial Intelligence
- Data as the Raw Material of AI
- Ethics and Considerations in AI
Module 3: Algorithms in AI
- Introduction to Algorithms
- Search Algorithms
- Adversarial Search: Games and Minimax
- Optimization Algorithms
Module 4: Machine Learning
- Basic Concepts of Machine Learning
- Types of Machine Learning
- Data Preparation and Feature Engineering
- Machine Learning Algorithms
- Model Evaluation and Validation
- Overfitting, Regularization and Hyperparameter Tuning
Module 5: Neural Networks and Deep Learning
- Introduction to Neural Networks
- Neural Network Architecture
- How a Network Learns: Gradient Descent and Backpropagation
- Deep Learning and Its Applications
- Transformers, Large Language Models and Generative AI
Module 6: Logic and Expert Systems
- Logic in AI
- Expert Systems
- Reasoning under Uncertainty: Probability and Bayesian Networks
- Applications of Expert Systems
Module 7: Tools and Programming Languages in AI
- Programming Languages for AI
- Scientific Python: NumPy, pandas and Matplotlib
- Popular Tools and Libraries
- Development Environments
Module 8: Projects and Case Studies
Module 9: Exercises and Practice
- Algorithm Exercises
- Machine Learning Practice
- Neural Network Projects
- Capstone Project: from Idea to Prototype