CV Train Classifier

You have features - stacked points, HOG rows, embeddings from a model that already ran - and integer labels for them. You want a classifier. CV Train Classifier fits one from the cv2.ml family and, more importantly, tells you whether it works instead of letting you assume it does.

The design choice that matters: the model never leaves the node. Training, evaluation and the optional prediction all happen in one execute call, so ComfyUI's caching stays correct (a node that trained on the side and cached its model would give you stale predictions the moment the inputs changed, with no visual sign).

What happens in one call

Your rows get split into a train set and a held-out test set, stratified per class and deterministic per seed. The chosen algorithm fits on the train split, then scores on the test split. You get accuracy, train accuracy, and a confusion matrix. Same seed, same split, same model - which is the point. Reproducible experiments inside a graph that otherwise re-rolls seeds at you.

The inputs that matter

• features - (N, D), one sample per row. Any shape flattens to rows, so a stacked blob of small image patches works.
• labels - (N,) integer class labels, aligned with the rows. CV Stack Feature Classes produces exactly this shape.
• algorithm - the menu is the point here. SVM is the strong default. KNearest is instance-based (no real training, just neighbours voting). RTrees/DTrees are tree ensembles, Boost needs exactly two classes, NormalBayes fits gaussians, LogisticRegression is linear, and ANN_MLP is a small fully-connected net trained from scratch by backprop - note it cannot fine-tune a pretrained network, that's not a thing cv2.ml does.
• test_fraction (default 0.3) - the held-out share. Set it to 0 and evaluation happens on the training set, which is optimistic to the point of meaningless, though it's fine if you just want decision regions for a demo.
• query_features - optional. Wire CV Coordinate Grid in here and the model classifies every pixel-coordinate pair, which you reshape and colour-map to paint the decision regions. That's the trick that turns a classifier into a picture.

There are per-algorithm knobs - svm_kernel, svm_tuning, svm_c, svm_gamma, knn_k, tree_depth, forest_size, mlp_hidden, mlp_iterations - plus seed. For SVM, svm_tuning = trainAuto cross-validates a grid over C and gamma: slower, and the honest default once you're past a toy.

The outputs

predictions and eval_labels are aligned arrays - compare them yourself if you want a per-sample view. accuracy is the headline number, train_accuracy is the one to compare it against: a big gap between them is overfitting in one line. confusion is a (K, K) int32 matrix, true class down the rows and predicted across the columns; upscale it with cv2_resize (INTER_NEAREST) and look at it with Preview CV Array (heatmap) rather than trusting a single accuracy figure. query_predictions is one label per query row, and model_yaml is the serialized model - real OpenCV YAML that cv2.ml.SVM_load reads back outside ComfyUI, which is how anything you train here escapes the graph.

success is false when training was impossible: no samples, a single class, or an algorithm/data mismatch like Boost with three classes. It doesn't raise - you get safe empty outputs and query predictions defaulting to the first class so your reshapes still work. Gate the downstream pretty graph on it with an if/else.

Installing it

Manager → ComfyUI CV, or:

cd ComfyUI/custom_nodes
git clone https://github.com/bmad4ever/comfyui_cv

Restart. Python ≥ 3.12, ComfyUI on the V3 node API, opencv-contrib-python-headless~=5.0.0.93. Nothing to download. Do keep the contrib wheel: swap in plain opencv-python and you'll lose chunks of the pack silently.

Where people get burned

Gamma units. svm_gamma is scale-dependent and the tooltip is the honest answer: for raw pixel coordinates you want something like 0.001-0.01, for normalized features 0.1-10. Leave it at 1 with RBF on pixel coords and you get a boundary that's noise in your input.

Judge by confusion, not accuracy. With three imbalanced classes, 85% accuracy can mean the model predicts the big class and ignores the other two. The matrix shows you that instantly.

A held-out set that isn't held out. If your "test" features were selected using the labels you're testing against, no amount of test_fraction rescues the number.

Expecting deep features to be plug-and-play. cv2.ml classifiers are small-capacity, decades-old implementations. They'll happily fit a feature vector a modern network gave you - that's an effective and cheap setup - but the ceiling is the classifier, not the embedding.