How is alpha computed in this case? Are there agreed upon values for the discount or can we adjust this value based on the nature of our graph? Also, I am a bit confused as to the reasoning behind including alpha. Why is there a need for a discount in creating the ranks themselves?

@shaan0924 this wikipedia article/section might be helpful in answering your question: https://en.wikipedia.org/wiki/PageRank#Damping_factor. The original paper (http://infolab.stanford.edu/pub/papers/google.pdf) is also an interesting read and they give an intuitive justification for the damping factor in section 2.1.2. Also, it seems like the optimal damping factor is just something that is determined empirically... but I'm no expert on page rank so don't take my word for it.

You can probably think about alpha as a "smoothing" parameter -- when it is one, all adjacent vertices are hard-coded to give the same contribution of 1/N. When it is zero, all adjacent vertices will give their true value as a contribution. Anything in-between is a smoothed version of the two extremes.

@thepurplecow that makes a lot of sense. You really want that smoothing parameter so that any single vertex doesn't have too much of a weight on a page. However, I do wonder how this discount factor is determined... maybe it's adjusted on the fly or varied from page to page? Or maybe it's a simple hyperparameter that's tuned during training?

We've talked a lot about the specifics of implementation in this class. But as we move on to advancing onto utilizing heavily optimized frameworks, it's useful to think of algorithms at a higher level: this example from lecture shows that all we need is a brief mathematical description of an algorithm that we can plug into a library. Surely makes parallelism more accessible, and doesn't require a black-belt knowledge of parallel computing.

The equation above makes me think that another nice tool I would want in my graph-specific language is to be able to write code from the perspective of a particular node or edge. For PageRank, as an example, it would be nice to write something like

def updateRank(node, neighbors): node.rank = (1-alpha)/N + sum([neighbor.rank / neighbor.degree for neighbor in neighbors])

And have this run in parallel for all nodes in the graph. Pytorch Geometric offers something like this in its message-passing framework, which allows you to reason about graphs from the perspective of an individual node and one of its neighbors.