This section details on the original issue you should resolve

<issue_title>emb fclass</issue_title>
<issue_description>Implement first-class node and edge embedding support in py3plex as a core ML primitive integrated with the builder/DSL architecture.

Goals:

Embeddings must work naturally with multilayer networks.

API must integrate with existing DSL (Q), pipelines, and graph_ops.

Backend should support scalable implementations (NumPy/JAX/PyTorch optional).

Embeddings must be reusable across downstream tasks (link prediction, clustering, classification).

Design and implement the following components.

Create a new module:

py3plex/ml/embedding/

Submodules:

base.py
node2vec.py
deepwalk.py
netmf.py
line.py
metapath2vec.py
multiplex.py
trainer.py
utils.py

Define a base embedding interface.

File: base.py

Requirements:

class BaseEmbedding:
name: str

def fit(self, network):
    pass

def transform(self, nodes=None):
    pass

def fit_transform(self, network):
    pass

def get_embedding(self, node):
    pass

def to_pandas(self):
    pass

def to_numpy(self):
    pass

All embedding models must inherit from this base.

Add a unified embedding entry point on the network object.

Extend multi_layer_network with:

net.embed(
method="node2vec",
dimensions=128,
walk_length=40,
num_walks=10,
context_size=10,
workers=4
)

Return object:

EmbeddingResult

Implement EmbeddingResult.

Capabilities:

embedding.vectors
embedding.nodes
embedding.dimension

embedding[node_id]

embedding.to_pandas()
embedding.to_numpy()
embedding.to_arrow()

embedding.similarity(node_a, node_b)
embedding.knn(node, k=10)

Storage:

dict[(node_id, layer)] -> vector

Support multiplex nodes.

Implement Node2Vec.

File: node2vec.py

Features:

biased random walks

parameters p, q

skipgram training

negative sampling

support multiplex networks

Interface:

Node2VecEmbedding(
dimensions=128,
walk_length=80,
num_walks=10,
p=1.0,
q=1.0,
window_size=10,
negative_samples=5,
)

Steps:

1. generate random walks

2. build training corpus

3. train skipgram

4. produce embeddings

Implement DeepWalk.

File: deepwalk.py

Same interface as Node2Vec but without bias parameters.

Implement NetMF.

File: netmf.py

Requirements:

spectral approximation of DeepWalk

use sparse matrices

truncated SVD

Interface:

NetMFEmbedding(
dimensions=128,
window=10,
negative=1,
)

Implement LINE.

File: line.py

Support:

order=1
order=2

Optimization:

negative sampling

stochastic gradient descent

Implement MetaPath2Vec for multiplex networks.

File: metapath2vec.py

Features:

meta-path guided random walks

layer-aware walks

Example metapath:

["author","paper","venue","paper","author"]

Interface:

MetaPath2VecEmbedding(
metapaths=[...],
dimensions=128,
walk_length=40
)

Implement multiplex-aware embeddings.

File: multiplex.py

Add:

MultiplexNode2Vec
SupraAdjacencyEmbedding
LayerRegularizedEmbedding

Capabilities:

cross-layer transitions

layer weighting

inter-layer edge handling

Random walk must support:

(node, layer)

states.

Implement embedding trainer.

File: trainer.py

Responsibilities:

random walk generation

negative sampling

batching

parallelization

APIs:

generate_walks(network)
train_skipgram(walks)
optimize_embeddings()

Allow backend selection:

backend="numpy"
backend="jax"
backend="torch"

Add DSL integration.

Extend Q builder.

Example:

result = (
Q.nodes()
.embed("node2vec", dim=128)
.execute(net)
)

Output:

QueryResult with embedding vectors

Columns:

node
layer
embedding

Add graph_ops integration.

Example:

nodes(net)
.embed(method="node2vec", dim=64)
.mutate(cluster=lambda x: kmeans(x["embedding"]))

Embedding must appear as column:

embedding

Add pipeline step.

File:

py3plex/pipeline/steps/embedding.py

Step:

NodeEmbedding(
method="node2vec",
dimensions=128
)

Usage:

Pipeline([
("embed", NodeEmbedding(method="node2vec")),
("cluster", NodeClustering())
])

Add similarity utilities.

File:

similarity.py

Functions:

cosine_similarity
euclidean_distance
dot_similarity

Add methods:

embedding.similarity(a,b)
embedding.most_similar(node,k=10)

Add clustering helpers.

embedding.cluster(method="kmeans", k=10)
embedding.cluster(method="spectral")

Return:

node -> cluster_id

Add persistence.

EmbeddingResult must support:

embedding.save("embeddings.parquet")
embedding.load("embeddings.parquet")

Formats:

parquet
arrow
numpy

Add evaluation utilities.

File:

evaluation.py

Functions:

evaluate_link_prediction()
evaluate_node_classification()
evaluate_clustering()

Metrics:

ROC-AUC
F1
NMI
ARI

Performance requirements.

random walk generation parallelized

sparse matrix operations

avoid dense adjacency matrices

s...