fix(#1400): swap CrossEntropyLoss → CrossEntropyWithLogitsLoss across 141 files

[ooples]

Summary

• 141 files, 281 occurrences swapped from new CrossEntropyLoss<T>() to new CrossEntropyWithLogitsLoss<T>(). All affected models emit raw conv/dense logits from identity-activated final layers, so the previous probability-input CE loss was driving -actual/predicted through ClampProbability's epsilon floor and producing gradient spikes that exceed MaxGradNorm=1.0 clipping in deep cascades.
• CrossEntropyWithLogitsLoss<T> is the PyTorch-equivalent fused LogSoftmax+NLL — numerically stable on raw logits.

Confirmed gradient-explosion failures fixed

Test	Before (initial → final loss)	After
PointTransformerV3.Training_ShouldReduceLoss	1.26 → 16575 (13000×)	PASS
Sonata.Training_ShouldReduceLoss	0.96 → 10755	PASS
SwinUNETR.Training_ShouldReduceLoss	0.34 → 9.6e17	PASS
OMGSeg.Training_ShouldReduceLoss	(was failing)	PASS

Affected families

• ComputerVision/Segmentation: 69 files
• Document: 26
• Classification: 17
• NeuralNetworks: 9
• Audio: 8
• ProgramSynthesis: 4
• Video: 3
• NER: 2
• Training, FitnessCalculators, Finance: 3 total

AiDotNet.LossFunctions is a global using so no per-file using directives were needed.

Test plan

• dotnet build src/AiDotNet.csproj --no-restore — clean (0 errors)
• Segmentation training tests: PTV3 / Sonata / SwinUNETR / OMGSeg — 4/4 PASS
• Cross-family regression sweep (LayoutLM / Wav2Vec2 / CodeBERT / NodeClassificationModel) — identical 4-fail/1-pass on master baseline vs. branch. The failures (LayoutLM ParameterBuffer ArgumentException, Wav2Vec2 120s timeout) are pre-existing and unrelated to this loss change.
• Full CI sweep

Closes #1400. Also closes the PointTransformerV3 portion of #1314 (one of cluster-6's listed failures).

🤖 Generated with Claude Code

Summary by CodeRabbit

• Bug Fixes / Improvements
  • Many models now default to a logits-compatible cross-entropy loss for more stable and consistent classification/segmentation training.
  • Speech recognition models now use a sequence-aware loss and refined training defaults for improved ASR training behavior.
  • Training runtime now tolerates lazily-initialized parameters to avoid buffer-related failures for large or on-demand models.
  • Attention paths avoid unnecessary allocations when auxiliary losses are disabled, reducing memory and overhead.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

2 Skipped Deployments

Project	Deployment	Actions	Updated (UTC)
aidotnet_website	Ignored	Preview	May 20, 2026 2:42pm
aidotnet-playground-api	Ignored	Preview	May 20, 2026 2:42pm

[coderabbitai]

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• ▶️ Resume reviews
• 🔍 Trigger review

Walkthrough

Replaces many constructors’ default CrossEntropyLoss<T> with CrossEntropyWithLogitsLoss<T>, updates LossFunctionFactory comments and XML docs, adds lazy-parameter handling in NeuralNetworkBase.TrainWithTape, and conditions MultiHeadAttentionLayer head-output caching.

Changes

Cross-entropy logits migration

Layer / File(s)	Summary
Global constructor and factory loss swap src/...	Replaced constructor/base initializer fallbacks and internal _lossFunction defaults from CrossEntropyLoss<T> to CrossEntropyWithLogitsLoss<T> (binary BCE-with-logits used when appropriate). Updated LossFunctionFactory comments and related XML docs.
NeuralNetworkBase: parameter-buffer lazy handling src/NeuralNetworks/NeuralNetworkBase.cs	Detects lazy/unallocated trainable parameters during parameter-buffer creation, skips temporary buffer for steps with lazy params, and memoizes skip decisions only for large models.
MultiHeadAttention caching change src/NeuralNetworks/Layers/MultiHeadAttentionLayer.cs	Only populates per-head _lastHeadOutputs when UseAuxiliaryLoss is enabled; otherwise sets _lastHeadOutputs = null to avoid needless allocations.
Wav2Vec2 CTCLoss special-case src/Audio/SpeechRecognition/Wav2Vec2Model.cs	Switches Wav2Vec2 model to use CTCLoss<T> by default (ONNX and native paths) instead of cross-entropy; also passes explicit Adam lr default and calls TrainWithTape with the model optimizer.
Test scaffold generator update src/AiDotNet.Generators/TestScaffoldGenerator.cs	Generator now emits token-ID 1D InputShape for LayoutLM-family models instead of image-shaped inputs.
Comments and docs src/FitnessCalculators/*, src/NeuralNetworks/Tasks/Graph/*, src/Training/Factories/LossFunctionFactory.cs	Adds explanatory comments clarifying softmax vs logits contracts and preserves historical probability-input CrossEntropyLoss mapping in the factory.

Estimated code review effort: 🎯 4 (Complex) | ⏱️ ~45 minutes

Possibly related PRs:

• ooples/AiDotNet#1102: TrainWithTape and parameter-buffer/view handling changes overlap with NeuralNetworkBase edits.
• ooples/AiDotNet#1188: Related cross-entropy semantics and logits/probability handling.
• ooples/AiDotNet#870: Overlap on segmentation model structure and wiring.

Suggested labels: feature

"Defaults swapped to logits, a subtle code ballet,
Buffers learn to wait while heads skip needless play.
Factory keeps history, constructors now align,
Tests and scaffolds updated — merge when checks shine.
🎉🛠️"

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch fix/issue-1400-segmentation-loss-with-logits

[coderabbitai]

Actionable comments posted: 25

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (43)

src/ComputerVision/Segmentation/Foundation/EoMT.cs (1)

122-144: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Refresh constructor docs for the new default loss behavior.

Line 122 still documents CrossEntropyLoss as default, while Line 143 now uses CrossEntropyWithLogitsLoss<T>(). Please update the XML comment.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Foundation/EoMT.cs` around lines 122 - 144,
Update the XML doc for the EoMT constructor to reflect the new default loss:
change the <param name="lossFunction"> description to indicate the default is
CrossEntropyWithLogitsLoss<T> (or "Cross-entropy with logits") instead of
CrossEntropyLoss; reference the EoMT constructor and the instantiated default
CrossEntropyWithLogitsLoss<T>() in the comment so the doc matches the actual
default used in the constructor.

src/ComputerVision/Segmentation/Foundation/Mask2Former.cs (1)

128-154: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Constructor docs are stale after logits-loss migration.

Line 128 still documents default CrossEntropyLoss, but Line 153 now defaults to CrossEntropyWithLogitsLoss<T>(). Please update the XML docs (including the explanatory note on default loss composition).

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Foundation/Mask2Former.cs` around lines 128 -
154, Update the XML doc for the Mask2Former constructor to reflect the new
default loss (CrossEntropyWithLogitsLoss<T>()) by changing the <param
name="lossFunction"> description to mention CrossEntropyWithLogitsLoss as the
default and adjust the explanatory remark to note that the original paper used a
combination of CE + binary cross-entropy + dice loss with Hungarian matching
(retain that historical note). Edit the XML text near the Mask2Former
constructor signature and any <remarks> that reference the default loss so they
match the actual code which calls new CrossEntropyWithLogitsLoss<T>().

src/ComputerVision/Segmentation/Efficient/MobileSAM.cs (1)

94-109: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix stale XML docs for default loss.

Line 94 documents CrossEntropyLoss as default, but Line 108 now uses CrossEntropyWithLogitsLoss<T>(). Please update the XML comment to match runtime behavior.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Efficient/MobileSAM.cs` around lines 94 -
109, The XML doc for the MobileSAM constructor incorrectly states the default
loss is "CrossEntropyLoss" but the constructor actually uses
CrossEntropyWithLogitsLoss<T>(); update the <param name="lossFunction"> text to
mention CrossEntropyWithLogitsLoss<T>() (or "CrossEntropyWithLogitsLoss") as the
default so the documentation matches the MobileSAM(NeuralNetworkArchitecture<T>,
...) constructor and the runtime behavior that constructs new
CrossEntropyWithLogitsLoss<T>().

src/ComputerVision/Segmentation/Foundation/MaskDINO.cs (1)

124-147: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update XML docs to reflect CrossEntropyWithLogitsLoss default.

Line 124 says default CrossEntropyLoss, but Line 146 now sets CrossEntropyWithLogitsLoss<T>() when lossFunction is null. Please align the docs.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Foundation/MaskDINO.cs` around lines 124 -
147, Update the XML doc for the MaskDINO constructor to state that the default
loss is CrossEntropyWithLogitsLoss (not CrossEntropyLoss): modify the <param
name="lossFunction"> text to mention CrossEntropyWithLogitsLoss and, if helpful,
note it's instantiated when lossFunction is null in the MaskDINO(...)
constructor which uses new CrossEntropyWithLogitsLoss<T>().

src/ComputerVision/Segmentation/Efficient/FastSAM.cs (1)

94-109: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update constructor XML docs to match the new default loss.

Line 94 still says the default is CrossEntropyLoss, but Line 108 now defaults to CrossEntropyWithLogitsLoss<T>(). Please align the docs to avoid incorrect usage guidance.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Efficient/FastSAM.cs` around lines 94 - 109,
The XML doc for the FastSAM constructor incorrectly states the default loss is
CrossEntropyLoss; update the <param name="lossFunction"> text to state the
default is CrossEntropyWithLogitsLoss<T>() (matching the constructor call that
uses new CrossEntropyWithLogitsLoss<T>()), so the FastSAM constructor
documentation and the actual default behavior are consistent.

src/ComputerVision/Segmentation/Efficient/SlimSAM.cs (1)

97-112: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update stale loss-function XML documentation.

Line 97 indicates default CrossEntropyLoss, but Line 111 now defaults to CrossEntropyWithLogitsLoss<T>(). Please sync docs with implementation.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Efficient/SlimSAM.cs` around lines 97 - 112,
The XML doc for the SlimSAM constructor is out of sync: update the <param
name="lossFunction"> text to reflect that the actual default is
CrossEntropyWithLogitsLoss<T>() (not CrossEntropyLoss); modify the comment on
the SlimSAM(NeuralNetworkArchitecture<T> architecture,
IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
ILossFunction<T>? lossFunction = null, ...) constructor to mention
CrossEntropyWithLogitsLoss<T>() as the default so the documentation matches the
implementation.

src/ComputerVision/Segmentation/Efficient/PIDNet.cs (1)

101-117: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Align XML docs with the new logits-based default.

Line 101 says default CrossEntropyLoss, but Line 116 now defaults to CrossEntropyWithLogitsLoss<T>(). Please update the parameter documentation.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Efficient/PIDNet.cs` around lines 101 - 117,
The XML doc for the PIDNet constructor is out of sync: the lossFunction param
says "CrossEntropyLoss" but the constructor default is
CrossEntropyWithLogitsLoss<T>(); update the <param name="lossFunction"> text to
indicate the default is CrossEntropyWithLogitsLoss (logits-based) and, if
useful, note that it expects raw logits rather than probabilities so callers use
matching logits-producing activation; refer to the PIDNet constructor signature
and CrossEntropyWithLogitsLoss<T> to locate and change the docstring
accordingly.

src/ComputerVision/Segmentation/Efficient/RepViTSAM.cs (1)

94-109: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Correct the documented default loss in constructor comments.

Line 94 still states CrossEntropyLoss as default, but Line 108 uses CrossEntropyWithLogitsLoss<T>(). Please update the XML docs.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Efficient/RepViTSAM.cs` around lines 94 -
109, Update the XML documentation for the RepViTSAM constructor to reflect the
actual default loss used: change the <param name="lossFunction"> description
from "CrossEntropyLoss" to "CrossEntropyWithLogitsLoss" (or
"CrossEntropyWithLogitsLoss<T>()") so it matches the constructor implementation
that uses new CrossEntropyWithLogitsLoss<T>() in
RepViTSAM(NeuralNetworkArchitecture<T> architecture, ...).

src/ComputerVision/Segmentation/InstanceSegmentation/YOLO11Seg.cs (1)

101-101: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Constructor XML docs are out of sync with the new default loss.

Line 101 still advertises CrossEntropyLoss, but Line 116 and Line 148 now default to CrossEntropyWithLogitsLoss<T>.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 116-116, 148-148

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/InstanceSegmentation/YOLO11Seg.cs` at line
101, The XML doc for the parameter "lossFunction" is stale: update the <param
name="lossFunction"> text in the YOLO11Seg constructor docs to reflect the new
default (CrossEntropyWithLogitsLoss<T>) instead of CrossEntropyLoss, and make
the same change for the other constructor overloads/comments that reference the
default loss (the constructor(s) around the other occurrences of YOLO11Seg);
ensure all "lossFunction" XML param comments consistently state
CrossEntropyWithLogitsLoss<T> as the default.

src/ComputerVision/Segmentation/Interactive/SegGPT.cs (1)

100-100: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update the lossFunction XML comment to reflect the new default.

Line 100 documents CrossEntropyLoss, but Line 115 and Line 147 now pass CrossEntropyWithLogitsLoss<T>.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 115-115, 147-147

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Interactive/SegGPT.cs` at line 100, The XML
doc for the parameter lossFunction in SegGPT.cs still states "CrossEntropyLoss"
as the default but the method/constructor now uses
CrossEntropyWithLogitsLoss<T>; update the <param name="lossFunction"> comment to
indicate the correct default (CrossEntropyWithLogitsLoss<T>) and ensure the
description matches the generic type usage and behavior wherever lossFunction is
documented (references in the SegGPT class/method signatures that accept
lossFunction).

src/ComputerVision/Segmentation/Interactive/SEEM.cs (1)

101-101: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Constructor documentation is stale after the loss swap.

Line 101 still points to CrossEntropyLoss, but Line 116 and Line 148 now default to CrossEntropyWithLogitsLoss<T>.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 116-116, 148-148

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Interactive/SEEM.cs` at line 101, The XML doc
for the SEEM constructor is stale: it still references CrossEntropyLoss for the
lossFunction parameter but the implementation and defaults use
CrossEntropyWithLogitsLoss<T>; update the <param name="lossFunction">
description to indicate CrossEntropyWithLogitsLoss<T> (or
"CrossEntropyWithLogitsLoss<T> by default") and make the same replacement in the
other constructor/overload docs that mention CrossEntropyLoss (lines around the
constructors referenced by SEEM and any overloads that default to
CrossEntropyWithLogitsLoss<T>) so the documentation matches the actual default
and types used at construction.

src/ComputerVision/Segmentation/Foundation/XDecoder.cs (1)

126-126: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update XML docs to match the new default loss.

Line 126 still documents CrossEntropyLoss, but Line 148 and Line 198 now default to CrossEntropyWithLogitsLoss<T>. Please sync the constructor docs with the implementation.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 148-148, 198-198

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Foundation/XDecoder.cs` at line 126, The XML
doc for the constructor parameter lossFunction is out-of-date (mentions
CrossEntropyLoss) — update all constructor/parameter XML comments in XDecoder
(references to the lossFunction parameter in the XDecoder constructor(s)) to
state the new default CrossEntropyWithLogitsLoss<T> instead of CrossEntropyLoss;
make the wording consistent at the occurrences around the documented lines
(previously 126, 148, 198) so the <param name="lossFunction"> text and any
summary remarks reflect the new default.

src/ComputerVision/Segmentation/InstanceSegmentation/YOLO26Seg.cs (1)

101-101: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Please update stale loss-default documentation.

Line 101 documents CrossEntropyLoss, but the constructors now default to CrossEntropyWithLogitsLoss<T> (Line 116 and Line 148).

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 116-116, 148-148

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/InstanceSegmentation/YOLO26Seg.cs` at line
101, The XML documentation for the lossFunction parameter in class YOLO26Seg is
stale (says CrossEntropyLoss) but the constructors for YOLO26Seg default to
CrossEntropyWithLogitsLoss<T>; update the <param name="lossFunction"> text to
state CrossEntropyWithLogitsLoss<T> as the default, and check and update any
other doc comments on the YOLO26Seg constructors (the overloads that set the
default loss) to reference CrossEntropyWithLogitsLoss<T> so the docs match the
actual defaults used in the YOLO26Seg constructors.

src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv8Seg.cs (1)

100-100: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Loss default in docs no longer matches constructor behavior.

Line 100 says CrossEntropyLoss, but Line 113 and Line 148 now default to CrossEntropyWithLogitsLoss<T>.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss; paper uses CIoU + DFL + BCE).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss; paper uses CIoU + DFL + BCE).</param>

Also applies to: 113-113, 148-148

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv8Seg.cs` at line
100, The XML doc for the parameter lossFunction is out of sync: it states
"CrossEntropyLoss" while the constructors for YOLOv8Seg default to
CrossEntropyWithLogitsLoss<T>; update the <param name="lossFunction"> text to
accurately state the actual default (CrossEntropyWithLogitsLoss<T>) or, if you
intended the old default, change the YOLOv8Seg constructor overloads that set
lossFunction to use CrossEntropyLoss instead; locate the lossFunction param doc
and the YOLOv8Seg constructors that instantiate CrossEntropyWithLogitsLoss<T>
and make the doc and implementation consistent.

src/ComputerVision/Segmentation/Mamba/VMamba.cs (1)

99-99: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix constructor docs to match CrossEntropyWithLogitsLoss<T> default.

Line 99 still says CrossEntropyLoss, while Line 114 and Line 146 now default to CrossEntropyWithLogitsLoss<T>.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 114-114, 146-146

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Mamba/VMamba.cs` at line 99, The XML docs for
the VMamba constructor incorrectly state the default loss as CrossEntropyLoss;
update the <param name="lossFunction"> description to indicate the actual
default type CrossEntropyWithLogitsLoss<T> (matching the constructor overloads
and defaults used in VMamba), and also update any other constructor parameter
docs referencing CrossEntropyLoss to CrossEntropyWithLogitsLoss<T> so all
mentions of the default lossFunction are consistent with the implementation.

src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv9Seg.cs (1)

105-105: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Sync constructor docs with the logits-loss migration.

Line 105 still states CrossEntropyLoss as default, but Line 121 and Line 153 now instantiate CrossEntropyWithLogitsLoss<T>.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 121-121, 153-153

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/InstanceSegmentation/YOLOv9Seg.cs` at line
105, The XML doc for the constructor parameter lossFunction is out of sync: it
still says "CrossEntropyLoss" but the code instantiates
CrossEntropyWithLogitsLoss<T> in the constructors (see YOLOv9Seg class and the
constructors that create CrossEntropyWithLogitsLoss<T> at the instantiation
sites). Update the <param name="lossFunction"> XML documentation to state the
correct default type CrossEntropyWithLogitsLoss<T> (and adjust any wording to
mention logits-compatible loss) so the docs match the actual defaults used in
the YOLOv9Seg constructors.

src/ComputerVision/Segmentation/Panoptic/CUPS.cs (1)

97-111: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update constructor docs to reflect logits-based default.

Line 97 says CrossEntropyLoss default, but Line 111 now uses CrossEntropyWithLogitsLoss.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Panoptic/CUPS.cs` around lines 97 - 111,
Update the XML doc for the CUPS constructor to correctly state the default loss
is logits-based CrossEntropyWithLogitsLoss (not CrossEntropyLoss); edit the
<param name="lossFunction"> description and any related remarks to mention
CrossEntropyWithLogitsLoss<T> (logits expected) so it matches the actual
constructor invocation that uses new CrossEntropyWithLogitsLoss<T>().

src/ComputerVision/Segmentation/OpenVocabulary/OpenVocabSAM.cs (1)

100-114: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update stale XML default-loss documentation.

Line 100 still says the default is CrossEntropyLoss, but Line 114 now defaults to CrossEntropyWithLogitsLoss. Please sync the XML docs with runtime behavior.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/OpenVocabulary/OpenVocabSAM.cs` around lines
100 - 114, The XML doc for the OpenVocabSAM constructor incorrectly states the
default loss as CrossEntropyLoss while the constructor uses
CrossEntropyWithLogitsLoss<T>; update the <param name="lossFunction"> summary to
reflect CrossEntropyWithLogitsLoss<T> as the default (or phrase it generically
as "CrossEntropyWithLogitsLoss by default") so the XML <param> for lossFunction
matches the actual behavior in the OpenVocabSAM(...) constructor.

src/ComputerVision/Segmentation/PointCloud/Concerto.cs (1)

98-113: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update default-loss XML docs for accuracy.

Line 98 still references CrossEntropyLoss, while Line 113 now uses CrossEntropyWithLogitsLoss by default.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/PointCloud/Concerto.cs` around lines 98 -
113, The XML doc for the Concerto constructor incorrectly names the default loss
as "CrossEntropyLoss" while the constructor uses CrossEntropyWithLogitsLoss<T>;
update the <param name="lossFunction"> summary to state the correct default
(CrossEntropyWithLogitsLoss) and optionally note it is used when lossFunction is
null; edit the docblock above the Concerto(NeuralNetworkArchitecture<T>
architecture, ...) constructor to reference CrossEntropyWithLogitsLoss<T> (and
adjust wording to match the type name used in the code).

src/ComputerVision/Segmentation/Panoptic/ODISE.cs (1)

100-115: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Sync XML docs with constructor default-loss change.

Line 100 still says CrossEntropyLoss, but Line 115 now defaults to CrossEntropyWithLogitsLoss.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Panoptic/ODISE.cs` around lines 100 - 115,
The XML documentation for the ODISE constructor is out of sync: the <param
name="lossFunction"> description still mentions "CrossEntropyLoss" but the
constructor default uses "CrossEntropyWithLogitsLoss". Update the <param
name="lossFunction"> XML summary to state the correct default
("CrossEntropyWithLogitsLoss") and optionally mention it is used when
lossFunction is null; ensure the change is made next to the
ODISE(NeuralNetworkArchitecture<T> architecture, IGradientBasedOptimizer<T,...>
constructor signature so the docs match the implemented default.

src/ComputerVision/Segmentation/Panoptic/KMaXDeepLab.cs (1)

99-114: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Correct stale XML default-loss value.

Line 99 documents CrossEntropyLoss as default, but Line 114 now defaults to CrossEntropyWithLogitsLoss.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Panoptic/KMaXDeepLab.cs` around lines 99 -
114, The XML doc for the KMaXDeepLab constructor incorrectly states the default
loss as CrossEntropyLoss; update the <param name="lossFunction"> text to reflect
the actual default used in the constructor (CrossEntropyWithLogitsLoss<T>), e.g.
change the documented default to "CrossEntropyWithLogitsLoss" or match the
generic form "CrossEntropyWithLogitsLoss<T>()" so the XML for the
KMaXDeepLab(NeuralNetworkArchitecture<T> architecture,
IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>? optimizer = null,
ILossFunction<T>? lossFunction = null, ...) constructor accurately describes the
runtime default.

src/ComputerVision/Segmentation/PointCloud/Sonata.cs (1)

97-112: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix stale XML loss default in constructor docs.

Line 97 says default CrossEntropyLoss, but Line 112 now defaults to CrossEntropyWithLogitsLoss.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/PointCloud/Sonata.cs` around lines 97 - 112,
Update the XML doc for the Sonata constructor to reflect the actual default loss
implementation: change the <param name="lossFunction"> description to reference
CrossEntropyWithLogitsLoss (not CrossEntropyLoss) so it matches the constructor
signature that uses new CrossEntropyWithLogitsLoss<T>(); ensure the text
mentions the correct type name (CrossEntropyWithLogitsLoss) and optionally that
it is used when lossFunction is null in the Sonata(NeuralNetworkArchitecture<T>
architecture, ...) constructor.

src/ComputerVision/Segmentation/OpenVocabulary/SAN.cs (1)

98-112: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Align XML docs with new default loss.

Line 98 still documents CrossEntropyLoss as default, but Line 112 now uses CrossEntropyWithLogitsLoss.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/OpenVocabulary/SAN.cs` around lines 98 - 112,
Update the XML documentation for the SAN constructor to reflect the new default
loss class: change the <param name="lossFunction"> description from
"CrossEntropyLoss" to "CrossEntropyWithLogitsLoss" (or otherwise describe that
the default is CrossEntropyWithLogitsLoss<T>), ensuring the text matches the
actual default used in the constructor where CrossEntropyWithLogitsLoss<T>() is
instantiated; update any related summary/remarks that mention the old default so
SAN(NeuralNetworkArchitecture<T> architecture, IGradientBasedOptimizer<T,
Tensor<T>, Tensor<T>>? optimizer = null, ILossFunction<T>? lossFunction = null,
...) documentation is accurate.

src/ComputerVision/Segmentation/OpenVocabulary/SED.cs (1)

98-112: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix stale default-loss doc string.

Line 98 still advertises CrossEntropyLoss, but Line 112 now defaults to CrossEntropyWithLogitsLoss.

Suggested fix

-    /// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/OpenVocabulary/SED.cs` around lines 98 - 112,
The XML doc for the SED constructor incorrectly documents the default loss as
CrossEntropyLoss while the code default is CrossEntropyWithLogitsLoss; update
the <param name="lossFunction"> summary to state the actual default
(CrossEntropyWithLogitsLoss) and ensure any <remarks> or other doc text
referencing the old loss is corrected; locate the
SED(NeuralNetworkArchitecture<T> architecture, IGradientBasedOptimizer<T,
Tensor<T>, Tensor<T>>? optimizer = null, ILossFunction<T>? lossFunction = null,
...) constructor and change the documentation to reference
CrossEntropyWithLogitsLoss<T> as the default.

src/ComputerVision/Segmentation/Referring/GLaMM.cs (1)

101-116: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update XML docs to match the new default loss type.

lossFunction is still documented as defaulting to CrossEntropyLoss, but constructor behavior now defaults to CrossEntropyWithLogitsLoss<T>().

📝 Suggested doc fix

-/// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+/// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 145-149

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Referring/GLaMM.cs` around lines 101 - 116,
The XML doc for the GLaMM constructor incorrectly states lossFunction defaults
to CrossEntropyLoss; update the <param name="lossFunction"> text to reflect the
actual default (CrossEntropyWithLogitsLoss<T>), and make the same change for the
duplicate docs around lines 145-149; reference the
GLaMM(NeuralNetworkArchitecture<T> architecture,
IGradientBasedOptimizer<T,...>?) constructor and the
CrossEntropyWithLogitsLoss<T>() default used in the constructor body when
editing the documentation.

src/ComputerVision/Segmentation/Semantic/InternImage.cs (1)

125-147: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update constructor XML docs to the new logits-based default.

The docs still describe CrossEntropyLoss as default, but fallback behavior now uses CrossEntropyWithLogitsLoss<T>().

📝 Suggested doc fix

-/// <param name="lossFunction">The loss function (default: CrossEntropyLoss for multi-class segmentation).</param>
+/// <param name="lossFunction">The loss function (default: CrossEntropyWithLogitsLoss for multi-class segmentation logits).</param>

Also applies to: 182-189

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Semantic/InternImage.cs` around lines 125 -
147, Update the XML doc comment for the InternImage constructor to state that
the default loss is now CrossEntropyWithLogitsLoss<T>() (logits-based) instead
of CrossEntropyLoss; locate the constructor overload described by the
InternImage(...) signature and change the <param name="lossFunction">
description and any other mentions in the constructor docs (also update the
second doc block that mirrors this behavior) to explicitly say
"CrossEntropyWithLogitsLoss (logits-based)" and reflect that the fallback uses
CrossEntropyWithLogitsLoss<T>().

src/ComputerVision/Segmentation/Semantic/DiffSeg.cs (1)

110-129: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Align XML docs with constructor behavior.

The lossFunction doc still says CrossEntropyLoss, but this now defaults to CrossEntropyWithLogitsLoss<T>().

📝 Suggested doc fix

-/// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+/// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 163-169

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Semantic/DiffSeg.cs` around lines 110 - 129,
The XML doc for the DiffSeg constructor incorrectly states the default loss is
CrossEntropyLoss; update the <param name="lossFunction"> description to
reference CrossEntropyWithLogitsLoss<T>() as the default to match the
constructor implementation (see the DiffSeg(...) constructor and its base(...)
call that uses new CrossEntropyWithLogitsLoss<T>()); make the same change for
the other affected constructor overload/docs mentioned around the 163-169 region
so all XML comments match the actual default behavior.

src/ComputerVision/Segmentation/Semantic/DiffCut.cs (1)

113-132: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix stale XML default-loss documentation.

lossFunction is still documented as CrossEntropyLoss, but the constructor now defaults to CrossEntropyWithLogitsLoss<T>().

📝 Suggested doc fix

-/// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+/// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 166-172

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Semantic/DiffCut.cs` around lines 113 - 132,
Update the XML doc for the DiffCut constructor to reflect the actual default
loss type: change the documented default for the lossFunction parameter from
"CrossEntropyLoss" to "CrossEntropyWithLogitsLoss<T>()" (matches the constructor
signature where lossFunction ?? new CrossEntropyWithLogitsLoss<T>() is used);
also update the similar documentation block referenced around the second
occurrence (the other constructor overload or overloaded docs between lines
~166-172) so both parameter docs consistently state
CrossEntropyWithLogitsLoss<T>() as the default.

src/ComputerVision/Segmentation/Referring/LISA.cs (1)

99-114: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update XML docs to reflect CrossEntropyWithLogitsLoss default.

The constructor docs still say CrossEntropyLoss as default, but the code now defaults to CrossEntropyWithLogitsLoss<T>().

📝 Suggested doc fix

-/// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+/// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 143-147

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Referring/LISA.cs` around lines 99 - 114,
Update the XML documentation for the LISA constructor(s) to reflect the actual
default loss implementation: change the <param name="lossFunction"> text from
"CrossEntropyLoss" to "CrossEntropyWithLogitsLoss" (for generic type T) so it
matches the code that uses new CrossEntropyWithLogitsLoss<T>(); update any other
constructor XML comments in the same file that mention the old default (e.g.,
the other LISA constructor overload around the later docs block) to the same
"CrossEntropyWithLogitsLoss" wording so all docstrings match the implementation.

src/ComputerVision/Segmentation/Referring/PixelLM.cs (1)

98-113: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Constructor docs still advertise the old default loss.

Please update the lossFunction XML param text to match the new CrossEntropyWithLogitsLoss<T>() default.

📝 Suggested doc fix

-/// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+/// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 142-146

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Referring/PixelLM.cs` around lines 98 - 113,
Update the XML documentation for the PixelLM constructor(s) to reflect the new
default loss: replace the <param name="lossFunction"> text that currently says
"CrossEntropyLoss" with "CrossEntropyWithLogitsLoss<T>()" (e.g., the constructor
PixelLM(NeuralNetworkArchitecture<T> architecture, IGradientBasedOptimizer<T,
Tensor<T>, Tensor<T>>? optimizer = null, ILossFunction<T>? lossFunction = null,
...) and any other PixelLM constructor overloads that mention the old default).
Ensure the param summary exactly names CrossEntropyWithLogitsLoss<T>() as the
default loss to match the implementation.

src/ComputerVision/Segmentation/Referring/VideoLISA.cs (1)

101-116: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update lossFunction XML default text.

The docs still state CrossEntropyLoss, but constructor fallback is now CrossEntropyWithLogitsLoss<T>().

📝 Suggested doc fix

-/// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+/// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 145-149

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Referring/VideoLISA.cs` around lines 101 -
116, The XML doc for the VideoLISA constructor incorrectly says the default loss
is CrossEntropyLoss; update the <param name="lossFunction"> text to state
CrossEntropyWithLogitsLoss<T>() as the default to match the actual fallback used
in the constructor (see VideoLISA(...) and the constructor call to new
CrossEntropyWithLogitsLoss<T>()); make the same update for the other
constructor/docblock later in the file that contains the analogous lossFunction
<param> description.

src/ComputerVision/Segmentation/Referring/OMGLLaVA.cs (1)

101-116: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Sync XML docs with the new constructor default.

lossFunction docs still mention CrossEntropyLoss, while runtime default is now CrossEntropyWithLogitsLoss<T>().

📝 Suggested doc fix

-/// <param name="lossFunction">Loss function (default: CrossEntropyLoss).</param>
+/// <param name="lossFunction">Loss function (default: CrossEntropyWithLogitsLoss).</param>

Also applies to: 145-149

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Referring/OMGLLaVA.cs` around lines 101 -
116, Update the XML documentation for the OMGLLaVA constructor to reflect the
new default loss (CrossEntropyWithLogitsLoss<T>), not CrossEntropyLoss, and make
the same edit for the other OMGLLaVA constructor overload where the docs still
mention CrossEntropyLoss; specifically change the <param name="lossFunction">
text to state that the default is CrossEntropyWithLogitsLoss<T>() (or equivalent
wording) so the docstring matches the actual runtime default used in the
OMGLLaVA(NeuralNetworkArchitecture<T>..., IGradientBasedOptimizer<T, Tensor<T>,
Tensor<T>>? optimizer = null, ILossFunction<T>? lossFunction = null, ...)
constructors.

src/ComputerVision/Segmentation/Semantic/SegFormer.cs (1)

149-150: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update XML docs to match the new default loss.

Line 150 still documents CrossEntropyLoss as the default, but Line 178 now defaults to CrossEntropyWithLogitsLoss<T>.

✏️ Suggested doc fix

-    /// (default: CrossEntropyLoss, the standard for multi-class segmentation tasks).</param>
+    /// (default: CrossEntropyWithLogitsLoss, the numerically stable choice for raw logits).</param>

Also applies to: 178-178

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Semantic/SegFormer.cs` around lines 149 -
150, The XML doc for the parameter lossFunction is out of date: it still says
the default is CrossEntropyLoss while the implementation now defaults to
CrossEntropyWithLogitsLoss<T>; update the <param name="lossFunction">
description in SegFormer.cs to state the correct default
(CrossEntropyWithLogitsLoss<T>) and briefly note it's the preferred default for
raw logits in multi-class segmentation (referencing the constructor/method that
sets this default and the type CrossEntropyWithLogitsLoss<T> to locate the
change).

src/ComputerVision/Segmentation/Semantic/ViTCoMer.cs (1)

123-123: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update docs for the new default loss.

Line 123 still lists CrossEntropyLoss as default, but Line 143 now defaults to CrossEntropyWithLogitsLoss<T>.

Also applies to: 143-143

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Semantic/ViTCoMer.cs` at line 123, The XML
doc for the parameter named lossFunction incorrectly states the default is
CrossEntropyLoss; update the <param name="lossFunction"> summary to reflect the
new default CrossEntropyWithLogitsLoss<T> (or its proper generic/type name used
in the code) wherever it appears in ViTCoMer.cs (the method/constructor that
declares lossFunction and the duplicated doc comment near the other occurrence).
Ensure the wording matches the exact type name used in code (including generic
angle brackets) and remove or replace the old CrossEntropyLoss text.

src/ComputerVision/Segmentation/Semantic/ViTAdapter.cs (1)

124-124: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix stale loss default in XML docs.

Line 124 still advertises CrossEntropyLoss, while Line 145 defaults to CrossEntropyWithLogitsLoss<T>.

Also applies to: 145-145

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Semantic/ViTAdapter.cs` at line 124, The XML
doc for the parameter "lossFunction" in ViTAdapter.cs is stale (mentions
CrossEntropyLoss) — update the <param name="lossFunction"> tag to state the
actual default used (CrossEntropyWithLogitsLoss<T>) and ensure any other XML
docs in the ViTAdapter class that reference the loss default (e.g.,
constructor/initializer docs around the lossFunction parameter) are changed to
match CrossEntropyWithLogitsLoss<T> so the documentation reflects the real
default.

src/ComputerVision/Segmentation/Semantic/SegNeXt.cs (1)

146-147: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Constructor docs are out of sync with the new loss default.

Line 147 still says CrossEntropyLoss, but Line 175 now defaults to CrossEntropyWithLogitsLoss<T>.

Also applies to: 175-175

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Semantic/SegNeXt.cs` around lines 146 - 147,
The XML doc for the constructor parameter lossFunction is out of sync: update
the <param name="lossFunction"> text in the Semantic SegNeXt constructor to
reflect the new default CrossEntropyWithLogitsLoss<T> (instead of
CrossEntropyLoss) and briefly describe that it combines logits + cross-entropy
for numerical stability; also search the same file for any other occurrences of
"CrossEntropyLoss" in constructor/class docs (e.g., the Semantic SegNeXt
constructor and related remarks) and change them to mention
CrossEntropyWithLogitsLoss<T> so the documentation matches the default used in
the constructor implementation.

src/ComputerVision/Segmentation/Video/UniVS.cs (1)

101-101: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update XML docs for the new default loss.

Line 101 still says CrossEntropyLoss, but Line 116 now defaults to CrossEntropyWithLogitsLoss<T>.

Also applies to: 116-116

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Video/UniVS.cs` at line 101, Update the XML
documentation for the 'lossFunction' parameter in UniVS to reflect the new
default: change the text that currently says "CrossEntropyLoss" to
"CrossEntropyWithLogitsLoss<T>" (or equivalent wording indicating
CrossEntropyWithLogitsLoss<T> is the default) so the param doc matches the
actual default used in the constructor/method where 'lossFunction' is defined.

src/ComputerVision/Segmentation/Video/DEVA.cs (1)

101-101: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Constructor docs no longer match the code default.

Line 101 says CrossEntropyLoss by default, but Line 116 now defaults to CrossEntropyWithLogitsLoss<T>.

Also applies to: 116-116

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ComputerVision/Segmentation/Video/DEVA.cs` at line 101, The XML doc for
the DEVA constructor is out of sync: the <param name="lossFunction"> comment
says the default is CrossEntropyLoss but the constructor actually defaults to
CrossEntropyWithLogitsLoss<T>; update the <param name="lossFunction">
documentation on the DEVA constructor to state the correct default
(CrossEntropyWithLogitsLoss<T>) or remove the explicit default mention so it
can't drift from the actual default in the DEVA(...) constructor signature.

src/Document/DocumentNeuralNetworkBase.cs (1)

136-142: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Update constructor XML docs to match the new default loss.

Line 136 says null defaults to CrossEntropyLoss, but Line 142 now defaults to CrossEntropyWithLogitsLoss<T>(). Please sync the XML comment to avoid misleading API docs.

Suggested fix

-    /// <param name="lossFunction">The loss function to use. If null, CrossEntropyLoss is used.</param>
+    /// <param name="lossFunction">The loss function to use. If null, CrossEntropyWithLogitsLoss is used.</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/Document/DocumentNeuralNetworkBase.cs` around lines 136 - 142, The XML
doc for the DocumentNeuralNetworkBase constructor is outdated: update the <param
name="lossFunction"> description to state that null now defaults to
CrossEntropyWithLogitsLoss<T>() instead of CrossEntropyLoss; locate the
constructor DocumentNeuralNetworkBase(NeuralNetworkArchitecture<T>,
ILossFunction<T>? lossFunction = null, double maxGradNorm = 1.0) and change the
comment for the lossFunction parameter to reference
CrossEntropyWithLogitsLoss<T>() for clarity and correct API docs.

src/ProgramSynthesis/Engines/CodeBERT.cs (1)

139-141: ⚠️ Potential issue | 🔴 Critical | ⚡ Quick win

BLOCKING: Empty Train method is a stub/placeholder.

The Train method has an empty body, which violates production readiness requirements. Every method must have a complete, production-ready implementation. An empty training method means the model cannot actually learn from data.

Production-ready code should either:

1. Implement actual training logic using the optimizer and loss function
2. Throw NotSupportedException with a clear message if training is intentionally unsupported
3. Delegate to a base class implementation if one exists

🛠️ Suggested fix

 public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
 {
+    SetTrainingMode(true);
+    try
+    {
+        TrainWithTape(input, expectedOutput, _optimizer);
+    }
+    finally
+    {
+        SetTrainingMode(false);
+    }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ProgramSynthesis/Engines/CodeBERT.cs` around lines 139 - 141, The
Train(Tensor<T> input, Tensor<T> expectedOutput) method in class CodeBERT is
currently an empty stub; either implement training logic using the model's
optimizer and loss function (compute forward pass, compute loss, backpropagate
gradients, apply optimizer step, and update model parameters) inside Train, or
if training is intentionally unsupported throw a NotSupportedException with a
clear message (e.g. "CodeBERT does not support on-device training; use
pre-trained weights or training pipeline"). If a base class provides a training
implementation, delegate by calling base.Train(input, expectedOutput). Locate
the Train method in CodeBERT and apply one of these fixes consistently with the
surrounding optimizer/loss naming and error handling conventions.

src/ProgramSynthesis/Engines/CodeT5.cs (1)

148-150: ⚠️ Potential issue | 🔴 Critical | ⚡ Quick win

BLOCKING: Empty Train method is a stub/placeholder.

The Train method body is empty, making the model unable to learn. This is a production readiness violation.

🛠️ Suggested fix

 public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
 {
+    SetTrainingMode(true);
+    try
+    {
+        TrainWithTape(input, expectedOutput, _optimizer);
+    }
+    finally
+    {
+        SetTrainingMode(false);
+    }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ProgramSynthesis/Engines/CodeT5.cs` around lines 148 - 150, The Train
method in CodeT5.cs is a stub and must perform a full training step: implement
CodeT5.Train(Tensor<T> input, Tensor<T> expectedOutput) to run a forward pass
(call the model's Forward/Infer method), compute the loss (use existing
ComputeLoss/LossFunction), run backpropagation (call Backward or compute
gradients), and apply parameter updates via the optimizer (call
Optimizer.Step()/UpdateParameters()); ensure gradients are zeroed/reset before
the step and any loss/metric logging is preserved. Use the existing class
members (e.g., Forward, ComputeLoss, Backward, Optimizer) within the CodeT5
class to locate and wire these calls so the model actually learns instead of
leaving Train empty.

src/ProgramSynthesis/Engines/GraphCodeBERT.cs (1)

143-145: ⚠️ Potential issue | 🔴 Critical | ⚡ Quick win

BLOCKING: Empty Train method is a stub/placeholder.

Same issue as CodeBERT and CodeT5 - the training method is non-functional.

🛠️ Suggested fix

 public override void Train(Tensor<T> input, Tensor<T> expectedOutput)
 {
+    SetTrainingMode(true);
+    try
+    {
+        TrainWithTape(input, expectedOutput, _optimizer);
+    }
+    finally
+    {
+        SetTrainingMode(false);
+    }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/ProgramSynthesis/Engines/GraphCodeBERT.cs` around lines 143 - 145, The
Train method in GraphCodeBERT (Train(Tensor<T> input, Tensor<T> expectedOutput))
is an empty stub and must either implement the model training loop consistent
with CodeBERT/CodeT5 or explicitly disallow training; add a concrete
implementation that validates inputs, runs a forward pass (call the class's
Forward/Encode methods), computes loss (call or implement
ComputeLoss/LossFunction), performs backprop and an optimizer step (use the
existing Optimizer/UpdateParameters utilities), and updates training metrics, or
if this engine doesn't support training, throw a clear NotImplementedException
with a comment explaining train is unsupported; ensure you reference
GraphCodeBERT's existing forward, loss, and optimizer helpers when wiring this
up.

src/Video/ActionRecognition/VideoMAE.cs (1)

154-175: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Fix stale XML default-loss documentation.

The constructor docs still say the default is CrossEntropyLoss, but behavior now defaults to CrossEntropyWithLogitsLoss.

Suggested doc fix

-    /// <param name="lossFunction">Optional loss function (default: CrossEntropyLoss).</param>
+    /// <param name="lossFunction">Optional loss function (default: CrossEntropyWithLogitsLoss).</param>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/Video/ActionRecognition/VideoMAE.cs` around lines 154 - 175, Update the
XML doc for the VideoMAE constructor to reflect the actual default loss
implementation: change the <param name="lossFunction"> description from
"Optional loss function (default: CrossEntropyLoss)." to indicate the current
default is CrossEntropyWithLogitsLoss (e.g., "Optional loss function (default:
CrossEntropyWithLogitsLoss)."); ensure the remark references the VideoMAE
constructor and the symbol CrossEntropyWithLogitsLoss<T> so readers correctly
understand the runtime default used in the constructor implementation.

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

[coderabbitai]

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/ComputerVision/Segmentation/Foundation/SAM.cs`:
- Around line 131-133: Update the XML documentation for the SAM constructors to
reflect the new default loss selection: instead of saying the default is
CrossEntropyLoss, document that if numClasses == 1 the constructor defaults to
BinaryCrossEntropyWithLogitsLoss<T> and otherwise defaults to
CrossEntropyWithLogitsLoss<T>; apply this change to the XML doc comments for the
primary constructor (the one calling base(architecture, lossFunction ?? ...))
and the overloaded constructor(s) around the second occurrence (the other
constructor block referenced at lines 174-176) so the summary/param remarks
accurately describe the conditional default behavior.

In `@src/ComputerVision/Segmentation/Video/DEVA.cs`:
- Around line 116-118: Update the XML summary/remarks for the DEVA
constructor(s) to document the new conditional default loss: when numClasses ==
1 the constructor defaults to BinaryCrossEntropyWithLogitsLoss<T>, otherwise it
defaults to CrossEntropyWithLogitsLoss<T>; locate the XML docs for the DEVA
constructor(s) that call base(architecture, lossFunction ?? (numClasses == 1 ?
(ILossFunction<T>)new BinaryCrossEntropyWithLogitsLoss<T>() : new
CrossEntropyWithLogitsLoss<T>)) and modify the text accordingly (also update the
second overload's XML docs that mirror this behavior).

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 4c8e73e4-316b-489d-8461-1b1abdcd3bbe

📥 Commits

Reviewing files that changed from the base of the PR and between caba691 and 9a23118.

📒 Files selected for processing (26)

• src/Audio/SpeechRecognition/Wav2Vec2Model.cs
• src/Classification/Ensemble/AdaBoostClassifier.cs
• src/ComputerVision/Segmentation/Foundation/SAM.cs
• src/ComputerVision/Segmentation/Mamba/ViMUNet.cs
• src/ComputerVision/Segmentation/Mamba/VisionMamba.cs
• src/ComputerVision/Segmentation/Medical/BiomedParse.cs
• src/ComputerVision/Segmentation/Medical/MedNeXt.cs
• src/ComputerVision/Segmentation/Medical/MedSAM.cs
• src/ComputerVision/Segmentation/Medical/MedSAM2.cs
• src/ComputerVision/Segmentation/Medical/MedSegDiffV2.cs
• src/ComputerVision/Segmentation/Medical/NnUNet.cs
• src/ComputerVision/Segmentation/Medical/SegMamba.cs
• src/ComputerVision/Segmentation/Medical/SwinUNETR.cs
• src/ComputerVision/Segmentation/Medical/TransUNet.cs
• src/ComputerVision/Segmentation/Medical/UMamba.cs
• src/ComputerVision/Segmentation/Medical/UniverSeg.cs
• src/ComputerVision/Segmentation/OpenVocabulary/CATSeg.cs
• src/ComputerVision/Segmentation/OpenVocabulary/GroundedSAM2.cs
• src/ComputerVision/Segmentation/OpenVocabulary/MaskAdapter.cs
• src/ComputerVision/Segmentation/Video/DEVA.cs
• src/Document/PixelToSequence/Donut.cs
• src/FitnessCalculators/CrossEntropyLossFitnessCalculator.cs
• src/NeuralNetworks/Layers/MultiHeadAttentionLayer.cs
• src/NeuralNetworks/Tasks/Graph/GraphClassificationModel.cs
• src/Training/Factories/LossFunctionFactory.cs
• src/Video/ActionRecognition/SlowFast.cs

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

[coderabbitai]

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/Audio/SpeechRecognition/Wav2Vec2Model.cs`:
- Around line 637-645: The cast using "as IGradientBasedOptimizer<T, Tensor<T>,
Tensor<T>>" can yield null and silently cause TrainWithTape to use a fallback
optimizer; change this to a safe check: explicitly test that _optimizer
implements IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>> (or perform a direct
cast) before calling TrainWithTape, and if it does not, throw a clear
ArgumentException/InvalidOperationException describing the mismatch so callers
cannot be silently downgraded; update the call site where TrainWithTape(input,
expectedOutput, _optimizer as IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>)
is invoked to perform this validation and pass a non-null optimizer instance.

In `@src/Document/LayoutAware/LayoutLM.cs`:
- Around line 525-543: The call to TrainWithTape casts _optimizer using "as
IGradientBasedOptimizer<T, Tensor<T>, Tensor<T>>" which can yield null and
silently ignore the caller's non-gradient optimizer; change this to validate the
optimizer before calling TrainWithTape: retrieve the castedOptimizer from
_optimizer, if it is null throw a clear exception (e.g., ArgumentException or
InvalidOperationException) stating that the provided _optimizer must implement
IGradientBasedOptimizer<T,Tensor<T>,Tensor<T>>; then pass castedOptimizer into
TrainWithTape (use the same TrainWithTape method name and _optimizer field to
locate the code).

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: e8268c7d-7c35-4584-aa71-2102d9812ffe

📥 Commits

Reviewing files that changed from the base of the PR and between 485a6cd and b9a98c8.

📒 Files selected for processing (3)

• src/AiDotNet.Generators/TestScaffoldGenerator.cs
• src/Audio/SpeechRecognition/Wav2Vec2Model.cs
• src/Document/LayoutAware/LayoutLM.cs

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.