Keyword args are not passed to backend if same backend string is reused

[co9olguy]

Putting this here because it is something I uncovered while debugging a user's code in the SF slack channel. I'm not sure what the intended behaviour that we want here is.

I will give example for "fock" backend, but also applies to "tf" backend (actually it's an engine issue).

If a user does, for example, eng.run("fock", cutoff_dim=N), then later does this again, but with a different value for the kwarg cutoff_dim, then the cutoff_dim used by the backend actually does not change.

This is because (currently) the engine checks on the second run whether the desired backend type is the same. If it is, it avoids reinitializing a backend. As a consequence, any kwargs are not passed on to the backend itself.

Code example:

import strawberryfields as sf

eng, q = sf.Engine(num_subsystems=1)

state = eng.run('fock', cutoff_dim=2, eval=False).ket()
print('shape:',state.shape) # >> shape: (2,)

state = eng.run('fock', cutoff_dim=3, eval=False).ket()
print('shape:',state.shape) # >> shape: (2,)

[josh146]

This is definitely confusing and should be fixed to match what the user expects.

Perhaps a simple solution would be a logic modification, so that if any passed keyword arguments (in this case, cutoff_dim) don't match the corresponding backend properties, the backend is reinitialized?

At the moment, this should only affect the Fock and TF backends with the cutoff_dim kwarg, but it would be nice if we could implement a solution that automatically checks all provided kwargs against the backend properties.

[co9olguy]

Yeah, that's what I was thinking

[microwavestine]

from engine.py run function

      elif isinstance(backend, str):
            # if backend is specified via a string and the engine already has that type of backend
            # loaded, then we should just use the existing backend
            # pylint: disable=protected-access
            if self.backend is not None and self.backend._short_name == backend and self.backend.circuit._trunc == kwargs.get('cutoff_dim'):
                pass
            else:
            # initialize backend

(added self.backend.circuit._trunc == kwargs.get('cutoff_dim') to the if statement)

I'm not sure about checking against backend part, I just guessed self.backend.circuit._trunc would return cutoff_dim based on the code below from floc backend code:

    def get_cutoff_dim(self):
        """Returns the Hilbert space cutoff dimension used.
        Returns:
            int: cutoff dimension
        """
        return self.circuit._trunc

I took a slightly different approach by adding more stricter condition i.e on what condition backend should not be initialised. I'm not familiar with the codebase so I won't be making a pull request, but hope this might inspire some ideas for better solutions.

[co9olguy]

Thanks for the suggestion @0xckylee

[smite]

This issue was fixed by #80