Welcome to PyMDE Discussions!

[akshayka]

👋 Welcome!

We’re using Discussions as a place to connect with other members of our community. We hope that you:

• Ask questions.
• Share ideas.
• Engage constructively with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.

On this thread, feel free to introduce yourself, ask questions about PyMDE or embeddings more generally, or showcase embeddings you've made using PyMDE.

[JELAshford]

Hi there! I'm James (he/him) a PhD Student in Genetics/Machine Learning - and I've got to start with thank you, because I've used PyMDE a lot over the last few months on a bunch of personal projects and it's been a joy to use! ☺️

I'm working on a project at the moment where I have samples made from signals from wireless access points, and I also have some pair-wise distance measures between many of the samples. It would be really useful if I could use this distance information as a constraint (?) to arrange the items in a 3d embedding but I don't know how to bring this information into the process, or if this is something that PyMDE is the right tool for. Any advice would be much appreciated, thanks!

[akshayka]

Hey James! Great to meet you. Thanks for using PyMDE, I'm glad you've had fun using it.

I would recommend adding terms to the objective that penalizes embeddings in which the known distance relationships aren't preserved.

Concretely, say that you have a list of item pairs (edges), and for each pair in that list, you have a known original distance.

# you have associated original distances for pairs (0, 1), (0, 2), (1, 2), ...
edges = torch.tensor([
         [0, 1],
         [0, 2],
         [1, 2],
         ...
])

# one original distance for each pair in edges
original_distances = torch.tensor([10., 5., 3.4, ...])

If all you wanted to do was preserve these original distances (or "deviations", as we call them in the docs), as much as possible, you could then use a loss function set up to preserve these distances. For example

distortion_function = pymde.losses.Quadratic(original_distances)

mde = pymde.MDE(
  n_items=n_tiems,
  embedding_dim=3,
  edges=edges,
  distortion_function=distortion_function,
  constraint=pymde.Centered())

Different loss functions will lead to different behavior in the embedding. The docs don't really explain that yet, but our monograph does, in chapter 4.

If you have more opinions on what the embedding should look like, beyond the pairwise original distances, you can set up an entirely custom distortion function. It just needs to be a Python callable, mapping a torch.Tensor of embedding distances to distortions. See this section, as well as this one.

Hope that helps! Feel free to ask follow-up questions.

[JELAshford]

Hi Akshay,

Thanks very much for this, I feel like I understand what's going on under the bonnet a bit better know! Making the embedding this way worked great for the paired distances, and already recovered some individual paths through the data that I didn't know about, but I was wondering if this could be taken a step further.

In the pymde.MDE function, there isn't the same interface for 'data' as there is in pymde.preserve_distance. I can see from the docs that preserve_distances calculates the euclidian distances between the samples in 'data' as the distances (up to max_distances of them), and then uses these distances (and I assume corresponding edges, given that we can't provide edges in preserve_distance) for the MDE.

So, just to check my intuition, preserve_distances is taking the input data (which is originally in a different number of dimensions) and embedding it into the embedding_dim while keeping the distances between the edges it sampled the same (or as close to) the original euclidian distances. As far as I can tell from the docs, that's two discrete but intertwined processes: embedding, and minimising distortion.

If that's the case, is it possible to use the method you gave above to provide the distortion minimisation function and edges, but also do the embedding of my high-D data down to 3d using that function at the same time as well. I feel like I'm really close, but can't give the preserve_distances function a set of edges that my distances correspond to, or the MDE function the original high-D data so I'm stuck somewhere in the middle.

I hope that made sense - thanks!

[akshayka]

So, just to check my intuition, preserve_distances is taking the input data (which is originally in a different number of dimensions) and embedding it into the embedding_dim while keeping the distances between the edges it sampled the same (or as close to) the original euclidian distances.

That's mostly correct, except it doesn't actually do the embedding, it returns an MDE object that describes the embedding problem. You can call the object's embed method to produce the embedding.

As far as I can tell from the docs, that's two discrete but intertwined processes: embedding, and minimising distortion.

There are two processes, but I would say that embedding and minimizing distortion are just one process.

In my mind the two steps are:

(1) Pre-process the raw data to make an MDE problem. This requires coming up with the edges and distortion functions. preserve_distances and preserve_neighbors are two examples of how to pre-process the data.

(2) Gven the distortion functions, find an embedding that minimizes the distortion. This is encapsulated by the MDE.embed method.

I feel like I'm really close, but can't give the preserve_distances function a set of edges that my distances correspond to, or the MDE function the original high-D data so I'm stuck somewhere in the middle.

Glad to hear that you're close!

The idea is that you'd come up with your edges and distortion functions from the raw data, and then pass them to the MDE constructor (as well as a keyword argument embedding_dim=3). In particular the MDE class doesn't need to know anything about the original raw data.

As an example, check out the cells titled "Cycle Graph", "Star Graph", and "Tree" in this notebook: https://github.com/cvxgrp/pymde/blob/main/examples/drawing_graphs.ipynb

Notice that in those cells, the raw data is pre-processed to come up with edges and original distances, and these edges and distances are used to create an MDE problem (which is solved to find the embedding).

Hope this helps!!

[JELAshford]

Ah, I can see where I had my intuition off now! I'm using those examples to integrate the original distances and distances derived from the raw data to construct an MDE problem that fits my aims.

Thanks again for all your help, if I find something that looks good I'll make sure to post it here!