1. However, I don't fully understand the difference between the trunk and the embedded model. Do I get it right that I create the embeddings where fragments from the same papyri are close together, and fragments from another papyrus are far apart while using the embedder Model? Why do I need a trunk model, and what does that mean?

Separating the model into "trunk" and "embedder" components can be helpful conceptually (see discussion #270).

Other than that, there's nothing special about the two terms. The convention in this library is that embeddings = embedder(trunk(data)). You can make embedder do nothing, by setting it to torch.nn.Identity(). You can also make trunk do nothing. It's also fine to ignore these terms and encapsulate your entire model in model.

2. Do I get It to write that it was a mistake to use just the vanilla EfficientNet without replacing the last layer and changing it to the desired embedding size (output of the last EfficientNet layer)?

Usually the last layer of these pretrained models is for classification, so before training you should replace the last layer with torch.nn.Identity() or a torch.nn.Linear that outputs the size of embedding that you want.

3. I would like to evaluate the images while patching them into equally sized parts (e.g., using transforms.FiveCrop). Is it possible to use the tester in combination with an adapted collate_fn and adapted data_label_getter?

Good question. Yes you can provide a custom collate_fn when you call tester.test.

As for the data_and_label_getter, you can see how that's used in compute_all_embeddings

If you're thinking of taking the 5 crops and computing the average embedding, then you might want to write a custom tester and modify get_embeddings_for_eval.

For example, something like:

from pytorch_metric_learning.testers import GlobalEmbeddingSpaceTester
from pytorch_metric_learning.utils import common_functions as c_f

class CustomTester(GlobalEmbeddingSpaceTester):
    def get_embeddings_for_eval(self, trunk_model, embedder_model, input_imgs):
        input_imgs = c_f.to_device(
            input_imgs, device=self.data_device, dtype=self.dtype
        )
        # from https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.FiveCrop
        bs, ncrops, c, h, w = input_imgs.size()
        result = embedder(trunk(input_imgs.view(-1, c, h, w))) # fuse batch size and ncrops
        result_avg = result.view(bs, ncrops, -1).mean(1) # avg over crops
        return result_avg 

I would also be very thankful if you could suggest literature, tutorials, or similar.

I found this related work: https://hal.archives-ouvertes.fr/hal-03260782/document