qwenlm.github.io

Machine learning is a way of building software that learns patterns from data instead of following rules a person wrote by hand. You use it when the relationship between input and output is too complex or too variable to specify directly — recognizing objects in photos, ranking search results, or predicting whether a transaction is fraudulent. The core idea: show the system many examples, let it adjust internal parameters to reduce its errors, then check whether it works on examples it has never seen.

Learning from data vs. hand-coded rules

In traditional programming, a developer writes explicit logic: if the email contains these words, mark it spam. In machine learning, you supply labeled examples and the model derives its own decision boundary. The trade-off is that the model's behavior depends on the data it saw — change the data, and the behavior changes.

The three main learning paradigms

Supervised learning covers most everyday applications. Unsupervised learning is used for clustering, compression, and anomaly detection. Reinforcement learning is harder to stabilize but is the approach behind recent work on scaling language-model reasoning — for instance, Qwen's GSPO research explicitly targets "stable and robust training dynamics" for RL at scale, noting that existing algorithms such as GRPO "exhibit severe instability issues during" training.

The core training loop

Every supervised model follows roughly the same cycle:

1. Collect and split data. Divide examples into a training set and a held-out test set.
2. Define a model. Choose an architecture with adjustable parameters (weights).
3. Measure error with a loss function. The loss quantifies how far predictions are from the correct answers.
4. Adjust parameters. An optimization algorithm nudges the weights to reduce the loss.
5. Repeat. Iterate over the data many times until the loss stops improving.
6. Evaluate on unseen data. Measure performance on the test set, not the training set.

The input is the data and the model definition; the action is repeated parameter updates; the expected result is a model whose error on new data is acceptably low.

Overfitting, underfitting, and why splits matter

• Underfitting: the model is too simple to capture the pattern — it performs poorly on both training and test data.
• Overfitting: the model memorizes the training examples, including their noise — it performs well on training data but poorly on test data.

This is why you never judge a model by its training accuracy. A held-out test set (or cross-validation) simulates the real world: data the model has not seen. If training error keeps falling while test error rises, you are overfitting.

Where deep learning and large language models fit

Deep learning is machine learning using neural networks with many layers. It is not a separate field — it is a subcategory that excels when data is abundant and patterns are hierarchical (images, audio, text).

Large language models are deep learning models trained on massive text corpora, usually with a self-supervised objective: predict the next token. That objective needs no human labels, which is why it scales. The Qwen family illustrates the breadth of the umbrella — its releases include a 20B image foundation model (Qwen-Image) for text rendering and editing, a safety classifier (Qwen3Guard) fine-tuned for prompt and response moderation, and RL research (GSPO) for training dynamics. All of these are machine learning systems; they differ in data, objective, and architecture, not in kind.

How to tell the paradigms apart in practice

Ask two questions:

1. Does the training data include the correct answer? If yes, it is supervised (or self-supervised, where the answer is derived from the data itself).
2. Does the model learn by taking actions and receiving feedback? If yes, it is reinforcement learning.

If neither applies and you are only looking for structure, it is unsupervised. Most real systems combine these — a language model may be pretrained with self-supervision, fine-tuned with supervised examples, and refined with reinforcement learning.

A blog is a website whose primary content is a stream of dated entries ("posts") shown newest-first, usually with an author byline and a way to browse older material by category, tag, or archive. It differs from a static site mainly in how content is organized and updated: a static site presents fixed pages you edit in place, while a blog is built around an accumulating timeline of posts. You'd choose a blog when you expect to publish repeatedly over time; you'd choose static pages when the content changes rarely and each page stands alone.

Blog vs. static site vs. wiki

The lines blur in practice. A project site can host a blog as one section, and a blog can contain static pages (About, Contact) alongside the post stream. The distinguishing feature is the post timeline, not the software.

The typical structure of a blog

• Posts — the individual dated entries. Each usually has its own URL, title, date, author, and body.
• Reverse-chronological index — the home page or a "blog" page listing posts newest-first.
• Categories — broad, usually pre-defined groupings (e.g., "Releases," "Tutorials").
• Tags — finer, often free-form labels that can cut across categories.
• Archives — views by month, year, or author for reaching older posts.
• Feeds — an RSS or Atom file that lets readers and other tools subscribe to new posts.
• Comments — optional; some blogs enable them, many disable them to avoid spam and moderation work.

Categories and tags both help readers and search engines, but they only work if you apply them consistently. A common failure is creating a new tag for every post, which produces dozens of one-item tag pages that help no one.

Hosted or self-hosted?

The main decision is who runs the software and the server.

• Hosted platforms (e.g., WordPress.com, Blogger, Medium-style services) handle hosting, updates, and often the domain for you. You trade control and sometimes portability for less maintenance.
• Self-hosted means you install and run the software yourself on a server or static host. You get full control over themes, plugins, and data, but you own backups, updates, and security.

A middle path is a static site generator such as Jekyll, which builds plain HTML files from templates and Markdown posts. These are fast and cheap to host, but they have no built-in comment system or admin interface, so publishing means running a build step. The OpenBVE project homepage, for example, is a project site that publishes dated release notes in a blog-like stream — the August 10, 2026 entry lists OpenBVE v1.14.0.3 changes such as a fix for builds failing to launch on non-Windows platforms and new quality options for viewers. That is the blog pattern applied to software releases: dated, newest-first, each entry a discrete update.

Basic steps to start a blog

1. Decide hosted vs. self-hosted based on how much control and maintenance you want.
2. Choose a platform that matches that choice — a hosted service, a self-hosted CMS, or a static generator.
3. Pick a domain — either a subdomain on the platform or your own registered name. Your own domain makes it easier to move later.
4. Select a theme that is responsive, so it works on phones as well as desktops.
5. Configure the basics — site title, author, time zone, and permalink structure.
6. Write and publish your first post, then verify it appears on the index and at its own URL.
7. Set up a feed so readers can subscribe, and check that it validates.

Ongoing tasks

Publishing is the visible part; the rest is upkeep.

• Comments — if enabled, expect spam. Most platforms offer moderation queues and spam filters; many bloggers simply turn comments off.
• Feeds — keep the feed working and decide whether to publish full text or excerpts.
• SEO basics — descriptive titles, clean URLs, sensible headings, and internal links between related posts. Avoid duplicating the same content across multiple URLs.
• Backups — especially self-hosted. A blog is a database plus files; back up both.
• Updates — self-hosted software needs security patches. Skipping them is the most common way small blogs get compromised.

How to tell it's working

After the first few posts, check that: the index lists posts newest-first, each post has a stable URL, categories and tags resolve to real pages, the feed validates, and the layout holds up on a narrow screen. If any of those fail, fix them before publishing more — structural problems get harder to correct as the archive grows.

Multi-modal AI refers to models that take in and connect more than one type of data — most commonly text plus images, and sometimes audio or video — rather than handling a single input format. You use it when a task needs two kinds of information at once, such as editing a picture by describing the change in words, or asking a question about an image. A single-modality model (text-only or image-only) can't do this because it never learns how the two formats relate.

What "multi-modal" actually means

A modality is a data type: text, image, audio, video. A multi-modal model processes at least two of them and, crucially, links them so that meaning carries across.

• Single-modality: a text model reads prompts and writes text; an image classifier reads pixels and outputs a label. Each stays in its lane.
• Multi-modal: the model accepts, say, an image and a text instruction, and produces an output that depends on both.

The key word is connect. Simply running two separate models side by side isn't multi-modal — the value comes from the model reasoning across the formats together.

How the pieces fit together

The general mechanism follows a consistent pattern:

1. Encode each modality. Text goes through a language encoder; images go through a vision encoder (often a VAE or a vision-language model). Each turns raw input into a numeric representation.
2. Align into a shared space. The representations are projected so that, for example, the vector for "a red circle" sits near the vector for an actual red circle image. This alignment is what lets the model relate a word to a visual feature.
3. Fuse and generate. The model combines the aligned signals and produces output — new text, a modified image, or a decision.

Qwen's image work shows this concretely. Qwen-Image-Edit feeds an input image into two paths at once: Qwen2.5-VL for "visual semantic control" and a VAE Encoder for "visual appearance control." One path handles what the image means, the other handles how it looks — and the model edits on both dimensions. That split is a clean illustration of why multi-modal systems encode the same input more than once.

Concrete examples

• Text-guided image editing. You give an image plus an instruction like "change the sign text." Qwen-Image-Edit extends text-rendering ability into editing, so it can precisely edit text inside an image — a task that requires reading the text (language) and repainting the pixels (vision) together.
• Visual question answering. You upload a chart and ask "what's the trend?" The model reads the visual and answers in language.
• Text rendering in generation. Qwen-Image is a 20B MMDiT image model built for complex text rendering — multi-line layouts, paragraph-level semantics, fine-grained detail — across alphabetic languages. Generating legible text inside an image is a multi-modal problem because the model must control both visual composition and linguistic content.

When to reach for multi-modal vs. single-modality

If your input is one format and your output is the same format, a single-modality model is usually simpler and cheaper. Add a second modality only when the task genuinely needs both.

Common limitations

• Cross-modal alignment errors. The model may bind the wrong word to the wrong region — editing the wrong object, or misreading which part of an image a prompt refers to.
• Data requirements. Learning the text–image relationship needs large paired datasets, which is why capable multi-modal models tend to be large (Qwen-Image is 20B parameters).
• Precision on fine detail. Small text, dense layouts, and subtle visual edits are where alignment tends to break down first.
• Task scope. A model tuned for image editing won't necessarily handle audio, even though both are "multi-modal" in the broad sense.

Practical takeaway

Treat "multi-modal" as a capability claim, not a guarantee. Before adopting one, check which modalities it actually connects, whether it handles your specific pairing (e.g., text-in-image editing vs. general captioning), and how it performs on the fine details your task depends on. For text-plus-image work, the Qwen-Image and Qwen-Image-Edit releases are concrete reference points for what current multi-modal editing can and can't do.