// bridge system

useState()→Model Weights·Event Propagation→Forward Pass·Array.map()→Tensor Operation·React diff→Loss Function L = Σ(y−ŷ)²·transition-duration→Learning Rate η·CSS clamp()→σ(x) Activation·Re-render cycle→Training Epoch·Event bubbling→Backpropagation ∂L/∂w·useCallback→Gradient Caching·Promise.all()→Batch Inference·Redux store→Weight Matrix·DevTools profiler→Loss Landscape·useState()→Model Weights·Event Propagation→Forward Pass·Array.map()→Tensor Operation·React diff→Loss Function L = Σ(y−ŷ)²·transition-duration→Learning Rate η·CSS clamp()→σ(x) Activation·Re-render cycle→Training Epoch·Event bubbling→Backpropagation ∂L/∂w·useCallback→Gradient Caching·Promise.all()→Batch Inference·Redux store→Weight Matrix·DevTools profiler→Loss Landscape·

Disclaimer: Signal Ward is an educational simulation. All clinical scenarios are fictional. Nothing in this course constitutes medical advice.

Dr. Karimi
Our first milestone: Diagnostic One needs to tell the difference between an allergy note, a progress note, and a discharge summary. Can you build that, Khalil?

Khalil
So it's like... routing. A request comes in and I need to send it to the right handler based on its content?

Vikram
That's exactly right. A classifier is a router for data. It looks at the features and decides which category they belong to.

You use Array.map() constantly — transforming each element in an array. A classifier does the same thing: it takes each input feature, multiplies it by a learned weight, adds a bias, and the result determines the category.

Learning Objectives

○Build a simple linear classifier using TensorFlow.js
○Understand weights and bias as the model's learned parameters
○Map the concept of Array.map(transform) to matrix multiplication
○Classify clinical notes into categories using feature vectors

The Simplest Classifier

Frontend

Array.map()

items.map(x => x * weight + bias)

Machine Learning

Linear Classifier

prediction = tf.add(tf.mul(input, weights), bias)

Identity Bridge

A linear classifier is just weighted addition. Each feature gets a weight that the model learns during training. Higher weight means that feature matters more for the prediction.

note-classifier.tstypescript

import * as tf from '@tensorflow/tfjs';

// Features: [has_allergy_word, has_medication, has_vitals, has_discharge_word, has_follow_up]
const allergyNote = tf.tensor([1, 1, 0, 0, 0]);
const progressNote = tf.tensor([0, 0, 1, 0, 0]);
const dischargeNote = tf.tensor([0, 1, 0, 1, 1]);

// Learned weights for "is this an allergy note?"
const allergyWeights = tf.tensor([0.9, 0.3, -0.1, -0.5, -0.2]);
const bias = tf.scalar(0.1);

// Score = sum(features * weights) + bias
function classify(features: tf.Tensor, weights: tf.Tensor, b: tf.Tensor): number {
const score = features.mul(weights).sum().add(b);
return score.dataSync()[0];
}

console.log('Allergy note score:', classify(allergyNote, allergyWeights, bias));     // ~1.3 (high)
console.log('Progress note score:', classify(progressNote, allergyWeights, bias));    // ~0.0 (low)
console.log('Discharge note score:', classify(dischargeNote, allergyWeights, bias));  // ~-0.1 (low)

From Score to Decision

A raw score isn't a classification yet. We apply a sigmoid function to squash it between 0 and 1 — turning it into a probability.

sigmoid-decision.tstypescript

// Sigmoid: squash any number to the 0-1 range
// Like CSS clamp() but for probabilities
function sigmoid(x: number): number {
return 1 / (1 + Math.exp(-x));
}

// High score → high probability
console.log(sigmoid(1.3));   // ~0.79 → likely an allergy note
console.log(sigmoid(0.0));   // 0.50 → uncertain
console.log(sigmoid(-0.1));  // ~0.48 → probably not an allergy note

// In TensorFlow.js, use tf.sigmoid()
const scores = tf.tensor([1.3, 0.0, -0.1]);
const probabilities = tf.sigmoid(scores);
probabilities.print(); // [0.786, 0.500, 0.475]

Challenge

Build a classifier that scores clinical notes as allergy-related or not.

⚡

Exercise

Beginner~8 min

Note Classifier

Write a classify function that takes a feature tensor and weight tensor, multiplies them element-wise, sums the result, adds a bias of 0.1, and returns the sigmoid of the score using tf.sigmoid(). Return the result of dataSync()[0].

import * as tf from '@tensorflow/tfjs';

function classify(features: tf.Tensor, weights: tf.Tensor): number {
  const bias = 0.1;
  // 1. Multiply features by weights element-wise
  // 2. Sum the result
  // 3. Add bias
  // 4. Apply sigmoid and return the value
  return null; // your code here
}

const features = tf.tensor([1, 1, 0, 0, 0]);
const weights = tf.tensor([0.9, 0.3, -0.1, -0.5, -0.2]);
const result = classify(features, weights);

Key Takeaways

✓A classifier multiplies features by weights and adds bias — just like Array.map(transform)
✓Sigmoid converts raw scores to probabilities between 0 and 1
✓Weights are the parameters the model learns — they encode which features matter
✓Classification is essentially routing: data in, category out

Need a hint?

🧭 Guidance

✅ Solution

Your First Classifier — Signal Ward | Tensorcraft

Your First Classifier

Context