Proto-VFL Under Class Imbalance and Cross-View Training

13.1 Class Imbalance in Vertical Federated Learning

13.1.1 Aligned Samples and Unaligned Samples

A party is one client that holds one vertical slice of the data, meaning one fixed set of features for whatever rows it owns. A class is one category label such as cat, dog, bird, elephant or parrot. An aligned sample is one record whose ID appears in more than one party, so the same real-world entity is seen from two or more feature views. An unaligned sample is one record that lives in only one party and has no matching ID elsewhere.

Only aligned samples carry labels at the central side. Unaligned samples have no label at the central side. That split shapes the whole design. Local clients see both aligned and unaligned rows during local training. The active party later receives representations only for aligned rows, because only those rows let it compute a supervised loss.

A private set intersection step finds the aligned IDs without revealing the unaligned ones, so each party learns which rows overlap while keeping the rest of its customer list secret. The aligned slice is usually small: a bank and a shop may share a few hundred common customers yet each serve tens of thousands the other never sees. That size gap is exactly why the method must squeeze learning signal out of unaligned rows locally instead of ignoring them.

Vertical splits of this kind appear when one organization holds image pixels and another holds text tags for the same users, or when a bank and a shop share a few common customers but each also serves many customers the other never sees. Fraud detection across banks, joint medical scoring across hospitals that hold lab results versus imaging for overlapping patients, and retail credit scoring that fuses purchase history with repayment history all run on this aligned-plus-unaligned pattern.

13.1.2 Intra-Party Imbalance and Combined Imbalance

When aligned and unaligned rows are pooled, the totals can look like 360 rows of one class, 175 rows of a second class and 0 rows of a third class. The board walk-through paired smaller counts side by side, such as 4 against 51, 2.65 against 1.75, 10 against 14, and a running sum of 2.10 plus 1.63 giving 3.73, to show how one or two dominant classes tower over the rest. Those small pairs were quick chalkboard illustrations of lopsided ratios rather than the canonical dataset totals; the numbers to carry forward are the pooled totals of 360, 175 and 0. The point stays the same across every pair. A model trained on such counts sees the big classes again and again and meets the small classes rarely or never.

A majority class is a class with many rows. A minority class is a class with few rows. An unseen class is a class with zero rows in a given party or slice, such as the parrot class with 0 rows above. Training must still return the right label when a minority or unseen case arrives at test time. That is the demand. Big classes must not swallow small ones.

Picture a bar chart with one bar per class and row counts on the vertical axis. The cat bar towers at 360, the dog bar reaches about half that height at 175, and the parrot slot is flat on the axis at 0. The landmark is the missing bar: a class the model must predict at test time without ever meeting it in this party. The takeaway is that the chart alone tells you where learning will fail unless the method borrows strength from elsewhere.

Several students stumbled on the small board pairs versus the big pooled totals, so keep them apart: the small pairs were ratio illustrations walked through live, while 360, 175 and 0 are the pooled totals to use in numerical answers.

The imbalance condition is now on the table with numbers attached. The next subsection traces the mechanism by which these lopsided counts bend what the network learns, at local scale first and then at global scale.

13.1.3 Why Imbalance Breaks Learning

Take a party with 50 percent cats, 30 percent dogs and 20 percent birds. A feature extractor trained on that mix meets cats most often. It tunes its filters for cat texture and shape. Dogs get less tuning. Birds get very little. At prediction time the model favours the classes it met most. Rare inputs get pulled toward the nearest big cluster and labelled wrong.

The same pull acts at global scale. Suppose the pooled data holds 360 of class A and only a handful of class B. Gradients from class A dominate each step because each averaged gradient is a vote weighted by headcount: roughly 360 votes for A against a handful for B. The decision surface shifts to please class A. Class B rows near the border fall on the wrong side. When a class has zero pooled rows, the model has no direct signal at all and must rely on structure shared from other classes plus smoothing from global statistics, which is covered in later sections.

Work through the gradient arithmetic once with tiny numbers. Say one cat row votes gradient 2.0 toward the cat side and one bird row votes gradient 2.0 toward the bird side, and a batch holds 5 cats and 1 bird. The cat pull totals about 10.0 against a bird pull of about 2.0, so the step moves roughly five times further toward cats. That is the whole mechanism in one line: headcount weights the vote, and the boundary slides toward whoever brings fewer voters.

Fraud scoring shows the cost of ignoring this: millions of ordinary transactions bury a handful of fraud cases, and a model trained on raw counts learns to wave everything through. Keeping a slot open for the rare class is the design goal of everything that follows.

13.2 Classifier Bias and Extractor Bias

13.2.1 Classifier Bias Toward Local Majorities

A classifier is the head that maps a feature vector to class scores, meaning one number per class where the largest number wins the prediction. A classifier bias here means the head leans toward locally common classes: its winning scores go to the labels it met most often. Because each party trains mostly on its own majority, its head learns high scores for those labels. In plain words, the head becomes a home-team fan that cheers for the local majority on every close call.

The failure shows on unaligned and unlabeled rows. Feed an unlabeled row from a rare class into a head shaped by a local majority and the head returns the majority label with high confidence. Those wrong pseudo-labels then feed back into training and lock in the error, because the next round treats the wrong guess as fresh truth. Class 1 against class 4 was used as a running case. Each party had its own pair of dominant labels, for example classes 2 and 3 dominating one side while classes 1 and 4 dominated the other, with classes 2 and 3 nearly absent on that side. Each local head therefore trusted its own pair and distrusted the rest.

Concretely, imagine a head that saw 200 rows of class 1 and 5 rows of class 4. Its class-1 score weight grows large while its class-4 weight stays near its starting value. A new class-4 row then scores, say, 3.1 for class 1 against 1.2 for class 4, and loses even though its features point to class 4. That is the whole failure in numbers: score weights follow headcount, and headcount decides close calls.

This head-level lean is only half the story. Even with a fair head, a biased extractor would feed it vectors in which rare detail was already erased, which is the next subsection.

13.2.2 Extractor Bias and the Overlap Picture

A feature extractor is the network body that turns raw input into a numerical vector, meaning the stack of layers before the final scoring head. An extractor bias means that body learns discriminative detail mostly for majority classes: its filters resolve majority texture finely and blur everything else. Within each party feature space, locally frequent features fill the space and drown out the fine detail that would separate minority classes.

A four-class picture made this concrete. Dots in four colours stood for classes 1 through 4. In one party the blue dots were many. Blue filled a wide region. A few dots of other colours sat inside or near the blue region. The trained extractor treated those neighbours as blue as well because it had learned blue texture so well and the other textures so weakly. In the mirror party a different colour dominated and the same swallowing happened there. Green was used as a case with almost no presence in one view, so nothing was learned for green there at all.

The dark lens-shaped overlap in the middle was the border zone. A few minority rows crossed into it from each side. Because major classes owned both sides, those crossing rows were read as members of the neighbouring majority rather than as their own class. The shape is not a third cluster. It is the zone where minority rows get split between the two neighbouring majorities and lose their identity.

Read the plot like a map. Each axis is one learned feature direction with no units, each dot is one row, and colour marks the true class. The landmark is the wide blue territory with a few foreign-coloured dots trapped inside it, plus the dark lens at the centre where trapped dots from both sides pile up. The takeaway is geometric: majority territory expands with headcount, and minority rows caught inside it are misread no matter what the head does.

Think of it like a loud pair of voices in a small room. Two people speak most of the time, so a listener learns their voices well. When a quiet third person speaks briefly near one of the loud speakers, the listener hears the loud voice and misses the quiet one. The fix is not to turn up the volume. It is to train the ear to keep a slot open for quiet voices even when loud voices dominate the room. The mapping is direct: speaking time is row count, the trained ear is the extractor, and the kept-open slot is the protected prototype plus prior mass that later sections build.

The listener analogy also marks where it breaks: a human listener can ask the quiet speaker to repeat the sentence, while the extractor cannot request more minority rows. It must instead reserve capacity for them using priors and transport costs, which is what the next sections construct.

13.2.3 Student Questions and Answers

The head learns whom to cheer for while the extractor learns whose faces to resolve sharply. Both biases point at the majority, which is why rare rows lose twice: their detail is blurred before scoring, and the scoring itself favours the familiar answer.

Biased heads and biased extractors that each trust their own dominant pair cannot be fixed by averaging their votes. The federation needs shared centres and smoothed frequencies that keep every class represented, which is where the next section starts.

13.3 Parties, Priors, Prototypes and Model Pieces

13.3.1 Local Prior and Global Prior

A local prior is how common each class is inside one party, meaning the share of that party rows belonging to each class. Write it as $p_m(z)$, where $m$ names the party and $z$ names the class. The spoken form in the room was "50 percent of the rows in this party are cats", which becomes $p_m(\text{cat})=0.50$. A full local example is $p_m(\text{cat})=0.50$ with $p_m(\text{dog})=0.30$ and $p_m(\text{bird})=0.20$. Each party has its own triple and the triples differ across parties. Every local triple sums to 1: 0.50 plus 0.30 plus 0.20 equals 1.00.

A global prior is how common each class is across all parties pooled together. Write it as $p^g(z)$ for the current round, and with an explicit round index as $p^{g,T}(z)$ where $T$ counts communication rounds and the superscript $T$ simply tags which round the estimate belongs to. The spoken form was "across all parties, 40 percent are cats", which becomes $p^g(\text{cat})=0.40$. A full global example is $p^g(\text{cat})=0.40$ with $p^g(\text{dog})=0.35$ and $p^g(\text{bird})=0.25$. The global triple is the average of the local triples. It shifts from round to round as local estimates improve.

Why keep both? The local triple tells what this party actually sees. The global triple tells what the federation as a whole sees. When a party has very few rows of a class, its local number is noisy. The global number steadies it. That steadying is the core fix and returns in the prior-update section. Think of a bag of marbles split by colour where the shares must total 1: each party holds its own small bag with its own colour mix, and the global bag pools all parties so that a colour missing from one small bag still shows its true overall share.

Frequencies alone cannot classify anything. They need geometric anchors to act on, which are the prototypes introduced next.

13.3.2 Prototypes, Features and Refined Features

A prototype is one centroid vector that stands in for a whole class inside one party, meaning the average address of that class in the party feature space. Write it as ${\mu }_{m,z}$, where $m$ is the party and $z$ is the class. The spoken form was "the ideal feature vector for cats in party m", which becomes ${\mu }_{m,\text{cat}}$. A prototype is the mean of the feature vectors of that class in that party. With three cat rows giving vectors $c_1$, $c_2$ and $c_3$, the prototype is their average. One illustration averaged first entries to 0.8 and second entries to minus 0.2, giving a centroid near $[0.8,-0.2]$. There is one such centroid per class per party: a cat centroid, a dog centroid, a bird centroid and so on. Same-class features should cluster near their prototype and stay away from other prototypes.

A feature vector is the numerical output of a party extractor for one row, meaning a list of numbers that places the row in the party learned space. Write an unaligned feature as $f_{m,n}$, where $m$ is the party and $n$ indexes the row. The spoken form was "pass the nth unaligned row through party m extractor and get a vector". An aligned feature is the same idea for an aligned row, written here as $h_{m,a}$ where $a$ indexes the aligned row. These vectors travel upward. Unaligned vectors stay local and shape local training. Aligned vectors are sent up for merging because only they have central labels.

A refined feature is an aligned vector mapped into a shared space. Write it as $r_{m,a}=R_m(h_{m,a})$, where $R_m$ is the adapter for party $m$. The spoken form was "run the received vector through the adapter to bring it onto a common scale". Parties may use different vector sizes, so raw vectors cannot be added directly: a 128-wide vector and a 256-wide vector have no entry-wise sum. The adapter maps each view onto one shared scale where addition is valid, just as converting all prices to the same currency must precede adding them.

Other symbols met in the room: $M$ for the number of parties, $Z$ for the number of classes with values like cat and dog, $T$ for the communication round, $B$ for a sampled batch of rows, ${\theta }_m^e$ for extractor weights of party $m$, $R_m$ for adapter weights, $G$ for gating-network weights, $C$ for final classifier weights, $W_m$ for the merge weight of party $m$, $\eta$ for a learning rate, and ${\gamma }_m$ for a per-party mixing number between local and global information. Keep this list handy: every later update is written in exactly these symbols with no silent renames.

Prototypes give every class a reserved address, priors give every class a reserved share, and adapters give every party a common language. The remaining pieces decide how much to trust each translated view.

13.3.3 Adapter, Gating Network, Weights and Classifier

An adapter is a small trainable map $R_m$ that cleans and rescales party $m$ vectors into the shared space. A gating network is a trainable map $G$ that reads the refined vectors and outputs merge weights. A merge weight $W_m$ says how much of party $m$ view to keep for one aligned row. A classifier $C$ is the final trainable head on the active side that maps the merged vector to class scores.

Adapters of this kind appear whenever views have mismatched widths, for example one party with a 128-wide embedding and another with a 256-wide embedding that must be fused into one 128-wide shared vector before scoring. Recommender systems fuse text and image towers the same way, and multi-hospital models fuse lab panels of different lengths through per-site adapters before joint scoring.

All the nouns are defined and all the symbols are fixed. The next section turns them into the two loss functions that do the heavy lifting against imbalance.

13.4 Two-Way Transport Costs Between Features and Prototypes

13.4.1 Mathematical Formulation

A transport cost here is a loss that measures movement between features and prototypes, meaning the price of dragging one toward the other. There are two directions. The spoken forms were "full features to prototypes" and "prototypes to features", reconstructed below as $f\to \mu$ and $\mu \to f$.

The $f\to \mu$ cost asks how far each feature vector sits from its assigned prototype. The spoken form was "measure how far each feature vector is from its assigned class prototype, weight by how likely it belongs there, then average over all features and prototypes". One faithful reconstruction is:

$${\mathcal{L}}_{f\to \mu }=\frac{1}{|B|}\sum _{f\in B}\sum _{z=1}^{Z}w(f,z)d(f,{\mu }_{m,z})$$

where $d$ is a distance such as squared Euclidean distance, $w(f,z)$ is the soft assignment weight saying how likely feature $f$ belongs to class $z$, $B$ is the sampled batch, and $Z$ is the number of classes. Terms: $f$ ranges over feature vectors in the batch, ${\mu }_{m,z}$ is the prototype for class $z$ in party $m$, $w(f,z)$ is large when the match is close and small when it is far, and the mean runs over all features and prototypes including other classes such as dogs with vectors $v_1,v_2,v_3$ and their own centroid. The lecture described this cost at a high level and named paper equations 4, 7 and 11 as the places where the prior enters the soft assignment $w(f,z)$ so that rare classes receive a boosted weight; the display above keeps the professor spoken structure with standard summation notation made explicit.

The $\mu \to f$ cost asks the mirror question, namely how far each prototype sits from the features of its class. The spoken form was "measure how far each prototype is from the features in its class, weight each prototype by its prior probability, then average over the batch". One faithful reconstruction is:

$${\mathcal{L}}_{\mu \to f}=\sum _{z=1}^Z{p}_m(z)\left(\frac{1}{|B_z|}\sum _{f\in B_z}d({\mu }_{m,z},f)\right)$$

where $p_m(z)$ is the local prior for class $z$ in party $m$ and $B_z$ holds the batch features currently claimed for class $z$. Terms: ${\mu }_{m,z}$ is the prototype, $f$ ranges over nearby features claimed for class $z$, and $p_m(z)$ scales the term so the sum stays a proper prior-weighted average rather than letting common classes dominate silently. The averaging set follows the spoken description; texts often write the same idea as an expectation over the class-conditional batch.

Both costs are local to the party. Both are minimized during local steps with local learning rates. The pair works like two mirrors facing each other. One pulls features toward their ideal centre so each class forms a tight cluster. The other pulls each ideal centre toward its features so no prototype is left without nearby rows. Together they keep rare centres alive. Without the second direction a rare prototype could sit empty while all mass collapsed onto big centres, and the global model would never learn that class.

Paper equations 4, 7 and 11 were named as the places where these priors bias the soft assignment toward rare classes.

The two directions are easy to confuse under exam pressure, so fix the picture before the numbers: features-to-centres tightens clouds, centres-to-features guards empty slots, and the prior is the guard funding.

13.4.2 Worked Mini Example

Take party $m$ with classes cat, dog and bird. Local priors are $p_m(\text{cat})=0.50$, $p_m(\text{dog})=0.30$ and $p_m(\text{bird})=0.20$. Three cat rows give vectors $c_1=[0.9,-0.1]$, $c_2=[0.7,-0.3]$ and $c_3=[0.8,-0.2]$. The cat prototype is the entry-wise mean:

$${\mu }_{m,\text{cat}}=[0.8,-0.2]$$

Now look from the centre outward. The $\mu \to f$ term for the bird prototype multiplies the mean distance from the bird centre to nearby bird vectors by $p_m(\text{bird})=0.20$. Even though 0.20 is small, the term stays in the sum and forces the bird centre to keep neighbours close. That is how a 20 percent class keeps its slot against a 50 percent class. Concretely, if the mean bird distance is 0.05, its contribution is 0.20 times 0.05, which is 0.01: small but nonzero, so the optimizer cannot delete the bird centre for free.

Picture tightness as darts around a bullseye with spread measured by variance: small spread means darts pierce the board near the centre, big spread means darts scatter across the wall. Each transport direction attacks one kind of scatter, and the pair leaves every bullseye, large or small, with darts grouped near it.

13.4.3 Why Two Directions Matter

One direction alone clusters the rows that already exist but lets empty centres drift. The other direction alone plants centres near rows but lets rows sprawl. Small spread means tight clusters. Big spread means loose clouds that cross borders. The pair gives tight clusters around every centre that carries prior mass, including small-mass centres. That is the behaviour the later global steps rely on.

Tight clusters around defended centres are only useful if training actually enforces them batch after batch. The next section runs that loop and shows what gets sent upward once it finishes.

13.5 Client-Side Training and Aligned Re-Encoding

13.5.1 Batch Sampling and Extractor Update

Training runs as nested loops. The outer loop counts communication rounds $T$. Inside, parties run in parallel. Each party draws a sample batch $B$ from its own store of cats, dogs and birds. It feeds the batch through its own network, which has the familiar split of a convolutional body as feature extractor, a flatten stage and a classifier head. The flatten stage simply unrolls the final feature map into one long vector that the head can score; nothing is learned there, but every exam answer that lists the body parts should name it.

The extractor weights ${\theta }_m^e$ move by a local gradient step scaled by a local rate $\eta$. In words the spoken update was "local gradient times learning rate applied to the extractor weights", reconstructed as:

$${\theta }_m^e\leftarrow {\theta }_m^e-\eta \nabla {\mathcal{L}}_{local}$$

where the local loss is the sum of the two transport costs for that party, ${\mathcal{L}}_{local}={\mathcal{L}}_{f\to \mu }+{\mathcal{L}}_{\mu \to f}$, both computed on batch $B$. Terms: ${\theta }_m^e$ holds party $m$ extractor weights, $\eta$ is the local step size, and $\nabla {\mathcal{L}}_{local}$ is the gradient of the local two-way cost on batch $B$. The lecture did not dictate extra weighting constants between the two terms, so they enter with equal weight; any reweighting would be a named hyperparameter, not a silent default.

The imbalance trap bites here. A batch from a 50-30-20 party holds mostly cats, some dogs and one bird at most: in a batch of 10, expect about 5 cats, about 3 dogs and about 2 birds, and smaller batches often hold zero birds. Step after step the extractor sees cats and dogs and tunes for them. Bird detail stays weak. That is why the two transport costs from the prior section are active during these steps. They tax sprawl and tax empty centres, so even a bird-poor batch must keep bird rows near the bird centre.

Follow the causal chain into the next step: a freshly stepped extractor produces fresher aligned vectors, fresher vectors earn better merges, and better merges return better prototypes that guide the next local round.

13.5.2 Re-Encoding Aligned Samples

After the local steps, each party re-encodes only its aligned rows. Training used both aligned and unaligned rows. Re-encoding uses aligned rows alone. Each aligned row goes back through the freshly tuned extractor and comes out as an aligned feature $h_{m,a}$. Those vectors, plus the party priors, are sent upward. The priors travel because the active side needs each party frequency triple to form the global average and to interpret the incoming vectors.

The logic is simple. Unaligned rows helped shape the extractor. Only aligned rows have central labels, so only they can teach the central merger and head. Sending anything else would add unsupervised mass where a supervised loss is needed. Re-encoding matters rather than reusing stale vectors: the extractor changed during local steps, so vectors computed before the steps would describe an extractor that no longer exists.

Local work ends with fresh aligned vectors and fresh priors on the wire. The next section opens them at the active party and fuses the views into one scored vector.

13.6 Active-Party Aggregation and Global Update

13.6.1 Refinement and Aggregation Weights

The active party is the side that holds labels for aligned rows and learns the merger plus final head. It receives aligned vectors and priors from every party. It first refines each received vector through that party adapter as $r_{m,a}=R_m(h_{m,a})$. The spoken form was "clean the received vectors and map them into a common space", which is exactly what $R_m$ does through steps such as noise removal and rescaling. The gating network $G$ reads these refined vectors and returns the merge weights; the lecture phrased the gating input both ways in passing, and the reconciled reading is that refined vectors feed $G$, since raw vectors live on incompatible scales and cannot enter one shared judge.

Next it merges views for each aligned row. With refined vectors $r_{1,a},r_{2,a},r_{3,a}$ from three parties and learned scalars $W_1,W_2,W_3$, the merged vector is:

$$m_a=W_1{r}_{1,a}+W_2{r}_{2,a}+W_3{r}_{3,a}$$

Terms: $r_{m,a}$ is the refined view from party $m$ for aligned row $a$, $W_m$ is the importance of that view with $W_1+W_2+W_3=1$, and $m_a$ is the single fused vector for row $a$. The weights come from the gating network $G$ and are learned, not fixed. A view shaped by 50 same-class rows earns more trust than a view shaped by 5 same-class rows for the same aligned input, because its extractor output is more representative.

Small counts win or lose here in concrete form. Say party 1 trained its cat path on 50 cats and party 2 trained its cat path on 5 cats. The same aligned cat row fed to both gives two outputs. The first output rests on broad evidence. The second rests on thin evidence. The learned weights should put more mass on the first, so $W_1$ ends above $W_2$ for that row. That is learned per merge, not set by hand: training discovers which view predicts the label better and shifts weight there through the global loss gradient.

Weights that track evidence rather than headcount alone are the global counterpart of the local prior fix: both steer influence toward whoever actually learned the class.

13.6.2 Student Questions and Answers

The gating network is the judge, the adapters are the translators, and the classifier is the decider. Each role has its own parameters because translation quality, trust and scoring are three different skills that improve on three different error signals.

13.6.3 Global Loss and Combiner-Classifier Update

Because the active side holds the true label for each aligned row, it can score the merged vector and pay a supervised global loss. The lecture stated the step in words without dictating the loss formula, and the reconciled reading is the standard cross-entropy on the merged vectors: sample a batch of aligned rows, build each $m_a$ by the weighted sum above, score it through $C$, compare against the known label $y_a$ and step $R$, $G$ and $C$ jointly down the gradient. In symbols the update for each parameter group $P\in \{R,G,C\}$ is:

$$P\leftarrow P-{\eta }^g{\nabla }_P{\mathcal{L}}_{global}$$

where ${\eta }^g$ is the global step size and ${\mathcal{L}}_{global}$ is the supervised loss over the aligned batch. In words, sample a batch of aligned rows, build each $m_a$ by the weighted sum above, compare against the known label, and move $R_m$, $G$ and $C$ to reduce the error.

Updated prototypes and priors then flow back down for the next round, which the next section covers. Representations, weights and heads therefore chase each other round after round. Local bodies improve, merges improve, heads improve, and the improved heads and prototypes guide the next local round.

Fusion converts many private views into one scored vector, but it cannot rescue a party whose local frequency estimate has already collapsed to zero. That rescue is the job of the smoothing update that flows back down before the next round.

13.7 Local Prior Update with Global Smoothing

13.7.1 Local Prior Update Rule

Step four of the routine is the heart of the fix. Each party refreshes its local class frequencies by mixing its own counts with the global average. Write the next-round local prior for party $m$ and class $z$ as ${\pi }_m^{(T+1)}(z)$. The spoken form was "new local prior blends the global prior from the active side with local evidence, with a per-party mixing number deciding the blend". One faithful reconstruction is:

$${\pi }_m^{(T+1)}(z)={\gamma }_m{p}^{g,T}(z)+(1-{\gamma }_m){\hat{p}}_m^T(z)$$

where ${\hat{p}}_m^T(z)$ is the fresh local estimate from party $m$ features at round $T$ and $p^{g,T}(z)$ is the global prior averaged over local priors. The lecture mentioned an averaging constant in passing without fixing its placement; the reconciled reading uses a plain convex combination with one per-party mixing number ${\gamma }_m$ in $[0,1]$ and no extra constant, since any additional constant would break the sum-to-1 property shown below. Terms: ${\gamma }_m$ in $[0,1]$ is the mixing number for party $m$, $p^{g,T}(z)$ is the pooled frequency of class $z$, and ${\hat{p}}_m^T(z)$ is what party $m$ alone would report. A related averaging step forms the global triple as the mean of local triples:

$$p^{g,T}(z)=\frac{1}{M}\sum _{m=1}^M{\hat{p}}_m^T(z)$$

When a party holds very few rows of a class, its ${\hat{p}}_m(z)$ is noisy and too small. The model would then ignore that class. Pulling in $p^g(z)$ lifts the estimate and keeps gradient mass on the rare class. The per-party ${\gamma }_m$ sets how much outside help to take. Thin local evidence calls for more global help. Rich local evidence calls for less. In practice a party with deep local counts uses a small ${\gamma }_m$ near 0.1, while a party nearly blind to a class uses a large ${\gamma }_m$ near 0.7.

All probabilities reappear inside the later losses and assignments, so this smoothing propagates. Softmax-style assignments that use these priors tilt back toward rare classes instead of collapsing onto big ones. The smoothed prior enters the soft assignment weight $w(f,z)$, scales the $\mu \to f$ term, and seeds the next round local triple, so one blending step protects the class in three places at once.

13.7.2 Worked Analogy and Smoothing Effect

A housing-price analogy carried the idea. Take one neighbourhood with very few recent sales. A buyer offers a very low price based only on those few sales. The seller knows the city-wide average across neighbourhoods is much higher. Blending the thin local number with the broad city average lifts the asking price toward a fair level, say from a naive 1 unit offer toward 10 units when the wider area supports it, or from 5 toward 15 when nearby zones trade near 20. Those currency numbers were board illustrations of the blending motion, not market data, so read them as directions rather than quotes. The blend neither ignores the street nor copies the city blindly. The mixing number plays the role of trust in outside data.

Map the story back. The street is party $m$. The city is the federation. The price is ${\pi }_m(z)$. The outside average is $p^g(z)$. A rare class with tiny local mass gets lifted by the pooled mass, so its prototype, its transport term and its assignment weight all stay alive for the next round.

Think of it like a small class that keeps a seat at the table even when it brings little food. The global average vouches for it until it can bring more rows of its own. The analogy breaks at one honest point: dinner guests who bring no food still eat, while a class with truly zero rows everywhere still has nothing to learn from. Smoothing protects the thinly seen, not the universally absent.

Smoothing rescues rare classes that own at least a few rows somewhere. The final method of the lecture handles the harder case where labels themselves are scarce and views disagree, by letting three experts vote and keeping only their confident agreements.

13.8 Semi-Supervised Cross-View Training

13.8.1 Three Experts and the Agreement Rule

The closing topic starts a second method for the case where labels are scarce and views are split. Three heads train on three different data slices. One head sees only view A rows, for example only dog rows with labels. One head sees only view B rows. One head sees rows from both views, for example cats and dogs together. Each becomes an expert in what it saw. The A-only expert knows A patterns. The B-only expert knows B patterns. The joint expert knows shared patterns. This tri-head design is the PET-CVT cross-view training scheme named in the exam guidance: two single-view experts plus one joint expert that bridges them.

A new row with missing features or a missing label goes to all three heads. Each head returns a class plus a confidence number. A pseudo-label is kept only when all three heads agree on the class and each confidence clears a threshold. Otherwise the row is dropped from supervised use. The spoken threshold was 0.70, reconstructed as:

$$\text{keep label }\hat{y}\text{ only if }\min (c_1,c_2,c_3)\ge \tau \text{ with }\tau =0.70$$

where $c_1,c_2,c_3$ are the three confidences for the agreed class. The lecture stated one shared cut-off of 0.70 rather than per-class cut-offs; per-class threshold tuning continues in the following session. Terms: $\hat{y}$ is the agreed pseudo-label, $c_i$ is head $i$ confidence in $\hat{y}$, and $\tau$ is the cut-off. All three must clear the bar: a single sceptic vetoes the label.

A worked pass used a true cat row. The cat-only head reported about 0.90 for cat. The joint head reported about 0.80 for cat. The dog-only head, which had never seen cats, still guessed dog but with weak confidence near 0.10 for dog, which is about 0.90 against dog. Only the agreed class whose every head clears 0.70 survives. That rule is why the method is called cross-view. No single view decides alone. The label must look right from every view.

13.8.2 Student Questions and Answers

Dropped rows are not deleted rows. They wait in the pool while the extractors improve, and each later round re-examines them with sharper eyes.

13.8.3 Labels for Aligned and Non-Aligned Rows

Labels exist for aligned rows. Non-aligned rows split by side. On one side the label may be present while the matching view on the other side is missing, and vice versa. The routine trains one head per available slice, collects three outputs per unlabelled row, applies per-class thresholds, and keeps the agreed subset as fresh pseudo-labels. The next round then trains on aligned labels plus these kept pseudo-labels. Full detail on threshold choice per class continues in the following session, followed by exam-style numerical problems.

Agreement filtering of this kind is used when labelling is costly, for example keeping only machine-labelled images on which colour, texture and caption models all agree before spending reviewer time. Medical triage pipelines keep only scans on which two view-specific models plus one joint model concur before a specialist reviews, and content-moderation queues escalate everything else to humans.

Cross-view agreement closes the lecture loop: prototypes and priors defend rare classes inside the federation, while three voting experts grow the labelled set where no labels existed. Both tools serve the same goal of learning from lopsided vertical views without moving raw data.

Exam Guidance Summary

Study from the post-mid part of the course, starting at FedAvg through the vertical methods. Central items are communication-efficient vertical learning with limited overlap, Proto-VFL and PET-CVT with cross-view training. FedAvg is the horizontal averaging baseline the vertical methods depart from: where FedAvg averages model weights across same-feature clients, Proto-VFL fuses different-feature views of shared IDs through prototypes, adapters and gating.

Carry one worked number for each mechanism into the hall: a pooled share, a centroid mean, a fused vector, a smoothed prior and one threshold decision. Those five numbers cover every numerical style named above.

Key Industry Applications

Vertical fusion of bank and retail views of shared customers keeps each side raw data local while scoring the shared IDs jointly, the canonical cross-silo deployment described for vertical federated learning. Adapter maps reconcile mismatched embedding widths before fusion wherever two systems describe the same entity with different vector sizes. Gating weights trust the view with deeper same-class evidence, such as 50 rows over 5 rows, so the better-observed view dominates each merge without any hand-set rule.

Together these five patterns form one deployable story: fuse views without moving raw data, translate them onto one scale, trust the best-evidenced view per row, keep rare classes funded through smoothed priors, and grow labels only through confident cross-view agreement.