graphical representation model

Introduction to Graph Machine Learning

We first study what graphs are, why they are used, and how best to represent them. We then cover briefly how people learn on graphs, from pre-neural methods (exploring graph features at the same time) to what are commonly called Graph Neural Networks. Lastly, we peek into the world of Transformers for graphs.

What is a graph?

In its essence, a graph is a description of items linked by relations.

Examples of graphs include social networks (Twitter, Mastodon, any citation networks linking papers and authors), molecules, knowledge graphs (such as UML diagrams, encyclopedias, and any website with hyperlinks between its pages), sentences expressed as their syntactic trees, any 3D mesh, and more! It is, therefore, not hyperbolic to say that graphs are everywhere.

The items of a graph (or network) are called its nodes (or vertices), and their connections its edges (or links). For example, in a social network, nodes are users and edges their connections; in a molecule, nodes are atoms and edges their molecular bond.

• A graph with either typed nodes or typed edges is called heterogeneous (example: citation networks with items that can be either papers or authors have typed nodes, and XML diagram where relations are typed have typed edges). It cannot be represented solely through its topology, it needs additional information. This post focuses on homogeneous graphs.
• A graph can also be directed (like a follower network, where A follows B does not imply B follows A) or undirected (like a molecule, where the relation between atoms goes both ways). Edges can connect different nodes or one node to itself (self-edges), but not all nodes need to be connected.

If you want to use your data, you must first consider its best characterisation (homogeneous/heterogeneous, directed/undirected, and so on).

What are graphs used for?

Let's look at a panel of possible tasks we can do on graphs.

At the graph level , the main tasks are:

• graph generation, used in drug discovery to generate new plausible molecules,
• graph evolution (given a graph, predict how it will evolve over time), used in physics to predict the evolution of systems
• graph level prediction (categorisation or regression tasks from graphs), such as predicting the toxicity of molecules.

At the node level , it's usually a node property prediction. For example, Alphafold uses node property prediction to predict the 3D coordinates of atoms given the overall graph of the molecule, and therefore predict how molecules get folded in 3D space, a hard bio-chemistry problem.

At the edge level , it's either edge property prediction or missing edge prediction. Edge property prediction helps drug side effect prediction predict adverse side effects given a pair of drugs. Missing edge prediction is used in recommendation systems to predict whether two nodes in a graph are related.

It is also possible to work at the sub-graph level on community detection or subgraph property prediction. Social networks use community detection to determine how people are connected. Subgraph property prediction can be found in itinerary systems (such as Google Maps ) to predict estimated times of arrival.

Working on these tasks can be done in two ways.

When you want to predict the evolution of a specific graph, you work in a transductive setting, where everything (training, validation, and testing) is done on the same single graph. If this is your setup, be careful! Creating train/eval/test datasets from a single graph is not trivial. However, a lot of the work is done using different graphs (separate train/eval/test splits), which is called an inductive setting.

How do we represent graphs?

The common ways to represent a graph to process and operate it are either:

• as the set of all its edges (possibly complemented with the set of all its nodes)
• or as the adjacency matrix between all its nodes. An adjacency matrix is a square matrix (of node size * node size) that indicates which nodes are directly connected to which others (where (A_{ij} = 1) if (n_i) and (n_j) are connected, else 0). Note: most graphs are not densely connected and therefore have sparse adjacency matrices, which can make computations harder.

However, though these representations seem familiar, do not be fooled!

Graphs are very different from typical objects used in ML because their topology is more complex than just "a sequence" (such as text and audio) or "an ordered grid" (images and videos, for example)): even if they can be represented as lists or matrices, their representation should not be considered an ordered object!

But what does this mean? If you have a sentence and shuffle its words, you create a new sentence. If you have an image and rearrange its columns, you create a new image.

This is not the case for a graph: if you shuffle its edge list or the columns of its adjacency matrix, it is still the same graph. (We explain this more formally a bit lower, look for permutation invariance).

Graph representations through ML

The usual process to work on graphs with machine learning is first to generate a meaningful representation for your items of interest (nodes, edges, or full graphs depending on your task), then to use these to train a predictor for your target task. We want (as in other modalities) to constrain the mathematical representations of your objects so that similar objects are mathematically close. However, this similarity is hard to define strictly in graph ML: for example, are two nodes more similar when they have the same labels or the same neighbours?

Note: In the following sections, we will focus on generating node representations. Once you have node-level representations, it is possible to obtain edge or graph-level information. For edge-level information, you can concatenate node pair representations or do a dot product. For graph-level information, it is possible to do a global pooling (average, sum, etc.) on the concatenated tensor of all the node-level representations. Still, it will smooth and lose information over the graph -- a recursive hierarchical pooling can make more sense, or add a virtual node, connected to all other nodes in the graph, and use its representation as the overall graph representation.

Pre-neural approaches

Simply using engineered features.

Before neural networks, graphs and their items of interest could be represented as combinations of features, in a task-specific fashion. Now, these features are still used for data augmentation and semi-supervised learning , though more complex feature generation methods exist; it can be essential to find how best to provide them to your network depending on your task.

Node-level features can give information about importance (how important is this node for the graph?) and/or structure based (what is the shape of the graph around the node?), and can be combined.

The node centrality measures the node importance in the graph. It can be computed recursively by summing the centrality of each node’s neighbours until convergence, or through shortest distance measures between nodes, for example. The node degree is the quantity of direct neighbours it has. The clustering coefficient measures how connected the node neighbours are. Graphlets degree vectors count how many different graphlets are rooted at a given node, where graphlets are all the mini graphs you can create with a given number of connected nodes (with three connected nodes, you can have a line with two edges, or a triangle with three edges).

Edge-level features complement the representation with more detailed information about the connectedness of the nodes, and include the shortest distance between two nodes, their common neighbours , and their Katz index (which is the number of possible walks of up to a certain length between two nodes - it can be computed directly from the adjacency matrix).

Graph level features contain high-level information about graph similarity and specificities. Total graphlet counts , though computationally expensive, provide information about the shape of sub-graphs. Kernel methods measure similarity between graphs through different "bag of nodes" methods (similar to bag of words).

Walk-based approaches

Walk-based approaches use the probability of visiting a node j from a node i on a random walk to define similarity metrics; these approaches combine both local and global information. Node2Vec , for example, simulates random walks between nodes of a graph, then processes these walks with a skip-gram, much like we would do with words in sentences , to compute embeddings. These approaches can also be used to accelerate computations of the Page Rank method , which assigns an importance score to each node (based on its connectivity to other nodes, evaluated as its frequency of visit by random walk, for example).

However, these methods have limits: they cannot obtain embeddings for new nodes, do not capture structural similarity between nodes finely, and cannot use added features.

Graph Neural Networks

Neural networks can generalise to unseen data. Given the representation constraints we evoked earlier, what should a good neural network be to work on graphs?

• Equation: f ( P ( G ) ) = f ( G ) f(P(G))=f(G) f ( P ( G )) = f ( G ) with f the network, P the permutation function, G the graph
• Explanation: the representation of a graph and its permutations should be the same after going through the network
• Equation: P ( f ( G ) ) = f ( P ( G ) ) P(f(G))=f(P(G)) P ( f ( G )) = f ( P ( G )) with f the network, P the permutation function, G the graph
• Explanation: permuting the nodes before passing them to the network should be equivalent to permuting their representations

Typical neural networks, such as RNNs or CNNs are not permutation invariant. A new architecture, the Graph Neural Network , was therefore introduced (initially as a state-based machine).

A GNN is made of successive layers. A GNN layer represents a node as the combination ( aggregation ) of the representations of its neighbours and itself from the previous layer ( message passing ), plus usually an activation to add some nonlinearity.

Comparison to other models : A CNN can be seen as a GNN with fixed neighbour sizes (through the sliding window) and ordering (it is not permutation equivariant). A Transformer without positional embeddings can be seen as a GNN on a fully-connected input graph.

Aggregation and message passing

There are many ways to aggregate messages from neighbour nodes, summing, averaging, for example. Some notable works following this idea include:

• Graph Convolutional Networks averages the normalised representation of the neighbours for a node (most GNNs are actually GCNs);
• Graph Attention Networks learn to weigh the different neighbours based on their importance (like transformers);
• GraphSAGE samples neighbours at different hops before aggregating their information in several steps with max pooling.
• Graph Isomorphism Networks aggregates representation by applying an MLP to the sum of the neighbours' node representations.

Choosing an aggregation : Some aggregation techniques (notably mean/max pooling) can encounter failure cases when creating representations which finely differentiate nodes with different neighbourhoods of similar nodes (ex: through mean pooling, a neighbourhood with 4 nodes, represented as 1,1,-1,-1, averaged as 0, is not going to be different from one with only 3 nodes represented as -1, 0, 1).

GNN shape and the over-smoothing problem

At each new layer, the node representation includes more and more nodes.

A node, through the first layer, is the aggregation of its direct neighbours. Through the second layer, it is still the aggregation of its direct neighbours, but this time, their representations include their own neighbours (from the first layer). After n layers, the representation of all nodes becomes an aggregation of all their neighbours at distance n, therefore, of the full graph if its diameter is smaller than n!

If your network has too many layers, there is a risk that each node becomes an aggregation of the full graph (and that node representations converge to the same one for all nodes). This is called the oversmoothing problem

This can be solved by :

• scaling the GNN to have a layer number small enough to not approximate each node as the whole network (by first analysing the graph diameter and shape)
• increasing the complexity of the layers
• adding non message passing layers to process the messages (such as simple MLPs)
• adding skip-connections.

The oversmoothing problem is an important area of study in graph ML, as it prevents GNNs to scale up, like Transformers have been shown to in other modalities.

Graph Transformers

A Transformer without its positional encoding layer is permutation invariant, and Transformers are known to scale well, so recently, people have started looking at adapting Transformers to graphs ( Survey) . Most methods focus on the best ways to represent graphs by looking for the best features and best ways to represent positional information and changing the attention to fit this new data.

Here are some interesting methods which got state-of-the-art results or close on one of the hardest available benchmarks as of writing, Stanford's Open Graph Benchmark :

• Graph Transformer for Graph-to-Sequence Learning (Cai and Lam, 2020) introduced a Graph Encoder, which represents nodes as a concatenation of their embeddings and positional embeddings, node relations as the shortest paths between them, and combine both in a relation-augmented self attention.
• Rethinking Graph Transformers with Spectral Attention (Kreuzer et al, 2021) introduced Spectral Attention Networks (SANs). These combine node features with learned positional encoding (computed from Laplacian eigenvectors/values), to use as keys and queries in the attention, with attention values being the edge features.
• GRPE: Relative Positional Encoding for Graph Transformer (Park et al, 2021) introduced the Graph Relative Positional Encoding Transformer. It represents a graph by combining a graph-level positional encoding with node information, edge level positional encoding with node information, and combining both in the attention.
• Global Self-Attention as a Replacement for Graph Convolution (Hussain et al, 2021) introduced the Edge Augmented Transformer. This architecture embeds nodes and edges separately, and aggregates them in a modified attention.
• Do Transformers Really Perform Badly for Graph Representation (Ying et al, 2021) introduces Microsoft's Graphormer , which won first place on the OGB when it came out. This architecture uses node features as query/key/values in the attention, and sums their representation with a combination of centrality, spatial, and edge encodings in the attention mechanism.

The most recent approach is Pure Transformers are Powerful Graph Learners (Kim et al, 2022), which introduced TokenGT . This method represents input graphs as a sequence of node and edge embeddings (augmented with orthonormal node identifiers and trainable type identifiers), with no positional embedding, and provides this sequence to Transformers as input. It is extremely simple, yet smart!

A bit different, Recipe for a General, Powerful, Scalable Graph Transformer (Rampášek et al, 2022) introduces, not a model, but a framework, called GraphGPS . It allows to combine message passing networks with linear (long range) transformers to create hybrid networks easily. This framework also contains several tools to compute positional and structural encodings (node, graph, edge level), feature augmentation, random walks, etc.

Using transformers for graphs is still very much a field in its infancy, but it looks promising, as it could alleviate several limitations of GNNs, such as scaling to larger/denser graphs, or increasing model size without oversmoothing.

Further resources

If you want to delve deeper, you can look at some of these courses:

• Stanford's Machine Learning with Graphs
• McGill's Graph Representation Learning
• Geometric Deep Learning course
• Graph Representation Learning*, Hamilton
• Graph Neural Networks Study Guide
• GraphML in 2023 summarizes plausible interesting directions for GraphML in 2023.

Nice libraries to work on graphs are PyGeometric or the Deep Graph Library (for graph ML) and NetworkX (to manipulate graphs more generally).

If you need quality benchmarks you can check out:

• OGB, the Open Graph Benchmark : the reference graph benchmark datasets, for different tasks and data scales.
• Benchmarking GNNs : Library and datasets to benchmark graph ML networks and their expressivity. The associated paper notably studies which datasets are relevant from a statistical standpoint, what graph properties they allow to evaluate, and which datasets should no longer be used as benchmarks.
• Long Range Graph Benchmark : recent (Nov2022) benchmark looking at long range graph information
• Taxonomy of Benchmarks in Graph Representation Learning : paper published at the 2022 Learning on Graphs conference, which analyses and sort existing benchmarks datasets

For more datasets, see:

• Paper with code Graph tasks Leaderboards : Leaderboard for public datasets and benchmarks - careful, not all the benchmarks on this leaderboard are still relevant
• TU datasets : Compilation of publicly available datasets, now ordered by categories and features. Most of these datasets can also be loaded with PyG, and a number of them have been ported to Datasets
• SNAP datasets: Stanford Large Network Dataset Collection :
• MoleculeNet datasets
• Relational datasets repository

External images attribution

Emojis in the thumbnail come from Openmoji (CC-BY-SA 4.0), the Graphlets figure comes from Biological network comparison using graphlet degree distribution (Pržulj, 2007).

More Articles from our Blog

Bringing the Artificial Analysis LLM Performance Leaderboard to Hugging Face

By  mhillsmith May 3, 2024 guest • 9

StarCoder2-Instruct: Fully Transparent and Permissive Self-Alignment for Code Generation

By  yuxiang630 April 29, 2024 guest • 62

A Brief Introduction to Graphical Models and Bayesian Networks

This tutorial, articles in the popular press, other sources of technical information, representation, are "bayesian networks" bayesian, explaining away, top-down and bottom-up reasoning, conditional independence in bayes nets, bayes nets with discrete and continuous nodes, temporal models, hidden markov models (hmms), linear dynamical systems (ldss) and kalman filters.

More complex DBNs

A generative model for generative models, variable elimination, dynamic programming, approximation algorithms, inference in dbns, known structure, full observability, bayesian learning, known structure, partial observability, unknown structure, full observability, the objective function used for model selection, search algorithms for finding the best model, unknown structure, partial observability, inventing new hidden nodes, further reading on learning, decision theory, applications, applications to biology, recommended introductory reading, review articles, exact inference, approximate inference.

Introduction to Graphical Models

A gentle introduction to graphical models, probabilistic programming, and mcmc using a simple linear regression example., will freyman, last modified on september 12, 2019.

Overview Prerequisites Getting Started with RevBayes and Rev Language Syntax

Data files and scripts Data Files anc_states_BiSSE.tree ase_freeK.tree bears.mcc.tre crocs_mass_extinction_probabilities.log empirical_data_pps_example.csv freeK_RJ.log primates.tre primates_BDS_rates.log primates_BiSSE_activity_period.log primates_EBD_extinction_rates.log primates_EBD_extinction_times.log primates_EBD_speciation_rates.log primates_EBD_speciation_times.log primates_HiSSE_2.log primates_cytb_GTR.log primates_cytb_GTR.trees primates_cytb_GTR_MAP.tre primates_cytb_GTR_run_1.log primates_cytb_GTR_run_2.log primates_tree.nex relaxed_OU_MAP.tre simple.ase.tre simulated_data_pps_example.csv x.csv y.csv Scripts anc_states.R divrates.R linear_regression.Rev linear_regression_generative.Rev parameter_estimates.R post_pred.R visualize_trees.R

RevBayes uses a graphical model framework in which all probabilistic models, including phylogenetic models, are comprised of modular components that can be assembled in a myriad of ways. RevBayes provides a highly flexible language called Rev that users employ to specify their own custom graphical models.

This tutorial is intended to be a gentle introduction on how to use Rev to specify graphical models. Additionally we’ll cover how to use Rev to specify the Markov chain Monte Carlo (MCMC) algorithms used to perform inference with the model. We will focus on a simple linear regression example, and use RevBayes to estimate the posterior distributions of our parameters.

Why Graphical Models?

RevBayes is a fundamental reconception of phylogenetic software. Most phylogenetic software have default settings that allow a user to run an analysis without truly understanding the assumptions of the model. RevBayes , on the other hand, has no defaults and is a complete blank slate when started. RevBayes requires users to fully specify the model they want to use for their analysis. This means the learning curve is steep, however there are a number of benefits:

Transparency: All the modeling assumptions are explicitly specified in RevBayes . The Rev script that runs an analysis makes these assumptions clear and can be easily shared. The assumptions can easily be modified in the Rev script and then the analysis can be rerun to see how changes affect the results. There is no reliance on “defaults” that may change with different versions of the software.

Flexibility: Users are not limited by a small set of models the programmers hard coded, instead users can specify their own custom models uniquely tailored to their hypotheses and datasets.

Modularity: Each model component can be combined with others in an endless number of new ways like a LEGO kit. Testing many complex evolutionary hypotheses require tying different models together. For example, suppose you wish to test how the effect of biographic range on trait evolution changes through time. In RevBayes you could simultaneously infer a time-calibrated phylogeny and estimate biogeography-dependent trait evolution using molecular data, biogeographic range data, and morphological data from both fossils and extant lineages.

What is a Graphical Model?

A graphical model is a way to represent a joint multivariate probability distribution as a graph. Here we mean graph in the mathematical sense of a set of nodes (vertices) and edges. In a graphical model, the nodes represent variables and the edges represent conditional dependencies among the variables. There are three important types of variables:

• Constant nodes: represents a fixed value that will not change.
• Stochastic nodes: represents a random variable with a value drawn from a probability distribution.
• Deterministic nodes: represents a deterministic transformation of the values of other nodes.

In the graphical modeling framework observed data is simply a variable with an observed value. To specify that a node has an observed value associated with it we say that the node is clamped , or fixed, to the observed value. illustrates the graphical model that represents the joint probability distribution

where \(\mathcal{D}\) is the vector of observed data points \(X_1,\dots,X_N\).

Nearly any probabilistic model can be represented as a graphical model: neural networks, classification models, time series models, and of course phylogenetic models! In some literature the terms Bayesian networks, belief networks, or causal networks are sometimes used to refer to graphical models.

Visual Representation

The statistics literature has developed a rich visual representation for graphical models. Visually representing graphical models can be useful for communication and pedagogy. We explain the notation used in the visual representation of these models only briefly (see ), and enourage readers to see Höhna et al. (2014) for more details. As we will discuss below, representing graphical models in computer code (using the Rev language) will likely be the most useful aspect of graphical models to most readers.

Phylogenetic Graphical Models

In phylogenetics, observations about different species are not considered independent data points due to their shared evolutionary history. So in a phylogenetic probabilistic model the topology of the tree determines the conditional dependencies among variables. This can be represented as a graphical model as in (left).

Phylogenetic models are often highly complex with hundreds of variables. Not only do we model the conditional dependencies due to shared evolutionary history (the tree topology), but we also commonly model character evolution (nucleotide substitution models, etc.), branching processes that determine the times between speciation events (birth-death processes), and many other aspects of the evolutionary process. With graphical models we can think of each part of these models as discrete components that can be combined in a myriad of ways to assemble different phylogenetic models ( right).

Probabilistic Programming

To describe complex probabilistic models and perform computational tasks with them, we need a way to formally specify the models in a computer. Probabilistic programming languages were designed exactly for this purpose. A probabilistic programming language is a tool for probabilistic inference that:

• formally specifies graphical models, and
• specifies the inference algorithms used with the model.

Probabilistic programming languages are being actively developed within the statistics and machine learning communities. Some of the most common are Stan , JAGS , Edward , and PyMC3 . While these are all excellent tools, they are all unsuitable for phylogenetic models since the tree topology itself must be treated as a random variable to be inferred.

The Rev Probabilistic Programming Language

RevBayes provides its own probabilistic programming language called Rev . While Rev focuses on phylogenetic models, nearly any type of probabilistic model can be programmed in Rev making it a highly flexible probabilistic computing environment. Most Rev scripts consist of two different parts:

• Model specification. This part of the script defines the constant, stochastic, and determinstic nodes that make up the model.
• Inference algorithm specification. This part of the script specifies what sort of inference algorithm we want to use with the model. Typically this is a Markov chain Monte Carlo algorithm, and we need to specify what sort of proposals (or moves) will operate on each variable.

In more complex Rev scripts, these two different elements (model specification and infernence algorithm specification) will be woven together. In the example for this tutorial we will keep the two parts separate.

Linear Regression Example

To demonstrate how to use the Rev language to specify a graphical model, we will start with a simple non-phylogenetic model. This tutorial will show both how to specify linear regression as a graphical model, and how to perform Bayesian inference over the model using MCMC.

Tutorial Format

All command-line text, including all Rev syntax, are given in monotype font . Furthermore, blocks of Rev code that are needed to build the model, specify the analysis, or execute the run are given in separate shaded boxes. For example, we will instruct you to create a new variable called n that is equal to 10 using the <- operator like this:

Setup Your Files

Make yourself familiar with the example script called linear_regression.Rev which shows the code for the following sections. Then, start a new and empty script in your text editor and follow each step provided as below. Name the script file my_linear_regression.Rev or anything you’d like.

You’ll also want to download the x.csv and y.csv data files and place them in a data directory.

Linear Regression as a Graphical Model

Suppose we observed the data shown in . We might hypothesize that $x$ and $y$ are related through the linear regression model

In this model $\beta$ and $\alpha$ are the regression variables (slope and y-intercept, respectively) and $\epsilon$ is an error or noise term. We can formulate this as the graphical model

Here $\mu_y$ is a deterministic variable, it is determined by whatever the values of $\beta$ and $\alpha$ are. We use the $:=$ assignment operator to designate that $\mu_y$ is deterministic. The error or noise term $\epsilon$ is represented as a normal distribution where the mean equals $\mu_y$ and the standard deviation is $\sigma_{\epsilon}$. $y$ is a stochastic variable, it has a value that is drawn from a probability distribution. This is designated by using the $\sim$ assignment operator. Since we have observed values for $y$, we will clamp $y$ to those observed values.

Bayesian Linear Regression

In our linear regression model $\beta$, $\alpha$, and $\sigma_{\epsilon}$ are the free variables we wish to estimate. To perform Bayesian inference, we need some priors!

Again, these are stochastic variables, so we use the $\sim$ assignment operator. For now we will accept these as decent uninformative priors. Later in the tutorial we will discuss how the choice of a prior can affect the outcome of the analysis.

Exercise: Using the sticks-and-arrows visual symbols explained in , draw the linear regression graphical model. See the answer in the expandable box below.

Answer: Visual Representation of the Linear Regression Model Visual representation of the linear regression graphical model. The plate (dashed rectangle) around $x_i$, $\mu_{yi}$ and $y_i$ represent the repeated variables for all the observed points. $y_i$ is a clamped (observed) stochastic node, so it is shaded. $\mu_{yi}$ is a deterministic node, so it is dashed. Here we treat $x_i$ as a constant node, so it is square. $\alpha$, $\beta$, and $\sigma$ are the stochastic variables we wish to estimate, and each of them are assigned priors distributions which have constant parameter values (the squares on the top row of the figure).

Specifying the Model in Rev

Remember that graphical models are made up of three types of nodes: stochastic, constant, and deterministic nodes. In Rev we specify the type of node by using a specific assignment operator:

• Stochastic node: n ~ dnNormal(0, 1)
• Constant node: n <- 5
• Deterministic node: n := m + 5

We will use each of these assignment operators to set up the linear regression model.

First, we read in the observed data as constant nodes:

Take a look at x_obs :

This is the vector of x-coordinates for the points plotted in .

Now we will specify the prior distributions for the stochastic nodes. These are the variables that we will estimate:

Now, for each observed value in x_obs we will create a deterministic node for mu_y and a stochastic node for y :

Take a look at y :

This produces a vector of simulated values of y ! We have specified a model that describes the process that generates y conditioned on the observed values of x . We have not clamped, or fixed, the observed values y_obs to the stochastic nodes y . In Rev all models can be used to both simulate new values and, when clamped to observed values, perform parameter inference.

In this case we are not interested in simulating new values of y , but instead we want to estimate our linear regression parameters. So let’s modify the above code to clamp the observed values to y :

Note that we have now clamped each observed value y_obs to each stochastic node y .

We have now fully specified the model, so we can begin specifying the inference algorithm.

Setting up MCMC in Rev

Here we will use the Metropolis-Hastings MCMC algorithm (Metropolis et al. 1953; Hastings 1970) to perform parameter estimation. We focus here on providing a simple overview of how to set up and tweak MCMC in RevBayes, for a more in depth introduction to MCMC please see the Introduction to Markov chain Monte Carlo (MCMC) Sampling tutorial.

The first step in setting up our MCMC algorithm is wrapping the entire model into a single variable:

Since our model is a graph in which all the model nodes are connected, we can use any model variable and RevBayes will traverse the graph to copy the entire model into the variable mymodel .

Note that we used the = assignment operator. This means that the variable mymodel is not part of the graphical model – it is not a stochastic, constant, or deterministic node. We call this a Rev workspace variable. Workspace variables are utility variables that we use for any programming task that is not specifically defining the model. Note, that unlike in R , in Rev the = and <- assignment operators have very different functions!

To sample different values of each variable, we must assign an MCMC move to each variable. Each MCMC move will propose new values of each parameter. We have three variables, so we will have three moves which we will save in a vector called moves :

Here we used simple slide moves for each variable. The slide move proposes new values for the variable by “sliding” its value within a small window determined by the delta argument. RevBayes provides many other types of moves that you will see in other tutorials. We set the weight of each move to 1, which means that each move will be performed on average once per MCMC iteration.

Next, we need to set up some monitors that will sample values during the MCMC. We will use two monitors which we save into a vector called monitors . The first monitor mnScreen prints out values to the screen, and the second monitor mnModel prints a log file.

RevBayes provides many other monitors that can be useful for different types of analyses, but these are sufficient for this example.

We can now pass the model, moves, and monitors into the mcmc function to finalize our analysis. Then we use the run member method to run the MCMC for 10000 iterations.

Note that we included the quit() command so that RevBayes will automatically quit after the MCMC has finished running.

Improving MCMC Mixing

Exercise: Now open the file output/linear_regression.log in Tracer.

You will notice that the MCMC analysis did not converge well:

We can fix this by modifying the MCMC moves we use. Let’s use a larger sliding window (the delta argument in mvSlide ). We will also increase the weight of each move to 5. This means that each move will be now be performed on average 5 times per MCMC iteration.

Exercise: Rerun the MCMC analysis with these new moves and view the log file in Tracer.

This analysis looks much better:

Prior Sensitivity

Prior distributions are a way to mathematically formalize our prior knowledge. We used normal distributions as priors for $\alpha$ and $\beta$. How did we pick these distributions? illustrates the normal distribution with different values for the standard deviation. Using a smaller standard deviation (0.1) places most of the density close to 0. This sort of prior is appropriate only if we have prior information that the parameter’s true value is close to 0, so we can call this an informative prior. Using a large standard deviation (10.0) is a highly uninformative prior. The density is diffuse and nearly uniform, allowing for a wide range of values. This is appropriate if we have very little idea what the true value of the parameter is.

In RevBayes it is easy to modify the priors used in an analysis and rerun the analysis.

Exercise: Try rerunning the linear regression exercise using highly informative priors (standard deviation set to 0.1) on beta and alpha as shown below.

shows the posterior estimates when using these priors. Compare those results with those shown in . Using informative priors that are incorrect can badly bias the results.

Exercise: Try running the analysis again with highly uninformative priors (10.0).

These results are highly similar to our original estimates shown in . Our original priors (that had a standard deviation of 1.0) did not introduce any bias. Typically the trade off is between informative priors that may introduce bias and uninformative priors that may increase the variance (uncertainty) of our estimates.

Generative vs Discriminative Models

Probabilistic models can be understood as either discriminative or generative models. The distinction between the two can be useful in phylogenetics where different analyses often make use of these different types of models. RevBayes enables us to specify both types of models.

Discriminative Models

Discriminative (or conditional) models involve a response variable conditioned on a predictor variable. The model represents the conditional distribution $p(y|x)$ and so makes fewer assumptions about the data: it is not necessary to specify $p(x)$. The linear regression example we coded in Rev was a discriminative model because it conditioned on the observed values of $x$. In other words the model could simulate values of $y$ conditioned on the observed values of $x$, but it could not simulate values of $x$.

In phylogenetics we often use discriminative models when we condition over a fixed tree (or set of trees):

• estimating divergence times over a fixed topology
• estimating ancestral states on a fixed tree
• estimating shifts in diversification rates over a fixed tree

We can set up all these discriminative models in RevBayes .

Generative Models

Generative models model the entire process used to generate the data. So these models represent the joint distribution $p(x, y)$, and therefore they must make more assumptions about the data: we need to define $p(x)$. This allows for a richer representation of the relations between variables. Additionally these models are more powerful; they allow us to compute $p(y|x)$ or $p(x|y)$ and to simulate both $x$ and $y$.

In phylogenetics we use fully generative models when we:

• jointly estimate divergence times and the tree topology
• jointly estimate ancestral states and the tree
• jointly estimate shifting diversification rates and the tree

RevBayes is unique because it allows us to specify both highly complex fully generative models as well as their more simple discriminative forms.

A Generative Linear Regression Model

A fully generative linear regression model enables us to learn something about $x$, for example the mean and standard deviation, which we don’t get from the discriminative form. With the generative model:

• we can simulate values of both $x$ and $y$,
• both $x$ and $y$ will need to be clamped to the observed data,
• and we will need to specify a prior distribution for $x$.

Exercise: Reformulate our linear regression example so that it is a fully generative model: Draw the sticks-and-arrows diagram for a generative model and compare it to the discriminative form. See the expandable box for one solution. Code up the model in Rev and run MCMC. A solution is provided in linear_regression_generative.Rev if you get stuck.

Answer: Visual Representation of the Generative Linear Regression Model Visual representation of the generative linear regression graphical model. Compare this to . The major difference is we now treat $x_i$ as a clamped (observed) stochastic node. Additionally, we now estimate $\mu_x$ and $\sigma_x$ as stochastic variables.

RevBayes gives evolutionary biologists the tools to formalize their hypotheses as custom graphical models that represent the specific process that generated their data. This enables many evolutionary hypotheses to now be tested in a rigorous and quantitative approach. Hopefully this tutorial will help readers develop their own custom models and not use defaults ever again!

• Hastings W.K. 1970. Monte Carlo Sampling Methods Using Markov Chains and Their Applications. Biometrika. 57:97–109.
• Höhna S., Heath T.A., Boussau B., Landis M.J., Ronquist F., Huelsenbeck J.P. 2014. Probabilistic Graphical Model Representation in Phylogenetics. Systematic Biology. 63:753–771. 10.1093/sysbio/syu039
• Metropolis N., Rosenbluth A.W., Rosenbluth M.N., Teller A.H., Teller E. 1953. Equation of State Calculations by Fast Computing Machines. Journal of Chemical Physics. 21:1087–1092. 10.1063/1.1699114

How to develop a graphical framework to chart your research

Graphic representations or frameworks can be powerful tools to explain research processes and outcomes. David Waller explains how researchers can develop effective visual models to chart their work

David Waller

• More on this topic

You may also like

Popular resources

.css-1txxx8u{overflow:hidden;max-height:81px;text-indent:0px;} A framework to teach library research skills

The trouble with bloom’s taxonomy in an age of ai, emotions and learning: what role do emotions play in how and why students learn, playing the promotion game: how to navigate upshifting, using the snowflake method to build belonging on campus.

While undertaking a study, researchers can uncover insights, connections and findings that are extremely valuable to anyone likely to read their eventual paper. Thus, it is important for the researcher to clearly present and explain the ideas and potential relationships. One important way of presenting findings and relationships is by developing a graphical conceptual framework.

A graphical conceptual framework is a visual model that assists readers by illustrating how concepts, constructs, themes or processes work. It is an image designed to help the viewer understand how various factors interrelate and affect outcomes, such as a chart, graph or map.

These are commonly used in research to show outcomes but also to create, develop, test, support and criticise various ideas and models. The use of a conceptual framework can vary depending on whether it is being used for qualitative or quantitative research.

• Using literature reviews to strengthen research: tips for PhDs and supervisors
• Get your research out there: 7 strategies for high-impact science communication
• Understanding peer review: what it is, how it works and why it is important

There are many forms that a graphical conceptual framework can take, which can depend on the topic, the type of research or findings, and what can best present the story.

Below are examples of frameworks based on qualitative and quantitative research.

As shown by the table below, in qualitative research the conceptual framework is developed at the end of the study to illustrate the factors or issues presented in the qualitative data. It is designed to assist in theory building and the visual understanding of the exploratory findings. It can also be used to develop a framework in preparation for testing the proposition using quantitative research.

In quantitative research a conceptual framework can be used to synthesise the literature and theoretical concepts at the beginning of the study to present a model that will be tested in the statistical analysis of the research.

It is important to understand that the role of a conceptual framework differs depending on the type of research that is being undertaken.

So how should you go about creating a conceptual framework? After undertaking some studies where I have developed conceptual frameworks, here is a simple model based on “Six Rs”: Review, Reflect, Relationships, Reflect, Review, and Repeat.

Process for developing conceptual frameworks:

Review: literature/themes/theory.

Reflect: what are the main concepts/issues?

Relationships: what are their relationships?

Reflect: does the diagram represent it sufficiently?

Review: check it with theory, colleagues, stakeholders, etc.

Repeat: review and revise it to see if something better occurs.

This is not an easy process. It is important to begin by reviewing what has been presented in previous studies in the literature or in practice. This provides a solid background to the proposed model as it can show how it relates to accepted theoretical concepts or practical examples, and helps make sure that it is grounded in logical sense.

It can start with pen and paper, but after reviewing you should reflect to consider if the proposed framework takes into account the main concepts and issues, and the potential relationships that have been presented on the topic in previous works.

It may take a few versions before you are happy with the final framework, so it is worth continuing to reflect on the model and review its worth by reassessing it to determine if the model is consistent with the literature and theories. It can also be useful to discuss the idea with  colleagues or to present preliminary ideas at a conference or workshop –  be open to changes.

Even after you come up with a potential model it is good to repeat the process to review the framework and be prepared to revise it as this can help in refining the model. Over time you may develop a number of models with each one superseding the previous one.

A concern is that some students hold on to the framework they first thought of and worry that developing or changing it will be seen as a weakness in their research. However, a revised and refined model can be an important factor in justifying the value of the research.

Plenty of possibilities and theoretical topics could be considered to enhance the model. Whether it ultimately supports the theoretical constructs of the research will be dependent on what occurs when it is tested.  As social psychologist, Kurt Lewin, famously said “ There's nothing so practical as good theory ”.

The final result after doing your reviewing and reflecting should be a clear graphical presentation that will help the reader understand what the research is about as well as where it is heading.

It doesn’t need to be complex. A simple diagram or table can clarify the nature of a process and help in its analysis, which can be important for the researcher when communicating to their audience. As the saying goes: “ A picture is worth 1000 words ”. The same goes for a good conceptual framework, when explaining a research process or findings.

David Waller is an associate professor at the University of Technology Sydney .

If you found this interesting and want advice and insight from academics and university staff delivered direct to your inbox each week,  sign up for the THE Campus newsletter .

A framework to teach library research skills

How hard can it be testing ai detection tools, how to develop cognitive presence in your learning community, student communication: a compassionate approach, improve your college course for students with add and adhd, a diy guide to starting your own journal.

Register for free

and unlock a host of features on the THE site

Help | Advanced Search

Computer Science > Computation and Language

Title: parameter-efficient tuning large language models for graph representation learning.

Abstract: Text-rich graphs, which exhibit rich textual information on nodes and edges, are prevalent across a wide range of real-world business applications. Large Language Models (LLMs) have demonstrated remarkable abilities in understanding text, which also introduced the potential for more expressive modeling in text-rich graphs. Despite these capabilities, efficiently applying LLMs to representation learning on graphs presents significant challenges. Recently, parameter-efficient fine-tuning methods for LLMs have enabled efficient new task generalization with minimal time and memory consumption. Inspired by this, we introduce Graph-aware Parameter-Efficient Fine-Tuning - GPEFT, a novel approach for efficient graph representation learning with LLMs on text-rich graphs. Specifically, we utilize a graph neural network (GNN) to encode structural information from neighboring nodes into a graph prompt. This prompt is then inserted at the beginning of the text sequence. To improve the quality of graph prompts, we pre-trained the GNN to assist the frozen LLM in predicting the next token in the node text. Compared with existing joint GNN and LMs, our method directly generate the node embeddings from large language models with an affordable fine-tuning cost. We validate our approach through comprehensive experiments conducted on 8 different text-rich graphs, observing an average improvement of 2% in hit@1 and Mean Reciprocal Rank (MRR) in link prediction evaluations. Our results demonstrate the efficacy and efficiency of our model, showing that it can be smoothly integrated with various large language models, including OPT, LLaMA and Falcon.

Submission history

Access paper:.

• HTML (experimental)
• Other Formats

References & Citations

• Google Scholar
• Semantic Scholar

BibTeX formatted citation

Bibliographic and Citation Tools

Code, data and media associated with this article, recommenders and search tools.

• Institution

arXivLabs: experimental projects with community collaborators

arXivLabs is a framework that allows collaborators to develop and share new arXiv features directly on our website.

Both individuals and organizations that work with arXivLabs have embraced and accepted our values of openness, community, excellence, and user data privacy. arXiv is committed to these values and only works with partners that adhere to them.

Have an idea for a project that will add value for arXiv's community? Learn more about arXivLabs .

• Data Science
• Data Analysis
• Data Visualization
• Machine Learning
• Deep Learning
• Computer Vision
• Artificial Intelligence
• AI ML DS Interview Series
• AI ML DS Projects series
• Data Engineering
• Web Scrapping
• Graphical Representation of Data
• Java Program to Represent Graphs Using Linked List
• Implementation of a Hypergraph
• How to Represent Graph Using Incidence Matrix in Java?
• Train a Deep Learning Model With Pytorch
• Network Visualization in R using igraph
• Graph and its representations
• Representation of Relation in Graphs and Matrices
• Graph representations using set and hash
• Graph Representation using Java ArrayList
• L-graphs and what they represent in TOC
• Fusion Operation In Graph
• Hypergraph & its representation | Discrete Mathematics
• Discrete Mathematics | Representing Relations
• Graph Matrices in Software Testing
• Prove that Sparse Graph is NP-Complete
• Graph | Question 1
• Convert Adjacency Matrix to Adjacency List representation of Graph
• Graph Plotting in R Programming

Graph Representation Learning

In this article we are going to learn about Graph representation in Machine Learning (ML) . Graph is basically a data structure which provide a mathematical model of representing information by the collection of nodes and edges connecting them. It is used in machine learning to solve the problem of real world with an ease and implement the algorithm accordingly. Hence, graph representation is an essential part of study of Machine learning . In this article, we are going to discuss graph theory, graph representation learning and more.

Table of Content

• What is a graph?
• Homogenous vs Heterogeneous Graph

What is Graph Representation Learning?

• Machine Learning with Graphs

Applications of Graph Representation in ML

What is a graph.

A graph is collection of some nodes and edges. A graph is represented as G (V, E) . Here V represents vertices and E represents edges. This a data structure which represents association and relation among entities. A Graph contains:

• Node: A collection of nodes, also called vertices, represented by V. These nodes to represents object or entities.
• Edges: Edges joining these vertices, represented by E. An edge between two node represents the relation, between those connected nodes.
• Weight: Weight are an attribute assigned to the edges to the weighted graph.
• Path: Path is the edges covered while moving from one particular node to another node. There can be more than one path from one node to another.
• Circuit: Circuit is path in which first and last node are same.

Types of Graphs

In graph theory, the graphs can be classified as:

• Directed Graph: Directed Graphs are those graphs in which connecting edges of nodes directs to a particular direction.
• Undirected Graph: An undirected graph is a type of graph in which edges do not have a direction associated with them. In other words, the relationships between vertices (nodes) are symmetric.
• Weighted Graph: Those graphs in which each edge associate with a weight is called a weighted graph .

Multi-relational Graphs

Multi-relational graphs extend traditional graphs by allowing different types of edges to represent different relationships between nodes. Each edge is associated with a specific edge type or relation [Tex]\tau[/Tex] , denoted as (u, \tau, v) \in E, where u and v are nodes connected by the edge of type [Tex]\tau[/Tex] . The graph can be represented by an adjacency tensor A of shape [Tex]|V|\times|R|\times|V|[/Tex] , where ∣ R ∣ is the number of distinct edge types or relations.

Heterogenous Graph

• Heterogeneous graphs are a subset of multi-relational graphs where nodes and edges can have different types or categories.
• Nodes in a heterogeneous graph may represent different types of entities (e.g., users, products, events), and edges may represent different types of relationships or interactions between these entities.
• For example, in a social network, nodes could represent users, pages, and events, while edges could represent friendships, likes, and attendances.
• Heterogeneous graphs provide a flexible framework for modeling complex relationships and interactions in various domains.

Multiplex Graphs

• Multiplex graphs are another subset of multi-relational graphs where different layers or “layers” of edges exist, each representing a distinct relationship between nodes.
• Unlike heterogeneous graphs, multiplex graphs typically have homogeneous nodes (i.e., all nodes belong to the same type), but different layers of edges capture different types of interactions between these nodes.
• For example, in a transportation network, one layer of edges could represent road connections, while another layer could represent railway connections.
• Multiplex graphs are useful for modeling systems with multiple interaction modalities or networks with diverse edge types.

Graph representation learning is indeed a field of machine learning and artificial intelligence that is concerned with developing algorithms capable of learning meaningful representations of graph-structured data. In traditional machine learning tasks, such as image classification or natural language processing, data is often represented in structured formats like matrices or tensors. However, many real-world datasets exhibit complex relational structures that cannot be easily captured using traditional representations.

Graphs provide a flexible and expressive way to model relationships between entities in various domains, such as social networks, biological networks, recommendation systems, knowledge graphs, and more. In these graphs, entities are represented as nodes, and relationships between entities are represented as edges. Analyzing and extracting insights from such graph-structured data poses unique challenges due to its irregular and heterogeneous nature.

Graph representation learning aims to learn low-dimensional vector representations (embeddings) of nodes, edges, or entire graphs. Techniques like node embeddings (e.g., node2vec, DeepWalk), graph embeddings (e.g., GraphSAGE, Graph Convolutional Networks), and graph neural networks (GNNs) are commonly used for this purpose. These embeddings capture structural and relational information from the graph, enabling downstream tasks such as node classification, link prediction, and graph classification.

Machine Learning with Graph

Graph in machine learning provides a mathematical foundation for an accurate analysis, understanding the problem and learning real world problems. They bring simplicity to the complex system and makes such task easy to handle. Those System which uses networking, such as biological networks, social media network, transportational network and other kind of networks related system are significant to use the graphs in Machine Learning. Those system where networking and connection of various nodes is a requirement graph are used.

Let’s discuss some key concepts in machine learning with Graphs:

Supervised Graph Machine learning tasks

Supervised Graph Machine learning tasks includes leveraging labeled data by which a machine learning model can be trained. This data contains nodes and edges and node or edge labels. We have described such task associated with Graph machine learning. Here is a list of those task which can be performed using Supervised Graph Machine Learning. Following are the examples of supervised Graph Machine learning tasks:

Node Classification

Classification of Nodes is a process of prediction of labels of the nodes of a graph according to their relationships and association with their neighbor nodes. If the graph is partially labeled than this classification aids to label the unlabeled part of graph.

Graph Classification

This a process of classification of graph in different parts according to its properties, attributes and nodes. This process is used in graph make a graph simple. It aids in community detection and anomaly detection. Its application is in biological networks, social networking system and various other system which includes networking.

Graph Regression

Graph regression tasks involve predicting continuous-valued target variables associated with nodes or graphs. Instead of discrete class labels, the goal is to predict real-valued quantities such as node properties, graph properties, or graph-level attributes. Example applications include predicting node properties like protein folding energies in biological networks, estimating graph properties like centrality measures in social networks, and forecasting financial indicators in economic networks.

Link Prediction

Link prediction is process of finding the possibility of link between two nodes of a graph. So, this process predicts the possibility of link between various nodes of a graph. There are many methods of link prediction. Heuristic approach is one of the feasible methods for link prediction. In this method it has to be found the similarity between two nodes according to their heuristics such as common neighbor. Link prediction is key problem of network-structured data.

Unsupervised graph machine learning tasks

In unsupervised a machine learning algorithm have to find the hidden patterns on its own without any label. In context of graph unlabeled data is analyzed through the graphs. Following are the examples of unsupervised machine learning task:

Graph Clustering

Graph clustering, also known as community detection, involves partitioning the nodes of a graph into clusters or communities based on their connectivity patterns. The objective is to identify densely connected subgraphs within the larger graph. Clustering algorithms such as spectral clustering, modularity optimization, and hierarchical clustering are commonly used for this task.

Anomaly detection

Anomaly detection is task of machine learning in which it is identified whether a pattern deviates from its regular characteristics. This process identifies the unusual characteristic of a patten within a graph. It is applicable in various domain such as fraud detection, social networking and spam detection.

Graph Generation

Graph generation aims to generate new graph instances that exhibit similar properties to a given set of training graphs. The goal is to learn a generative model that captures the underlying distribution of the data and can produce novel graph samples. Generative models such as graph autoencoders, graph generative adversarial networks (GANs), and variational graph autoencoders (VGAEs) are used for graph generation.

Following are the various applications of Graph representation in Machine Learning:

• Graphs are widely used in various ML based application such as social networking platforms.
• Domains such as network analysis, fraud detection, bioinformatics and map construction have significant requirement of graph theory.
• food websites, product delivery system and other map related websites and many other applications.
• By implementing Minimum distance algorithms, we can easily get the minimum distance among two cities as we use it in google maps.
• Graphs are also used in many scientific research related tasks and inventions. Where some entities are related with each other.
• GNN, Graphical Neural Network is also a concept where graphs are used and on crucial part of Machine Learning.

Please Login to comment...

Similar reads.

• ML-Statistics

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Transcending classical diffusion models: nonlinear dynamics and solitary waves in the fractional Chaffee–Infante equation

• Published: 04 May 2024
• Volume 56 , article number  1033 , ( 2024 )

Cite this article

• Raghda A. M. Attia 1 ,
• Suleman H. Alfalqi 2 ,
• Jameel F. Alzaidi 2 ,
• Aleksander Vokhmintsev 3 , 4 &
• Mostafa M. A. Khater 1 , 5  

This research employs advanced computational methodologies to analyze solitary wave solutions associated with the fractional nonlinear Chaffee–Infante ( \(\mathcal{C}\mathcal{I}\) ) equation, extending classical diffusion models with broad applications in materials science, fluid dynamics, and signal processing. The study makes notable contributions to the modeling of anomalous diffusion in porous materials, the comprehension of nonlinear dynamics, and the analysis of wave behavior incorporating memory and non-local effects. The research enhances our understanding of practical applications and provides valuable insights into complex wave dynamics within fluid dynamics, nonlinear optics, and plasma physics. The computational techniques utilized in this investigation, specifically the extended unified ( \(\mathcal{E}\mathcal{U}\) ) and trigonometric–quantic–B-spline ( \(\mathcal {TQBS}\) ) approaches, demonstrate superior effectiveness in comparison to existing methods, promising heightened accuracy and efficiency in solving fractional partial differential equations. The numerical scheme, Trigonometric–Quantic–B–spline, in tandem with analytical solutions, serves to validate the model and adapt it to real-world complexities. This integrated approach not only quantifies accuracy but also supports parameter estimation, ensuring the model’s applicability in diverse engineering and scientific scenarios. Graphical representations of both analytical and numerical solutions are presented, offering a visual elucidation of the model’s characteristics and validating solution accuracy. The incorporation of the Trigonometric–Quantic–B–spline scheme provides a robust foundation for further exploration and applications in varied scientific and engineering domains.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Price includes VAT (Russian Federation)

Instant access to the full article PDF.

Rent this article via DeepDyve

Institutional subscriptions

Similar content being viewed by others

Eighty Years of the Finite Element Method: Birth, Evolution, and Future

Analyses of the Contour Integral Method for Time Fractional Normal-Subdiffusion Transport Equation

Solitary Wave Solutions in (2+1) Dimensions: The KdV Equation Derived from Ideal Fluid Models

Data availibility statement.

Data will be made available on request.

Jumarie, G.: Modified Riemann–Liouville derivative and fractional Taylor series of nondifferentiable functions further results. Comput. Math. Appl. 51 (9–10), 1367–1376 (2006)

Article   MathSciNet   Google Scholar  

Khater, M.M.: Exploring the rich solution landscape of the generalized Kawahara equation: insights from analytical techniques. Eur. Phys. J. Plus 139 (2), 184 (2024a)

Article   Google Scholar  

Khater, M.M.: Wave propagation and evolution in a (1+1)-dimensional spatial-temporal domain: a comprehensive study. Mod. Phys. Lett. B 38 (05), 2350235 (2024b)

Article   ADS   Google Scholar  

Khater, M.M.: Wave propagation analysis in the modified nonlinear time fractional Harry Dym equation: insights from Khater II method and b-spline schemes. Mod. Phys. Lett. B 2450288 (2024c)

Khater, M.M.: Modeling wave propagation with gravity and surface tension: Soliton solutions for the generalized hietarinta-type equation. Qual. Theory Dyn. Syst. 23 (2), 86 (2024d)

Li, J., Feng, Z.: Quadratic and cubic nonlinear oscillators with damping and their applications. Int. J. Bifurc. Chaos 26 (3), 1650050–350 (2016)

Mahmood, A., Abbas, M., Akram, G., Sadaf, M., Riaz, M.B., Abdeljawad, T.: Solitary wave solution of (2+1)-dimensional Chaffee–Infante equation using the modified Khater method. Results Phys. 48 , 106416 (2023)

Mao, Y.: Exact solutions to \((2+1) (2+1)\) -dimensional Chaffee–Infante equation. Pramana 91 (1), 9 (2018)

Naqeeb, M., hussain, A.: Conservation laws and the applicability of group theoretical technique to non-linear Chaffee–Infante equation. Print at arXiv:1904.07738 (2019)

Qiang, L., Yun, Z., Yuanzheng, W.: Qualitative analysis and travelling wave solutions for the Chaffee–Infante equation. Rep. Math. Phys. 71 (2), 177–193 (2013)

Article   ADS   MathSciNet   Google Scholar  

Rolland, J., Bouchet, F., Simonnet, E.: Rare transitions between metastable states in the stochastic Chaffee-Infante equation. In: EGU General Assembly Conference Abstracts, EGU General Assembly Conference Abstracts, p. 14223 (2015)

Sakthivel, R., Chun, C.: New soliton solutions of Chaffee–Infante equations using the exp-function method. Z. Naturforschung Teil A 65 (3), 197–202 (2010)

Sebogodi, M.C., Muatjetjeja, B., Adem, A.R.: Traveling wave solutions and conservation laws of a generalized Chaffee–Infante equation in (1+3) dimensions. Universe 9 (5), 224 (2023)

Shomberg, J.L.: Explicit construction of a robust family of compact inertial manifolds. Preprint at arXiv:0807.3934 (2008)

Xie, F.-D., Liu, X.-D., Sun, X.-P., Tang, D.: Application of computer algebra in solving Chaffee Infante equation. Commun. Theor. Phys. 49 (4), 825–828 (2008)

Yan, Z., Zhang, H.: Backlund transformation and exact solutions for (2+1)-dimensional Kolmogoroff–Petrovsky–Piscounov equation. Commun. Nonlinear Sci. Numer. Simul. 4 (2), 146–151 (1999)

Download references

Acknowledgements

The authors extend their appreciation to the Deanship of Scientific Research at King Khalid University for funding this work through Large Groups Project under grant number (RGP. 2/554/44). All authors read and approved the final manuscript.

This study has been partially funded by the Deanship of Scientific Research at King Khalid University for funding this work through the Large Groups Project under grant number (RGP. 2/554/44). All authors read and approved the final manuscript.

Author information

Authors and affiliations.

School of Medical Informatics and Engineering, Xuzhou Medical University, 209 Tongshan Road, Xuzhou, 221004, Jiangsu Province, People’s Republic of China

Raghda A. M. Attia & Mostafa M. A. Khater

Department of Mathematics, Faculty of Science and Arts in Mahayil Asir, King Khalid University, Abha, Saudi Arabia

Suleman H. Alfalqi & Jameel F. Alzaidi

Institute of Information Technology, Chelyabinsk State University, Chelyabinsk, Russia

Aleksander Vokhmintsev

Institute of Digital Economy, Ugra State University, Khanty-Mansiysk, Russia

Department of Basic Science, Obour High Institute for Engineering and Technology, Cairo, 11828, Egypt

Mostafa M. A. Khater

You can also search for this author in PubMed   Google Scholar

Contributions

Raghda A. M. Attia and Mostafa M. A. Khater conceived and designed the experiments and performed them. Suleman H. Alfalqi, Jameel F. Alzaidi, and Aleksander Vokhmintsev analyzed and interpreted the data, contributed to the provision of reagents, materials, analysis tools, or data, and wrote the paper.

Corresponding author

Correspondence to Mostafa M. A. Khater .

Ethics declarations

Declaration of interest’s statement:.

The authors declare no Conflict of interest.

Additional information

Publisher's note.

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

This section presents the headlines of the extended unified ( \(\mathcal{E}\mathcal{U}\) ) technique, introduced here as follows:

Consider the generic form of the nonlinear evolution equation:

where \(\mathcal {G}=\mathcal {G}(x,t)\) represents a polynomial in \(\mathcal {U}(x,t)\) and its partial derivatives involving the highest order derivatives and nonlinear terms.

Step 1 Implement the traveling wave transformation along with the the Jumarie’s modified Riemann–Liouville derivative:

to convert Eq. ( 23 ) into the following ODE:

where \(\mathcal {C}\) is a polynomial in \(\mathcal {U}(\mathfrak {Z})\) and its total derivatives, and \(\mathcal {U}^{\prime }(\mathfrak {Z})=\frac{d \mathcal {U}}{d \mathfrak {Z}}\) .

Step 2 Assume the solution of ( 25 ) to be in the form:

where \(a_{i}\) , ( \(i=0,\,1,\,2,\,3,\, \ldots ,\,n\) ) are arbitrary constants with \(a_{n} \ne 0\) . Here, \(\psi (\mathfrak {Z} )\) satisfies the equation:

where \(\lambda \) , is arbitrary constant. Step 3 Determine the positive integer n appearing in the general solution by considering the homogeneous balance between the highest order derivatives and the highest order nonlinear terms in ( 25 ):

Rights and permissions

Springer Nature or its licensor (e.g. a society or other partner) holds exclusive rights to this article under a publishing agreement with the author(s) or other rightsholder(s); author self-archiving of the accepted manuscript version of this article is solely governed by the terms of such publishing agreement and applicable law.

Reprints and permissions

About this article

Attia, R.A.M., Alfalqi, S.H., Alzaidi, J.F. et al. Transcending classical diffusion models: nonlinear dynamics and solitary waves in the fractional Chaffee–Infante equation. Opt Quant Electron 56 , 1033 (2024). https://doi.org/10.1007/s11082-024-06824-7

Download citation

Received : 24 December 2023

Accepted : 10 March 2024

Published : 04 May 2024

DOI : https://doi.org/10.1007/s11082-024-06824-7

Share this article

Anyone you share the following link with will be able to read this content:

Sorry, a shareable link is not currently available for this article.

Provided by the Springer Nature SharedIt content-sharing initiative

• Fractional nonlinear Chaffee–Infante equation
• Solitary wave solutions
• Anomalous diffusion
• Computational methods
• Trigonometric–quantic–B–spline
• Extended unified approach
• Fluid dynamics
• Nonlinear optics
• Plasma physics

Mathematics Subject Classification

• Find a journal
• Publish with us
• Track your research