# torch_geometric.transforms¶

class Compose(transforms)[source]

Composes several transforms together.

Parameters: transforms (list of transform objects) – List of transforms to compose.
class Constant(value=1, cat=True)[source]

Adds a constant value to each node feature.

Parameters: value (int, optional) – The value to add. (default: 1) cat (bool, optional) – If set to False, all existing node features will be replaced. (default: True)
class Distance(norm=True, max_value=None, cat=True)[source]

Saves the Euclidean distance of linked nodes in its edge attributes.

Parameters: norm (bool, optional) – If set to False, the output will not be normalized to the interval $$[0, 1]$$. (default: True) max_value (float, optional) – If set and norm=True, normalization will be performed based on this value instead of the maximum value found in the data. (default: None) cat (bool, optional) – If set to False, all existing edge attributes will be replaced. (default: True)
class Cartesian(norm=True, max_value=None, cat=True)[source]

Saves the relative Cartesian coordinates of linked nodes in its edge attributes.

Parameters: norm (bool, optional) – If set to False, the output will not be normalized to the interval $${[0, 1]}^D$$. (default: True) max_value (float, optional) – If set and norm=True, normalization will be performed based on this value instead of the maximum value found in the data. (default: None) cat (bool, optional) – If set to False, all existing edge attributes will be replaced. (default: True)
class LocalCartesian(cat=True)[source]

Saves the relative Cartesian coordinates of linked nodes in its edge attributes. Each coordinate gets neighborhood-normalized to the interval $${[0, 1]}^D$$.

Parameters: cat (bool, optional) – If set to False, all existing edge attributes will be replaced. (default: True)
class Polar(norm=True, max_value=None, cat=True)[source]

Saves the polar coordinates of linked nodes in its edge attributes.

Parameters: norm (bool, optional) – If set to False, the output will not be normalized to the interval $${[0, 1]}^2$$. (default: True) max_value (float, optional) – If set and norm=True, normalization will be performed based on this value instead of the maximum value found in the data. (default: None) cat (bool, optional) – If set to False, all existing edge attributes will be replaced. (default: True)
class Spherical(norm=True, max_value=None, cat=True)[source]

Saves the spherical coordinates of linked nodes in its edge attributes.

Parameters: norm (bool, optional) – If set to False, the output will not be normalized to the interval $${[0, 1]}^3$$. (default: True) max_value (float, optional) – If set and norm=True, normalization will be performed based on this value instead of the maximum value found in the data. (default: None) cat (bool, optional) – If set to False, all existing edge attributes will be replaced. (default: True)
class PointPairFeatures(cat=True)[source]

Computes the rotation-invariant Point Pair Features

$\left( \| \mathbf{d_{j,i}} \|, \angle(\mathbf{n}_i, \mathbf{d_{j,i}}), \angle(\mathbf{n}_j, \mathbf{d_{j,i}}), \angle(\mathbf{n}_i, \mathbf{n}_j) \right)$

of linked nodes in its edge attributes, where $$\mathbf{d}_{j,i}$$ denotes the difference vector between, and $$\mathbf{n}_i$$ and $$\mathbf{n}_j$$ denote the surface normals of node $$i$$ and $$j$$ respectively.

Parameters: cat (bool, optional) – If set to False, all existing edge attributes will be replaced. (default: True)
class OneHotDegree(max_degree, in_degree=False, cat=True)[source]

Adds the node degree as one hot encodings to the node features.

Parameters: max_degree (int) – Maximum degree. in_degree (bool, optional) – If set to True, will compute the in-degree of nodes instead of the out-degree. (default: False) cat (bool, optional) – Concat node degrees to node features instead of replacing them. (default: True)
class TargetIndegree(norm=True, max_value=None, cat=True)[source]

Saves the globally normalized degree of target nodes

$\mathbf{u}(i,j) = \frac{\deg(j)}{\max_{v \in \mathcal{V}} \deg(v)}$

in its edge attributes.

Parameters: cat (bool, optional) – Concat pseudo-coordinates to edge attributes instead of replacing them. (default: True)
class LocalDegreeProfile[source]

Appends the Local Degree Profile (LDP) from the “A Simple yet Effective Baseline for Non-attribute Graph Classification” paper

$\mathbf{x}_i = \mathbf{x}_i \, \Vert \, (\deg(i), \min(DN(i)), \max(DN(i)), \textrm{mean}(DN(i)), \textrm{std}(DN(i)))$

to the node features, where $$DN(i) = \{ \deg(j) \mid j \in \mathcal{N}(i) \}$$.

class Center[source]

Centers node positions around the origin.

class NormalizeRotation(max_points=-1)[source]

Rotates all points so that the eigenvectors overlie the axes of the Cartesian coordinate system. If the data additionally holds normals saved in data.norm these will be also rotated.

Parameters: max_points (int, optional) – If set to a value greater than 0, only a random number of max_points points are sampled and used to compute eigenvectors. (default: -1)
class NormalizeScale[source]

Centers and normalizes node positions to the interval $$(-1, 1)$$.

class RandomTranslate(translate)[source]

Translates node positions by randomly sampled translation values within a given interval. In contrast to other random transformations, translation is applied separately at each position.

Parameters: translate (sequence or float or int) – Maximum translation in each dimension, defining the range $$(-\mathrm{translate}, +\mathrm{translate})$$ to sample from. If translate is a number instead of a sequence, the same range is used for each dimension.
class RandomFlip(axis, p=0.5)[source]

Flips node positions along a given axis randomly with a given probability.

Parameters: axis (int) – The axis along the position of nodes being flipped. p (float, optional) – Probability that node positions will be flipped. (default: 0.5)
class LinearTransformation(matrix)[source]

Transforms node positions with a square transformation matrix computed offline.

Parameters: matrix (Tensor) – tensor with shape $$[D, D]$$ where $$D$$ corresponds to the dimensionality of node positions.
class RandomScale(scales)[source]

Scales node positions by a randomly sampled factor $$s$$ within a given interval, e.g., resulting in the transformation matrix

$\begin{split}\begin{bmatrix} s & 0 & 0 \\ 0 & s & 0 \\ 0 & 0 & s \\ \end{bmatrix}\end{split}$

for three-dimensional positions.

Parameters: scales (tuple) – scaling factor interval, e.g. (a, b), then scale is randomly sampled from the range $$a \leq \mathrm{scale} \leq b$$.
class RandomRotate(degrees, axis=0)[source]

Rotates node positions around a specific axis by a randomly sampled factor within a given interval.

Parameters: degrees (tuple or float) – Rotation interval from which the rotation angle is sampled. If degrees is a number instead of a tuple, the interval is given by $$[-\mathrm{degrees}, \mathrm{degrees}]$$. axis (int, optional) – The rotation axis. (default: 0)
class RandomShear(shear)[source]

Shears node positions by randomly sampled factors $$s$$ within a given interval, e.g., resulting in the transformation matrix

$\begin{split}\begin{bmatrix} 1 & s_{xy} & s_{xz} \\ s_{yx} & 1 & s_{yz} \\ s_{zx} & z_{zy} & 1 \\ \end{bmatrix}\end{split}$

for three-dimensional positions.

Parameters: shear (float or int) – maximum shearing factor defining the range $$(-\mathrm{shear}, +\mathrm{shear})$$ to sample from.
class NormalizeFeatures[source]

Row-normalizes node features to sum-up to one.

class AddSelfLoops[source]

class RemoveIsolatedNodes[source]

Removes isolated nodes from the graph.

class KNNGraph(k=6, loop=False, force_undirected=False, flow='source_to_target')[source]

Creates a k-NN graph based on node positions pos.

Parameters: k (int, optional) – The number of neighbors. (default: 6) loop (bool, optional) – If True, the graph will contain self-loops. (default: False) force_undirected (bool, optional) – If set to True, new edges will be undirected. (default: False) flow (string, optional) – The flow direction when using in combination with message passing ("source_to_target" or "target_to_source"). (default: "source_to_target")
class RadiusGraph(r, loop=False, max_num_neighbors=32, flow='source_to_target')[source]

Creates edges based on node positions pos to all points within a given distance.

Parameters: r (float) – The distance. loop (bool, optional) – If True, the graph will contain self-loops. (default: False) max_num_neighbors (int, optional) – The maximum number of neighbors to return for each element in y. This flag is only needed for CUDA tensors. (default: 32) flow (string, optional) – The flow direction when using in combination with message passing ("source_to_target" or "target_to_source"). (default: "source_to_target")
class FaceToEdge(remove_faces=True)[source]

Converts mesh faces [3, num_faces] to edge indices [2, num_edges].

Parameters: remove_faces (bool, optional) – If set to False, the face tensor will not be removed.
class SamplePoints(num, remove_faces=True, include_normals=False)[source]

Uniformly samples num points on the mesh faces according to their face area.

Parameters: num (int) – The number of points to sample. remove_faces (bool, optional) – If set to False, the face tensor will not be removed. (default: True) include_normals (bool, optional) – If set to True, then compute normals for each sampled point. (default: False)
class FixedPoints(num)[source]

Samples a fixed number of num points and features from a point cloud.

Parameters: num (int) – The number of points to sample.
class ToDense(num_nodes=None)[source]

Converts a sparse adjacency matrix to a dense adjacency matrix with shape [num_nodes, num_nodes, *].

Parameters: num_nodes (int) – The number of nodes. If set to None, the number of nodes will get automatically inferred. (default: None)
class TwoHop[source]

Adds the two hop edges to the edge indices.

class LineGraph(force_directed=False)[source]

Converts a graph to its corresponding line-graph:

\begin{align}\begin{aligned}L(\mathcal{G}) &= (\mathcal{V}^{\prime}, \mathcal{E}^{\prime})\\\mathcal{V}^{\prime} &= \mathcal{E}\\\mathcal{E}^{\prime} &= \{ (e_1, e_2) : e_1 \cap e_2 \neq \emptyset \}\end{aligned}\end{align}

Line-graph node indices are equal to indices in the original graph’s coalesced edge_index. For undirected graphs, the maximum line-graph node index is (data.edge_index.size(1) // 2) - 1.

New node features are given by old edge attributes. For undirected graphs, edge attributes for reciprocal edges (row, col) and (col, row) get summed together.

Parameters: force_directed (bool, optional) – If set to True, the graph will be always treated as a directed graph. (default: False)
class LaplacianLambdaMax(normalization=None, is_undirected=False)[source]

Computes the highest eigenvalue of the graph Laplacian given by torch_geometric.utils.get_laplacian().

Parameters: normalization (str, optional) – The normalization scheme for the graph Laplacian (default: None): 1. None: No normalization $$\mathbf{L} = \mathbf{D} - \mathbf{A}$$ 2. "sym": Symmetric normalization $$\mathbf{L} = \mathbf{I} - \mathbf{D}^{-1/2} \mathbf{A} \mathbf{D}^{-1/2}$$ 3. "rw": Random-walk normalization $$\mathbf{L} = \mathbf{I} - \mathbf{D}^{-1} \mathbf{A}$$ is_undirected (bool, optional) – If set to True, this transform expects undirected graphs as input, and can hence speed up the computation of the largest eigenvalue. (default: False)
class GenerateMeshNormals[source]

Generate normal vectors for each mesh node based on neighboring faces.

class Delaunay[source]

Computes the delaunay triangulation of a set of points.