Feature request - MerlinProcessor support for multiple sessions

[smaugdela]

Feature Request:
MerlinProcessor supporting multi-sessions flow.

Proposed solution:
MerlinProcessor accepting multiple sessions as parameter. It would allow batching logic; maybe even direct comparison of different topologies on the same task.

Additional context:
It improves upon recent changes made to the MerlinProcessor to accept a session object.

[ben9871]

Hello,
do you mind giving an example of when this would be used?

• i.e what options does this open up?
• what has been blocked by this? for this it would be good if there was a clear example case in mind for reference
• would the multi-sessions be using the same noise model for all or different noise models? ( different noise models may not be reasonable as these would behave differently i.e sim:ascella or sim:belenos deployment would not reflect the same conditions and batching according to this may not give rational results ). One route that would be practical would be to have multiple sessions of the same backend
• minimum example of what your API would look like

[ben9871]

Following our latest discussion, here is the phrase I would use to describe what you want:
'we do the forward pass of our model via MerlinProcessor,
the batch size of the forward pass is split up into multiple micro-batches.
If we send this microbatch to a GPU, there is already parallelisation and thus this notion is not pertinent until we reach large batch sizes.
i.e microbatching 120 into batches of 40 is pointless.
However, if we surpass the limits of 1 device in terms of parallelisation, we would want to shift to another
Thus if we had forward pass of 12k with microbatch 2.5k
we would use session 1 for chunk 1 --> datapoints 0-2.5k
we would use session 2 for chunk 2 --> datapoints 2.5k-5k
and so forth.......
Thus we would like to specify a session per microbatch. This raises the question of whether they should also have a variable batch size( I feel this may be too much for now ).

What would help us converge on a spec is if we make an exact phrase that captures what we are looking for. In this way we will naturally converge to the right solution.
Kind regards,
Benjamin

[vmscw]

Here a draft of MerLin / Pytorch snippet to invoke the usage of multiple sessions:

import os
import torch
import torch.nn as nn

# Session by provider 
import perceval.providers.scaleway as scw
import perceval.providers.genci as genci

from merlin.algorithms import QuantumLayer
from merlin.builder.circuit_builder import CircuitBuilder
from merlin.core.merlin_processor import MerlinProcessor
from merlin.measurement.strategies import MeasurementStrategy

### Session invokation can be done from multiple providers (Scaleway, GENCI, Quandela...) ###
with scw.Session(platform_name="belenos-scaleway", project_id=..., token=...) as session_1:
with genci.Session(platform_name="belenos-genci", token=...) as session_2:

    # Create the processor using the session and configuration parameters
    proc = MerlinProcessor(
        session=[session_1, session_2],
        microbatch_size=32,
        timeout=300.0,
    )

    # Build a simple circuit with 6 modes and 2 photons
    b = CircuitBuilder(n_modes=6)
    b.add_rotations(trainable=True, name="theta")
    b.add_angle_encoding(modes=[0, 1], name="px")
    b.add_entangling_layer()

    # Instantiate the quantum layer, pytorch module-compatible
    q_layer = QuantumLayer(
        input_size=2,
        builder=b,
        n_photons=2,
        measurement_strategy=MeasurementStrategy.probs(),  # Extract raw probability vector
    ).eval()

    # Combine with classical layers to make a full model
    model = nn.Sequential(
        nn.Linear(3, 2, bias=False),
        q_layer,
        nn.Linear(15, 4, bias=False),  # 15 = Combinations(6,2) from the chosen circuit
        nn.Softmax(dim=-1),
    ).eval()

    # Generate dummy data for inference
    X = torch.rand(8, 3)
    
    print("Sending hybrid model to Scaleway QaaS...")
    # Execute forward pass
    y = proc.forward(model, X, nsample=100)

print("Inference successful!")
print(f"Final output shape: {y.shape}")

[ben9871]

This is fine for me. Each session has batch size 32 and they are the basis for our remoteprocessors built from these. Mainly internal but very slight addition to API to make contract between device and 'microbatch' clearer for parallelisation and more controllable. I also don't think it will clash with development of merlinprocessor on our end for 0.4.
kind regards,
Benjamin