code: def compute_flash_embeddings(
      samples,
      model,
      embeddings_field=None,
      batch_size=None,
      num_workers=None,
      transform_kwargs=None,
      trainer_kwargs=None,
  ):
      """Computes embeddings for the samples in the collection using the given
      :class:`Lightning Flash model <flash:flash.core.model.Task>`.
  
      This method only supports applying an
      :ref:`ImageEmbedder <flash:image_embedder>` to an image collection.
  
      If an ``embeddings_field`` is provided, the embeddings are saved to the
      samples; otherwise, the embeddings are returned in-memory.
  
      Args:
          samples: a :class:`fiftyone.core.collections.SampleCollection`
          model: a :class:`flash:flash.core.model.Task`
          embeddings_field (None): the name of a field in which to store the
              embeddings
          batch_size (None): an optional batch size to use. If not provided, a
              default batch size is used
          num_workers (None): the number of workers for the data loader to use
          transform_kwargs (None): an optional dict of transform kwargs to pass
              into the created data module used by some models
          trainer_kwargs (None): an optional dict of kwargs used to initialize the
              :mod:`Trainer <flash:flash.core.trainer>`. These can be used to,
              for example, configure the number of GPUs to use and other
              distributed inference parameters
  
      Returns:
          one of the following:
  
          -   ``None``, if an ``embeddings_field`` is provided
          -   a ``num_samples x num_dim`` array of embeddings, if
              ``embeddings_field`` is None
      """
      if not isinstance(model, _SUPPORTED_EMBEDDERS):
          raise ValueError(
              "Unsupported model type %s. Supported model types are %s"
              % (type(model), _SUPPORTED_EMBEDDERS)
          )
  
      if trainer_kwargs is None:
          trainer_kwargs = {}
  
      data_kwargs = {
          "num_workers": num_workers or 1,
          "batch_size": batch_size or 1,
      }
      if transform_kwargs:
          data_kwargs["transform_kwargs"] = transform_kwargs
  
      datamodule = fi.ImageClassificationData.from_fiftyone(
          predict_dataset=samples, **data_kwargs
      )
      embeddings = flash.Trainer(**trainer_kwargs).predict(
          model, datamodule=datamodule
      )
      embeddings = np.stack(sum(embeddings, []))
  
      if embeddings_field is not None:
          samples.set_values(embeddings_field, embeddings)
          return
  
      return embeddings
  
file_path: fiftyone/fiftyone/utils/flash.py
imports: import inspect
  import itertools
  import numpy
  import fiftyone.core.labels
  import fiftyone.core.utils
  import flash
  import flash.core.classification
  import flash.image
  import flash.image.detection.output
  import flash.image.segmentation.output
  import flash.video
label_desc: Use image node_id 4 for calling a global function with example usage: compute_flash_embeddings(samples, model, embeddings_field, batch_size, num_workers, transform_kwargs, trainer_kwargs) and returns: embeddings