presentsUNAIVERSE
The UN AI timeline

    Learn AI /Large Language Models /Model weights (as a released artefact)

    Model weights (as a released artefact)

    Also called: weights file, checkpoint file.

    Detail

    In five seconds

    What it is

    A released file of learned numerical settings that lets compatible software run a trained model without repeating the original training process.

    In plain words

    Think of it as the trained model packed into files full of numbers. Those files let compatible software reproduce the model’s learned behaviour without training from the beginning.

    An everyday example

    A musician spends hours adjusting the controls on a synthesiser, then saves those settings to a file. Someone with a compatible synthesiser can load the file and obtain the tuned sound without repeating all the adjustments. The file is not the instrument: without the matching controls, sound engine and software, it is only a set of values. A model-weights release works similarly, although it stores many more learned values and compatible software uses them to calculate outputs.

    Where the story stops working

    A spreadsheet scoring sheet is much simpler and easier to inspect than real model weights. Real weights are usually enormous collections of numbers spread across many layers, and their effect comes from complex interactions rather than a few clear scoring rules. Also, a library ranking sheet usually sorts known documents, while a language model uses weights to generate new token sequences one step at a time.

    Remember thisWeights are serialised trained parameter values, not a complete application. A compatible architecture, runtime, configuration and tokeniser are still needed.

    Understand it

    Understand it

    Why it matters

    This term matters because discussions about access, cost, transparency, security, and deployment often turn on what exactly has been released. If a vendor or developer says a model is available, a non-specialist should ask whether that means API access, an application, source code, or the weights artefact. Released weights can make local deployment, auditing, fine-tuning, conversion, or offline use more feasible, but they also raise governance questions about licensing, safety controls, infrastructure needs, and misuse. In procurement and policy conversations, confusing weights with the whole system can lead to wrong assumptions about reproducibility, openness, portability, or risk.

    From training run to released weights to usable model

    Show that released weights are a saved snapshot of learned numbers, and that they need matching software and configuration to produce outputs.

    1. 01

      Training updates numbers

      A model is trained on large text collections. During training, many numerical values are adjusted to reduce prediction error.

      Draw a box labelled 'Training run' with small token icons entering and many tiny number cells changing colour inside the box.

    2. 02

      Checkpoint is saved

      At intervals or at the end, the learned values are written to disk as one or more checkpoint or weights files.

      Draw an arrow to a file icon labelled 'Released weights / checkpoint'. Add a small note: 'saved snapshot of learned values'.

    3. 03

      Compatible software loads it

      To use the checkpoint, software must load it into the right architecture with the expected configuration, vocabulary and tokenisation.

      Draw arrows from the checkpoint file, a box labelled 'architecture', and smaller boxes labelled 'config', 'vocabulary', and 'tokenisation' into a box labelled 'runtime'.

    4. 04

      Model can generate output

      Once loaded, the runtime can process a prompt and produce a completion token by token.

      Draw a prompt entering the runtime box and an output text bubble leaving it. Keep colours distinct so the file is not mistaken for the whole system.

    A left-to-right flow with four boxes. Read from training on the left, to saved checkpoint in the middle, to loading with compatible components, to generated output on the right. The diagram separates the saved artefact from the full runnable system so readers can see why weights are necessary but not sufficient.

    Hover or tap each box to highlight what is stored there versus what is required from elsewhere.

    Describe this without the diagram

    The diagram is a four-step flow. First, a training run adjusts many numbers while processing text. Second, those learned numbers are saved as a checkpoint or weights file. Third, that file is loaded by compatible runtime software together with the model architecture, configuration, vocabulary and tokenisation rules. Fourth, the loaded system accepts a prompt and generates output text. The key point is that the released weights are a saved snapshot of learned values, not the entire runnable system by themselves.

    With reduced motion: A static four-box left-to-right flow replaces animation. Arrows connect Training run, Released weights/checkpoint, Compatible runtime with architecture and configuration, and Output from prompt.

    When people say they are downloading a model, they often mean they are downloading its weights files. This is a saved artefact: a file, or set of files, full of numbers learned during training. Some releases use files taken from a training checkpoint, but a full checkpoint can also contain optimiser state and other training information. The learned numbers shape how the model transforms input text into likely next tokens, where a token is a small unit such as part of a word.

    What goes in? During training, the model sees very large amounts of text and repeatedly adjusts many numerical values. What happens? The training process changes them so the model becomes better at predicting the next token. What comes out is a saved snapshot of those learned values.

    When someone releases model weights, other people can load the files into software that implements the matching architecture, meaning the design of the network that uses the numbers. The software combines the architecture, the weights, a vocabulary, and tokenisation rules to generate outputs from prompts. The weights alone are powerful, but they are not the whole system.

    This term is often confused with a single weight or with a parameter. A single weight is one learned number that scales a signal. A parameter is any learned numerical setting, which can include weights and other values. Model weights as a released artefact means the packaged collection of learned parameter values saved to disk and shared so others can run, fine-tune, inspect, or convert the model.

    How “A saved sound preset” maps onto the real thing

    In the storyIn the AI system
    The spreadsheet of tuned numbers sent to branchesThe released weights or checkpoint file
    The ranking software that applies the spreadsheetThe model architecture and inference software
    Past document requests used to improve the scoring sheetTraining data and training process
    The category list and columns expected by the softwareVocabulary, tokenisation rules, and model configuration

    A worked example

    An information management officer in a regional hub prepares a local summarisation test for a technology governance board review. The test uses a paragraph from a public progress report and must be ready by close of business.

    Starting from: The release package contains serialised weight tensors, an architecture configuration and tokeniser files. It does not contain the original training environment or optimiser state.

    1. The officer confirms that the approved inference runtime supports the stated architecture and weights format.
    2. The runtime constructs the matching model architecture from the configuration and loads the tensor values as its parameters.
    3. The tokeniser converts the progress-report paragraph into model tokens. The loaded network then calculates successive output-token probabilities.
    4. The runtime generates a summary using the trained parameter values, without repeating the original training process.

    Result: The release supports local inference because the weights are combined with the matching architecture, configuration, tokeniser and runtime. It is not a complete training checkpoint and cannot by itself restore the original training state.

    In a United Nations workplace

    An internal auditor is finalising the terms of reference for a review of a locally hosted language model in a library and records service. Before the file goes to the chief of section for Friday clearance, the draft must distinguish a release of model weights from a complete, deployable system.

    The distinction determines what the review must test. Serialised tensors may provide the trained parameter values, while the service still needs the matching architecture definition, configuration, tokeniser and runtime. A full training checkpoint may also contain optimiser state; a weights release need not.

    Before you try thisDo not treat local possession of the weights as security or data-protection approval. The auditor should require provenance and integrity checks, licence review, access controls and testing in an approved environment. Restricted records, personal data and confidential documents must not be loaded until that environment is authorised for them, because the runtime, logs and surrounding tools can expose or retain inputs.

    Where you may hear it

    • A technology governance board reviewing whether a model can run on approved infrastructure
    • A procurement meeting clarifying what a supplier means by “model package”
    • A technical handover before a locally hosted model is accepted
    • An internal audit opening meeting on controls around released AI models

    Avoid confusion

    Avoid confusion

    Often confused with

    Common misconceptions

    • If the weights are available, the whole model is fully open and easy to use.

      Released weights may still depend on separate code, configuration, tokenisers, licences, and hardware. Some releases allow use but not redistribution or training-data inspection. So access to weights does not automatically mean the whole system is open in every practical or legal sense.

    • A weights file contains the training data in readable form.

      The file mainly stores learned numerical values, not a clean database of source documents. Models can sometimes reproduce memorised fragments, so privacy and copyright concerns still matter, but the artefact is not simply a text archive of the training set.

    • Weights and parameters mean exactly the same thing in every conversation.

      People often use the words loosely, but they point to different levels. A parameter is an adjustable value in the model. Released model weights usually means the saved collection of many learned parameter values packaged as files for loading and use.

    • If you have the weights, you can run the model on any computer.

      The artefact may require a specific architecture, software stack, memory size, accelerator support, and sometimes conversion or quantisation. A checkpoint that works on a large server may not run acceptably on a laptop or phone.

    Quick check

    What best describes released model weights?

    Go deeper

    Go deeper

    The simple version

    Think of it as the trained model packed into files full of numbers. Those files let compatible software reproduce the model’s learned behaviour without training from the beginning.

    The technical version

    A released weights artefact contains serialised tensors holding the learned numerical values of a trained model. It is usually saved after training or fine-tuning, or extracted from an intermediate checkpoint. A full training checkpoint may also contain optimiser state and other information used to resume training. The tensors correspond to parameter values used by the model architecture during inference. On their own, weights files are not enough: a runtime must know the architecture definition, tensor shapes, layer arrangement, configuration settings, vocabulary, and tokenisation scheme expected by the files. Once loaded, the runtime applies the weights during forward passes to transform token representations and produce next-token probability distributions. Different formats may store the same learned values in different ways. Some releases provide quantised versions, which lower numerical precision and memory use and may improve speed on compatible systems. In practice, people often say “the model” when they mean the weights, but the full runnable system also includes code, configuration, and supporting assets.

    Reviewed external resources

    Where this came from

    Drafted with a language model through an offline pipeline, checked against this site's schema, and every external link above fetched to see whether it answers. Treat it as a starting point and check anything that matters against the primary sources. How this site is built and what that means.

    The one thing to remember

    Weights are serialised trained parameter values, not a complete application. A compatible architecture, runtime, configuration and tokeniser are still needed.