The whole training run, in order

A vision scoring model is trained by repeating one loop millions of times: show it labelled photos, let it guess a score, measure how wrong the guess was, and nudge its internal numbers to be slightly less wrong. When the errors stop shrinking, the numbers are frozen, and that frozen set is the model.

Nothing in the process teaches the model what a score means. It teaches the model to reproduce a pattern in the labels, and everything else follows from that.

The dataset comes first

Training starts with a pile of images, each paired with a target: the score a person, or a panel of people, gave it. The pile is usually split in three before anything else happens. The biggest part, the training set, is what the model learns from. A smaller validation set is held back and used during training to check progress on photos the model has not been adjusted against. A third test set is kept untouched until the very end, so the final report is not contaminated by decisions made along the way.

The split matters because a model can look excellent on photos it has seen and be useless on new ones. Keeping some photos out of the learning is the only way to find out which has happened.

Where the targets came from, who produced them and how they were instructed, sets a ceiling on everything below. That is its own subject, covered in where the scoring labels come from, and this piece takes the labels as given. What matters here is that the dataset is the only source of information the model will ever have about the task. If a kind of photo is missing from it, the model has no way to know the kind exists.

Starting from noise, or from a head start

Before the first step, the model's weights have to hold something. Each weight is a single number, and what a weight actually is is less mysterious than the billions-of-parameters headlines suggest. If the model is built from scratch, the weights start as small random values, so the first guesses are meaningless. In practice most scorers do not start there. They begin from a backbone already trained on a large unrelated collection of images, which is the reason scorers borrow a pretrained backbone rather than learning to see from nothing. The loop below is identical either way. Only the starting point differs, and with it how long the loop needs to run.

The forward pass

Each step of training begins with a forward pass. A group of photos, called a batch, is resized and normalised, then fed through the network layer by layer. Each layer multiplies its inputs by its weights, adds them up and passes the result on. At the end comes a single number per photo: the model's current guess at the score.

Early in training these guesses are poor. That is expected and necessary, because the poor guesses are what the next stages learn from. Why the model works on a handful of photos at a time rather than one, and why that steadies things, is covered in how epochs and batches work.

The loss turns "wrong" into a number

The model's guess is compared with the label, and the gap is turned into a single number called the loss. Large gap, large loss; perfect guess, zero. Averaged over the batch, this one number is the only feedback the model receives about how it is doing.

The choice of formula for the loss is a design decision with visible consequences. A loss that punishes big misses heavily makes the model cautious and pulls its guesses toward the middle. A loss that treats all misses alike behaves differently at the edges. This is worked through in how the loss function decides what wrong costs, and it is one reason scores from different tools can behave so differently on the same photo.

The backward pass assigns blame

Knowing the loss is not enough. The model has millions or billions of weights, and it needs to know, for each one, whether turning it up or down would have reduced the loss. The backward pass computes exactly that. Working from the output back toward the input, it applies the chain rule from calculus to produce a gradient for every weight: a number saying which direction improves things and how steeply.

This is bookkeeping rather than intelligence. No weight understands anything; each just receives a small signed number telling it which way to move. The idea is explained with a hill analogy in gradient descent in plain terms.

The weight update

With a gradient for every weight, the update itself is simple. Each weight is moved a small step in the direction that reduces the loss. The size of that step is set by the learning rate, a number chosen by the designers rather than learned. Too large and the model overshoots and the loss bounces around or climbs. Too small and training crawls, or settles somewhere mediocre.

Most real training does not use the plain version of this rule. Optimisers such as Adam, described by Kingma and Ba (2014), keep running averages of past gradients so that each weight gets a step size adapted to its own history. The principle is unchanged: look at the slope, take a small step downhill.

Then the loop repeats with the next batch. One pass through every training photo is an epoch, and a run typically lasts many of them. Each individual step changes the model very little. The result comes from the accumulation of an enormous number of tiny corrections.

Validation keeps the process honest

After each epoch, or every so often, training pauses and the model is run over the validation set with its weights held still. No learning happens here. The point is to measure the loss on photos the model has not been adjusted to fit.

Two curves are watched side by side. The training loss almost always falls, because the model is being fitted to those photos directly. The validation loss falls too, for a while, then flattens, and in a model that trains too long it starts to rise. The gap between the two is the signature of overfitting, where the model has begun to memorise its examples rather than learn the pattern behind them. The validation curve is the early warning for that, and the reason the split in the first section exists.

Validation is also where the designers make choices: learning rate, how many layers to unfreeze, which augmentations to apply. Each choice is tried, compared on the validation set and kept or dropped. That is useful, and it has a subtle cost. The more choices are tuned against the validation set, the less independent it becomes. This is why the test set is held back until the end, and why a reported accuracy figure only means something when the set behind it is described, a point taken up in what a claimed accuracy would even mean.

Knowing when to stop

Training does not end because the model is finished. It ends because a rule says so. The common rules are a fixed number of epochs, a loss that has stopped improving for several checks in a row, or a budget of time and money running out.

A frequent version is early stopping: keep a copy of the weights from the epoch with the best validation loss, and when the loss stops improving for a set number of checks, return to that copy. The model handed to users is therefore often not the last one trained but the best one seen.

There is no moment where the model is declared correct. Correct is not available, because for a subjective rating there is no true score to be accurate against. There is only a point where more training stops helping on the photos set aside to check.

What comes out

At the end the weights are frozen and saved to a file. That file is the whole product of the run. It contains no photos, no labels and no record of the loop that produced it. It holds the numbers, plus a description of how to arrange them into layers.

Using the model afterwards, called inference, is just the forward pass from above, run once on your photo with no loss, no backward pass and no updates. A photo goes in, passes through the frozen layers and comes out as a number. The model does not learn from your upload while doing this. Whether a service separately saves uploads to train a later version is a different question, and a matter of that service's practice rather than of how models work.

Several consequences follow from the shape of the loop. The model can only reflect what was in its dataset, so unusual photos get scored from thin evidence. It optimises for the loss it was given, so what the loss rewards is what the scores track. And it was stopped by a rule, so the score you see is a snapshot of a particular stopping point rather than a convergence on a truth. None of this is a flaw particular to one tool. It is what training produces, and it is why a score is better read as an inference than as a measurement.

Why this matters when you read a score

Knowing the loop makes several common surprises less strange. A tool that returns the same score for the same file is not being precise in the way a ruler is; it is running a frozen function. A tool whose scores shift after an update has been retrained, so its weights changed, and the old and new numbers are not on one scale. A tool that handles an unusual photo badly is not being capricious; the training set may simply not have contained anything like it.

The same loop, with different data, labels and loss, underlies image classifiers, detectors and the vision encoders inside larger models. What changes between them is the target, not the mechanism. That is why cockrate.com is a better place to start if you want to know how to approach a rating tool as a user, rather than how the model behind one was built. If you want to know how a score compares with something actually measured, measuremycock.com owns that question, and the difference traces straight back to the training loop above: a measurement has a physical reference, and a trained score has only its labels. For reading a result once you have one, penisrater.com covers what a total can and cannot support.

A concrete product is one place to see the loop's outputs. Rate Cock returns scores from a model of this kind, and the pipeline from upload to number is documented in how the scan works, which this site deliberately does not repeat.

Pair this piece with what happens inside the model on a single photo and the picture is complete: training sets the numbers once, and inference uses them every time after. The part worth remembering is that the weights hold a compressed record of the labels, and so a score is only ever as good as the people and photos that went into the loop.