fix: revert float literal changes in ir.Function and subgraph contexts

Python float/int literals passed to onnxscript ops become initializers
in the root graph. This breaks in two contexts:

1. ir.Function bodies: functions cannot reference outer-scope
   initializers (unlike subgraphs which can). Affected:
   - linear_attention.py (scale in LinearAttention function)
   - packed_multi_head_attention.py (bias in function body)
   - causal_conv.py (axis/width in CausalConvWithState function)

2. Component code that may run in subgraph or function contexts:
   - minimax.py (_scaled_add in MoE expert dispatch)
   - granitemoehybrid.py (residual multiplier in MoE+Mamba layers)
   - _mamba_block.py (conv bias, time_step_min in Scan body)
   - _gated_deltanet.py (conv bias)

Reverts these files to use op.Constant(value_float=...) which creates
inline Constant nodes that live in whatever graph context they are
built in.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Signed-off-by: G Ramalingam <grama@microsoft.com>

Author: gramalingam

src/mobius/components/_gated_deltanet.py

@@ -80,7 +80,7 @@ def forward(
         # Zero bias — model has no conv bias; the function requires it.
         # CastLike ensures the bias matches the weight dtype (e.g. f16).
         conv_bias = op.Expand(
-            op.CastLike(0.0, self.weight),
+            op.CastLike(op.Constant(value_float=0.0), self.weight),
             op.Constant(value_ints=[self._channels]),
         )
         return op.CausalConvWithState(

src/mobius/components/_mamba_block.py

@@ -216,7 +216,7 @@ def forward(
         else:
             # Zero bias — the function requires a bias input.
             conv_bias = op.Expand(
-                op.CastLike(0.0, self.weight),
+                op.CastLike(op.Constant(value_float=0.0), self.weight),
                 op.Constant(value_ints=[self._channels]),
             )
         return op.CausalConvWithState(
@@ -393,7 +393,7 @@ def forward(
         # dt = softplus(dt_raw + dt_bias): (B, T, num_heads)
         dt = op.Softplus(op.Add(dt_raw_f32, dt_bias_f32))
         if self.time_step_min > 0.0:
-            dt = op.Clip(dt, self.time_step_min)
+            dt = op.Clip(dt, op.Constant(value_float=self.time_step_min))
 
         # decay = A * dt in log-space: g_t where exp(g_t) is the decay
         # A = -exp(A_log), so decay = -exp(A_log) * dt

src/mobius/functions/causal_conv.py

@@ -113,8 +113,8 @@ def causal_conv_nd_with_state(
     conv_input = op.Concat(conv_state_val, input_val, axis=temporal_axis)
 
     # Step 2: Extract new carry state — last K-1 positions of conv_input.
-    total_len = op.Gather(op.Shape(conv_input), temporal_axis, axis=0)
-    state_start = op.Sub(total_len, state_width)
+    total_len = op.Gather(op.Shape(conv_input), op.Constant(value_int=temporal_axis), axis=0)
+    state_start = op.Sub(total_len, op.Constant(value_int=state_width))
     present_state = op.Slice(
         conv_input,
         op.Reshape(state_start, op.Constant(value_ints=[1])),

src/mobius/functions/linear_attention.py

@@ -189,7 +189,7 @@ def linear_attention(
     # CastLike ensures scale constant matches the input dtype.
     scaled_query = op.Mul(
         query_expanded,
-        op.CastLike(scale, query_expanded),
+        op.CastLike(op.Constant(value_float=scale), query_expanded),
     )
 
     # --- Build Scan for sequential recurrence ---

src/mobius/functions/packed_multi_head_attention.py

@@ -121,11 +121,10 @@ def packed_multi_head_attention() -> ir.Function:
     same_segment = op.Equal(segment_ids_row, segment_ids_column)  # (N, N)
 
     # Convert to attention bias: 0 for same segment, -10000 for different
-    # CastLike before Where so only the scalar is cast (cheaper than post-broadcast)
     attention_bias = op.Where(
         same_segment,
-        op.CastLike(0.0, query_input),
-        op.CastLike(-10000.0, query_input),
+        op.Constant(value_float=0.0),
+        op.Constant(value_float=-10000.0),
     )
     # Reshape for Attention: (1, 1, N, N)
     attention_bias = op.Unsqueeze(attention_bias, [0, 1])

src/mobius/models/granitemoehybrid.py

@@ -120,7 +120,7 @@ def forward(
             op, hidden_states, conv_state, ssm_state
         )
         # residual + output * residual_multiplier
-        rm = op.CastLike(self._residual_multiplier, mamba_out)
+        rm = op.CastLike(op.Constant(value_float=self._residual_multiplier), mamba_out)
         hidden_states = op.Add(residual, op.Mul(mamba_out, rm))
 
         # MoE + shared-MLP path with pre-norm
@@ -131,7 +131,7 @@ def forward(
             self.block_sparse_moe(op, hidden_states),
             self.shared_mlp(op, hidden_states),
         )
-        rm = op.CastLike(self._residual_multiplier, hidden_states)
+        rm = op.CastLike(op.Constant(value_float=self._residual_multiplier), hidden_states)
         hidden_states = op.Add(residual, op.Mul(hidden_states, rm))
 
         return hidden_states, (new_conv_state, new_ssm_state)
@@ -189,7 +189,7 @@ def forward(
             position_embeddings=None,  # NoPE: skip rotary embedding application
             past_key_value=past_key_value,
         )
-        rm = op.CastLike(self._residual_multiplier, attn_out)
+        rm = op.CastLike(op.Constant(value_float=self._residual_multiplier), attn_out)
         hidden_states = op.Add(residual, op.Mul(attn_out, rm))
 
         # MoE + shared-MLP path with pre-norm
@@ -199,7 +199,7 @@ def forward(
             self.block_sparse_moe(op, hidden_states),
             self.shared_mlp(op, hidden_states),
         )
-        rm = op.CastLike(self._residual_multiplier, hidden_states)
+        rm = op.CastLike(op.Constant(value_float=self._residual_multiplier), hidden_states)
         hidden_states = op.Add(residual, op.Mul(hidden_states, rm))
 
         return hidden_states, present_kv

src/mobius/models/minimax.py

@@ -223,11 +223,11 @@ def _scaled_add(
     if math.isclose(alpha, 1.0) and math.isclose(beta, 1.0):
         return op.Add(residual, sub_layer_out)
     scaled_res = op.Mul(
-        op.CastLike(alpha, residual),
+        op.CastLike(op.Constant(value_float=alpha), residual),
         residual,
     )
     scaled_out = op.Mul(
-        op.CastLike(beta, sub_layer_out),
+        op.CastLike(op.Constant(value_float=beta), sub_layer_out),
         sub_layer_out,
     )
     return op.Add(scaled_res, scaled_out)