Question: Represent the scientific article to find a short TLDR

Question: Representation Learning over graph structured data has received significant attention recently due to its ubiquitous applicability. However, most advancements have been made in static graph settings while efforts for jointly learning dynamic of the graph and dynamic on the graph are still in an infant stage. Two fundamental questions arise in learning over dynamic graphs: (i) How to elegantly model dynamical processes over graphs? (ii) How to leverage such a model to effectively encode evolving graph information into low-dimensional representations? We present DyRep - a novel modeling framework for dynamic graphs that posits representation learning as a latent mediation process bridging two observed processes namely -- dynamics of the network (realized as topological evolution) and dynamics on the network (realized as activities between nodes). Concretely, we propose a two-time scale deep temporal point process model that captures the interleaved dynamics of the observed processes. This model is further parameterized by a temporal-attentive representation network that encodes temporally evolving structural information into node representations which in turn drives the nonlinear evolution of the observed graph dynamics. Our unified framework is trained using an efficient unsupervised procedure and has capability to generalize over unseen nodes. We demonstrate that DyRep outperforms state-of-the-art baselines for dynamic link prediction and time prediction tasks and present extensive qualitative insights into our framework. Representation learning over graph structured data has emerged as a keystone machine learning task due to its ubiquitous applicability in variety of domains such as social networks, bioinformatics, natural language processing, and relational knowledge bases. Learning node representations to effectively encode high-dimensional and non-Euclidean graph information is a challenging problem but recent advances in deep learning has helped important progress towards addressing it BID4 BID17;; a; BID15 BID14, with majority of the approaches focusing on advancing the state-of-the-art in static graph setting. However, several domains now present highly dynamic data that exhibit complex temporal properties in addition to earlier cited challenges. For instance, social network communications, financial transaction graphs or longitudinal citation data contain fine-grained temporal information on nodes and edges that characterize the dynamic evolution of a graph and its properties over time. These recent developments have created a conspicuous need for principled approaches to advance graph embedding techniques for dynamic graphs (b). We focus on two pertinent questions fundamental to representation learning over dynamic graphs: (i) What can serve as an elegant model for dynamic processes over graphs? -A key modeling choice in existing representation learning techniques for dynamic graphs BID16; BID14; ) assume that graph dynamics evolve as a single time scale process. In contrast to these approaches, we observe that most real-world graphs exhibit at least two distinct dynamic processes that evolve at different time scales -Topological Evolution: where the number of nodes and edges are expected to grow (or shrink) over time leading to structural changes in the graph; and Node Interactions: which relates to activities between nodes that may or may not be structurally connected. Modeling interleaved dependencies between these non-linearly evolving dynamic processes is a crucial next step for advancing the formal models of dynamic graphs. (c) Communication Events (k=1) where nodes interact with each other. For both these processes, t p,k=0 < (t 1, t 2, t 3, t 4, t 5) k=1 < t q,k=0 < (t 6, t 7) k=1 < t r,k=0. (b) Evolving Representations.(ii) How can one leverage such a model to learn dynamic node representations that are effectively able to capture evolving graph information over time? -Existing techniques in this direction can be divided into two approaches: a.) Discrete-Time Approach, where the evolution of a dynamic graph is observed as collection of static graph snapshots over time (; BID16). These approaches tend to preserve (encode) very limited structural information and capture temporal information at a very coarse level which leads to loss of information between snapshots and lack of ability to capture fine-grained temporal dynamics. Another challenge in such approaches is the selection of appropriate aggregation granularity which is often misspecified. b.) Continuous-Time Approach, where evolution is modeled at finer time granularity in order to address the above challenges. While existing approaches have demonstrated to be very effective in specific settings, they either model simple structural and complex temporal properties in a decoupled fashion BID14 or use simple temporal models (exponential family in ). But several domains exhibit highly nonlinear evolution of structural properties coupled with complex temporal dynamics and it remains an open problem to effectively model and learn informative representations capturing various dynamical properties of such complex systems. As noted in BID5, an important requirement to effectively learn over such dynamical systems is the ability to express the dynamical processes at different scales. We propose that any dynamic graph must be minimally expressed as a of two fundamental processes evolving at different time scales: Association Process (dynamics of the network), that brings change in the graph structure and leads to long lasting information exchange between nodes; and Communication Process (dynamics on the network), that relates to activities between (not necessarily connected) nodes which leads to temporary information flow between them BID15 BID1. We, then, posit our goal of learning node representations as modeling a latent mediation process that bridges the above two observed processes such that learned representations drive the complex temporal dynamics of both processes and these processes subsequently lead to the nonlinear evolution of node representations. Further, the information propagated across the graph is governed by the temporal dynamics of communication and association histories of nodes with its neighborhood. For instance, in a social network, when a node's neighborhood grows, it changes that node's representation which in turn affects her social interactions (association → embedding → communication). Similarly, when node's interaction behavior changes, it affects the representation of her neighbors and herself which in turn changes the structure and strength of her connections due to link addition or deletion (communication → embedding → association). We call this phenomenon -evolution through mediation and illustrate it graphically in FIG0.In this work, we propose a novel representation learning framework for dynamic graphs, DyRep, to model interleaved evolution of two observed processes through latent mediation process expressed above and effectively learn richer node representations over time. Our framework ingests dynamic graph information in the form of association and communication events over time and updates the node representations as they appear in these events. We build a two-time scale deep temporal point process approach to capture the continuous-time fine-grained temporal dynamics of the two observed processes. We further parameterize the conditional intensity function of the temporal point process with a deep inductive representation network that learns functions to compute node representations. Finally, we couple the structural and temporal components of our framework by designing a novel Temporal Attention Mechanism, which induces temporal attentiveness over neighborhood nodes using the learned intensity function. This allows to capture highly interleaved and nonlinear dynamics governing node representations over time. We design an efficient unsupervised training procedure for end-to-end training of our framework. We demonstrate consistent and significant improvement over state-of-the-art representative baselines on two real-world dynamic graphs for the tasks of dynamic link prediction and time prediction. We further present an extensive qualitative analysis through embedding visualization and ablation studies to discern the effectiveness of our framework. Representation Learning approaches for static graphs either perform node embedding BID4 BID17;; a; BID15 BID14 or sub-graph embedding (; ; which can also utilize convolutional neural networks (; BID3 . Among them, GraphSage (a) is an inductive method for learning functions to compute node representations that can be generalized to unseen nodes. Most of these approaches only work with static graphs or can model evolving graphs without temporal information. Dynamic network embedding is pursued through various techniques such as matrix factorization , structural properties , CNN-based approaches , deep recurrent models BID14, and random walks . There exists a rich body of literature on temporal modeling of dynamic networks , that focus on link prediction tasks but their goal is orthogonal to our work as they build task specific methods and do not focus on representation learning. Authors in BID14 ) proposed models of learning dynamic embeddings but none of them consider time at finer level and do not capture both topological evolution and interactions simultaneously. In parallel, research on deep point process models include parametric approaches to learn intensity BID9 ) using recurrent neural networks and GAN based approaches to learn intensity functions . More detailed related works are provided in Appendix F. Stochastic point processes BID7 are random processes whose realization comprises of discrete events in time, t 1, t 2,.... A temporal point process is one such stochastic process that can be equivalently represented as a counting process, N (t), which contains the number of events up to time t. The common way to characterize temporal point processes is via the conditional intensity function λ(t), a stochastic model of rate of happening events given the previous events. Formally, λ(t)dt is the conditional probability of observing an event in the tiny window DISPLAYFORM0, where T (t) = t k |t k < t is history until t. Similarly, for t > t n and given history T = t 1,..., t n, we characterize the conditional probability that no event happens during [t n, t) as S(t|T) = exp − in an event. t represents time of the event. k ∈ {0, 1} and we use k = 0 to signify events from the topological evolution process (association) and k = 1 to signify events from node interaction process (communication). Persistent edges in the graph only appear through topological events while interaction events do not contribute them. Hence, k represents an abstraction of scale (evolution rate) associated with processes that generate topological (dynamic of the network) and interaction events (dynamic on the network) respectively. We then represent complete set of P observed events ordered by time in window DISPLAYFORM1. Here, t p ∈ R +, 0 ≤ t p ≤ T. Appendix B discusses a marked point process view of such an event set. Node Representation-Let z v ∈ R d represent d-dimensional representation of node v. As the representation evolve over time, we qualify them as function of time: z v (t) -the representation of node v being updated after an event involving v at time t. We use z v (t) for most recently updated embedding of node v just before t. Dynamic Graph Setting. Let G t0 = (V t0, E t0) be the initial snapshot of a graph at time t 0. Please note that G t0 may be empty or it may contain an initial structure (association edges) but it will not have any communication history. Our framework observes evolution of graph as a stream of events O and hence any new node will always be observed as a part of such an event. This will induce a natural ordering over nodes as available from the data. As our method is inductive, we never learn node-specific representations and rather learn functions to compute node representations. In this work, we only support growth of network i.e. we only model addition of nodes and structural edges and leave deletion as future work. Further, for general description of the model, we will assume that an edge in the graph do not have types and nodes do not have attributes but we discuss the details on how to use our model to accommodate these features in Appendix B. The key idea of DyRep is to build a unified architecture that can ingest evolving information over graphs and effectively model the evolution through mediation phenomenon described in Section 1. To achieve this, we design a two-time scale temporal point process model of observed processes and parameterize it with an inductive representation network which subsequently models the latent mediation process of learning node representations. The rationale behind our framework is that the observed set of events are the realizations of the nonlinear dynamic processes governing the changes in topological structure of graph and interactions between the nodes in the graph. Now, when an event is observed between two nodes, information flows from the neighborhood of one node to the other and affects the representations of the nodes accordingly. While a communication event (interaction) only propagates local information across two nodes, an association event changes the topology and thereby has more global effect. The goal is to learn node representations that encode information evolving due to such local and global effects and further drive the dynamics of the observed events.3.1 MODELING TWO-TIME SCALE OBSERVED GRAPH DYNAMICS The observations over dynamic graph contain temporal point patterns of two interleaved complex processes in the form of communication and association events respectively. At any time t, the occurrence of an event, from either of these processes, is dependent on the most recent state of the graph, i.e., two nodes will participate in any event based on their most current representations. Given an observed event p = (u, v, t, k), we define a continuous-time deep model of temporal point process using the conditional intensity function λ u,v k (t) that models the occurrence of event p between nodes u and v at time t: λ DISPLAYFORM0 wheret signifies the timepoint just before current event. The inner function g k (t) computes the compatibility of the most recently updated representations of two nodes, z u (t) and z v (t) as follows: DISPLAYFORM1 [;] signifies concatenation and ω k ∈ R 2d serves as the model parameter that learns time-scale specific compatibility. g k (t) is a function of node representations learned through a representation network described in Section 3.2. This network parameterizes the intensity function of the point process model which serves as a unifying factor. Note that the dynamics are not two simple point processes dependent on each other, but, they are related through the mediation process and in the embedding space. Further, a well curated attention mechanism is employed to learn how the past drives future. The choice of outer function f k needs to account for two critical criteria: 1) Intensity needs to be positive. 2) As mentioned before, the dynamics corresponding to communication and association processes evolve at different time scales. To account for this, we use a modified version of softplus function parameterized by a dynamics parameter ψ k to capture this timescale dependence: DISPLAYFORM2 where, x = g(t) in our case and ψ k (> 0) is scalar time-scale parameter learned as part of training. ψ k corresponds to the rate of events arising from a corresponding process. In 1D event sequences, the formulation in corresponds to the nonlinear transfer function in . We build a deep recurrent architecture that parameterizes the intensity function in Eq. and learns functions to compute node representations. Specifically, after an event has occurred, the representation of both the participating nodes need to be updated to capture the effect of the observed event based on the principles of:Self-Propagation. Self-propagation can be considered as a minimal component of the dynamics governing an individual node's evolution. A node evolves in the embedded space with respect to its previous position (e.g. set of features) and not in a random fashion. Exogenous Drive. Some exogenous force may smoothly update the node's current features during the time interval (e.g. between two global events involving that node).Localized Embedding Propagation. Two nodes involved in an event form a temporary (communication) or a permanent (association) pathway for the information to propagate from the neighborhood of one node to the other node. This corresponds to the influence of the nodes at second-order proximity passing through the other node participating in the event (See Appendix A for pictorial depiction).To realize the above processes in our setting, we first describe an example setup: Consider nodes u and v participating in any type of event at time t. Let N u and N v denote the neighborhood of nodes u and v respectively. We discuss two key points here: 1) Node u serves as a bridge passing information from N u to node v and hence v receives the information in an aggregated form through u. 2) While each neighbor of u passes its information to v, the information that node u relays is governed by an aggregate function parametrized by u's communication and association history with its neighbors. With this setup, for any event at time t, we update the embeddings for both nodes involved in the event using a recurrent architecture. Specifically, for p-th event of node v, we evolve z v as: DISPLAYFORM0 where, h u struct ∈ R d is the output representation vectors obtained from aggregator function on node u's neighborhood and z v (t v p) is the recurrent state obtained from the previous representation of node v. t p is time point of current event,t p signifies the timepoint just before current event andt v p represent time point of previous event for node v. z v (t v p = 0), the initial representation of a node v may be initialized either using input node features from dataset or random vector as per the setting. Eq. 4 is a neural network based functional form parameterized by DISPLAYFORM1 that govern the aggregate effect of all the three inputs (graph structure, previous embedding and exogenous feature) respectively to compute representations. The above formulation is inductive (supports unseen nodes) and flexible (supports node and edge types) as discussed in Appendix B. The Localized Embedding Propagation principle above captures rich structural properties based on neighborhood structure which is a key to any representation learning task over graphs. However, for a given node, not all of its neighbors are uniformly important and hence it becomes extremely important to capture information from each neighbor in some weighted fashion. Recently proposed attention mechanisms have shown great success in dealing with variable sized inputs, focusing on the most relevant parts of the input to make decisions. However, existing approaches consider attention as a static quantity. In dynamic graphs, changing neighborhood structure and interaction activities between nodes evolves importance of each neighbor to a node over time, thereby making attention itself a temporally evolving quantity. Further this quantity is dependent on the temporal history of association and communication of neighboring nodes through evolving representations. To this Algorithm 1 Update Algorithm for S and A DISPLAYFORM0, most recently updated A(t) and S(t). Output: A(t) and S(t) DISPLAYFORM1 where i is the other node involved in the event.←{λ computed in Eq. 2} DISPLAYFORM2 where i is the other node involved in the event ←{λ computed in Eq. 2} y w = y w − x; ∀w = i, y w = 0 end if Normalize y and set S j (t) ← y end for return S(t), A(t) end, we propose a novel Temporal Point Process based Attention Mechanism that uses temporal information to compute the attention coefficient for a structural edge between nodes. These coefficient are then used to compute the aggregate quantity (h struct) required for embedding propagation. Let A(t) ∈ R n×n be the adjacency matrix for graph G t at time t. Let S(t) ∈ R n×n be a stochastic matrix capturing the strength between pair of vertices at time t. One can consider S as a selection matrix that induces a natural selection process for a node -it would tend to communicate more with other nodes that it wants to associate with or has recently associated with. And it would want to attend less to non-interesting nodes. We start with following implication required for the construction of h u struct in: For any two nodes u and v at time t, S uv (t) ∈ if A uv (t) = 1 and S uv (t) = 0 if A uv (t) = 0. Denote N u (t) = {i : A iu (t) = 1} as the 1-hop neighborhood of node u at time t. To formally capture the difference in the influence of different neighbors, we propose a novel conditional intensity based attention layer that uses the matrix S to induce a shared attention mechanism to compute attention coefficients over neighborhood. Specifically, we perform localized attention for a given node u and compute the coefficients pertaining to the 1-hop neighbors i of node u as: DISPLAYFORM3, where q ui signifies the attention weight for the neighbor i at time t and hence it is a temporally evolving quantity. These attention coefficients are then used to compute the aggregate information h u struct (t) for node u by employing an attended aggregation mechanism across neighbors as follows: DISPLAYFORM4 are parameters governing the information propagated by each neighbor of u. z i (t) ∈ R d is the most recent embedding for node i. The use of max operator is inspired from learning on general point sets . By applying max-pooling operator element-wise, the model effectively captures different aspects of the neighborhood. We found max to work slightly better as it considers temporal aspect of neighborhood which would be amortized if mean is used instead. Connection to Neural Attention over Graphs. Our proposed temporal attention layer shares the motivation of recently proposed Graph Attention Networks (GAT) (Veličković et al., 2018) and Gated Attention Networks (GaAN) in the spirit of applying non-uniform attention over neighborhood. Both GAT and GaAN have demonstrated significant success in static graph setting. GAT advances GraphSage (a) by employing multi-head non-uniform attention over neighborhood and GaAN advances GAT by applying different weights to different heads in the multi-head attention formulation. The key innovation in our model is the parameterization of attention mechanism by a point process based temporal quantity S that is evolving and drives the impact that each neighbor has on the given node. Further, unlike static methods, we use these attention coefficients as input to the aggregator function for computing the temporal-structural effect of neighborhood. Finally, static methods use multi-head attention to stabilize learning by capturing multiple representation spaces but this is an inherent property in our layer as representations and event intensities update over time and hence new events help capture multiple representation spaces. Construction and Update of S. We construct a single stochastic matrix S (used to parameterize attention in the earlier section) to capture complex temporal information. At the initial timepoint t = t 0, we construct S(t 0) directly from A(t 0). Specifically, for a given node v, we initialize the elements of corresponding row vector S v (t 0) as: DISPLAYFORM5 After observing an event o = (u, v, t, k) at time t > t 0, we make updates to A and S as per the observation of k. Specifically, A only gets updated for association events (k=0, change in structure). Note that S is parameter for a structural temporal attention which means temporal attention is only applied on structural neighborhood of a node. Hence, the values of S are only updated/active in two scenarios: a) the current event is an interaction between nodes which already has structural edge (A uv (t) = 1 and k = 1) and b) the current event is an association event (k = 0). Given a neighborhood of node u, b represents (base) attention for each edge which is uniform attention based on neighborhood size. Whenever an event involving u occurs, this attention changes in following ways: For case (a), the attention value for corresponding S entries are updated using the intensity of the event. For case (b), repeat same as (a) but also adjust the attention (by b − b, b and b being the new and old attention respectively) for edge with other neighbors as the neighborhood size grows in this case. From mathematical viewpoint, this update resembles a standard temporal point process formulation where the term coming from b serves as attention while λ can be viewed as endogenous intensity based attention. Algorithm 1 outlines complete update scenarios. In the directed graph case, updates to A will not be symmetric, which will subsequently affect the neighborhood structure and attention flow for a node. Appendix A provides a pictorial depiction of the complete DyRep framework discussed in this section. We provide an extensive ablation study in Appendix C that can help discern the contribution of all the above components in achieving our goal. The complete parameter space for the current model is DISPLAYFORM0 For a set O of P observed events, we learn these parameters by minimizing the negative log likelihood: DISPLAYFORM1 represent the intensity of event at time t and Λ(τ) = n u=1 n v=1 k∈{0,1} λ u,v k (τ) represent total survival probability for events that do not happen. While it is intractable (will require O(n 2 k) time) and unnecessary to compute the integral in the log-likelihood equation for all possible non-events in a stochastic setting, we can locally optimize L using mini-batch stochastic gradient descent where we estimate the integral using novel sampling technique. Algorithm 2 in Appendix H adopts a simple variant of Monte Carlo trick to compute the survival term of log-likelihood equation. Specifically, in each mini-batch, we sample non-events instead of considering all pairs of non-events (which can be millions). Let m be the mini-batch size and N be the number of samples. The complexity of Algorithm 2 will then be O(2mkN) for the batch where the factor of 2 accounts for the update happening for two nodes per event which demonstrates linear scalability in number of events which is desired to tackle web-scale dynamic networks . The overall training procedure is adopted from BID14 where the Backpropagation Through Time (BPTT) training is conducted over a global sequence, thereby maintaining the dependencies between events across sequences while avoiding gradient related issues. Implementation details are left to Appendix G. #Communications: 604649 and Clustering Coefficient: 0.087. These datasets cover a range of configurations as Social Dataset is a small network with high clustering coefficient and over 2M events. In contrast, Github dataset forms a large network with low clustering coefficient and sparse events thus allowing us to test the robustness of our model. Further, Github dataset contains several unseen nodes which were never encountered during training. We study the effectiveness of DyRep by evaluating our model on tasks of dynamic link prediction and event time prediction tasks:Dynamic Link Prediction. When any two nodes in a graph has increased rate of interaction events, they are more likely to get involved in further interactions and eventually these interactions may lead to the formation of structural link between them. Similarly, formation of the structural link may lead to increased likelihood of interactions between newly connected nodes. To understand, how well our model captures these phenomenon, we ask questions like: Which is the most likely node u that would undergo an event with a given node v governed by dynamics k at time t? The conditional density of such and event at time t can be computed: DISPLAYFORM0 λ(s)ds, wheret is the time of the most recent event on either dimension u or v. We use this conditional density to find most likely node. For a given test record (u, v, t, k), we replace v with other entities in the graph and compute the density as above. We then rank all the entities in descending order of the density and report the rank of the ground truth entity. Please note that the latest embeddings of the nodes update even during the test while the parameters of the model remaining fixed. Hence, when ranking the entities, we remove any entities that creates a pair already seen in the test. We report Mean Average Rank (MAR) and HITS(@10) metric for dynamic link prediction. Event Time Prediction. This is a relatively novel application where the aim is to compute the next time point when a particular type of event (structural or interaction) can occur. Given a pair of nodes (u, v) and event type k at time t, we use the above density formulation to compute conditional density at time t. The next time pointt for the event can then be computed as:t = ∞ t tf u,v k (t)dt where the integral does not have an analytic form and hence we estimate it using Monte Carlo trick. For a given test record (u, v, t, k), we compute the next time this communication event may occur and report Mean Absolute Error (MAE) against the ground truth. GAT is designed for supervised learning. In Appendix A (Ablation studies), we show on one version where we only update attention based on Association events which is temporal analogous to GAT.Event Time Prediction. We compare our model against (i) Know-Evolve which has the ability to predict time in a multi-relational dynamic graphs (II) Multi-dimensional Hawkes Process (MHP) BID8 model where all events in graph are considered as dyadic.5.4 EVALUATION SCHEME We divide our test sets into n(= 6) slots based on time and report the performance for each time slot, thus providing comprehensive temporal evaluation of different methods. This method of reporting is expected to provide fine-grained insights on how various methods perform over time as they move farther from the learned training history. For dynamic baselines that do not explicitly model time (DynGem, DynTrd, GraphSage) and static baselines (Node2Vec), we adopt a sliding window training approach with warm-start method where we learn on initial train set and test for the first slot. Then we add the data from first slot in the train set and remove equal amount of data from start of train set and retrain the model using the embeddings from previous train. Communication Event Prediction Performance. We first consider the task of predicting communication events between nodes which may or may not have a permanent edge (association) between them. FIG2 (a-b) shows corresponding . Social Evolution. Our method significantly and consistently outperforms all the baselines on both metrics. While the performance of our method drops a little over time, it is expected due to the temporal recency affect on node's evolution. Know-Evolve can capture event dynamics well and shows consistently better rank than others but its performance deteriorates significantly in HITS@10 metric over time. We conjecture that features learned through edge-level modeling limits the predictive capacity of the method over time. The inability of DynGem (snapshot based dynamic), DynTrd and GraphSage (inductive) to significantly outperform Node2vec (transductive static baseline) demonstrate that discrete time snapshot based models fail to capture fine-grained dynamics of communication events. Github dataset. We demonstrate comparable performance with both Know-Evolve and GraphSage on Rank metric. We would like to note that overall performance for all methods on rank metric is low. As we reported earlier, Github dataset is very sparse with very low clustering coefficient which makes it a challenging dataset to learn. It is expected that for a large number of nodes with no communication history, most of the methods will show comparable performance but our method outperforms all others when there is some history available. This is demonstrated by our significantly better performance for HITS@10 metric where we are able to do highly accurate prediction for nodes where we learn better history. This can also be attributed to our model's ability to capture the effect of evolving topology which is missed by Know-Evolve. Finally, we do not see significant decrease in performance of any method over time in this case which can again be attributed to roughly uniform distribution of nodes with no communication history across time slots. Association Event Prediction Performance. Association events are not available for all time slots so FIG2 (c-d) report the aggregate number for this task. For both the datasets, our model significantly outperforms the baselines for this task. Specifically, our model's strong performance on HITS@10 metric across both datasets demonstrates its robustness in accurate learning from various properties of data. On Social evolution dataset, the number of association events are very small (only 485) and hence our strong performance shows that the model is able to capture the influence On the Github dataset, the network grows through new nodes and our model's strong performance across both metric demonstrates its inductive ability to generalize across new nodes across time. An interesting observation was poor performance of DynTrd which seems to be due to its objective to complete triangles. Github dataset is very sparse and has very few possibilities for triadic closure. Time Prediction Performance. Figure 3 demonstrates consistently better performance than stateof-the-art baseline for event time prediction on both datasets. While Know-Evolve models both processes as two different relations between entities, it does not explicitly capture the variance in the time scales of two processes. Further, Know-Evolve does not consider influence of neighborhood which may lead to capturing weaker temporal-structural dynamics across the graph. MHP uses specific parametric intensity function which fails to account for intricate dependencies across graph. Qualitative Performance. We conducted a series of qualitative analysis to understand the discriminative power of evolving embeddings learned by DyRep. We compare our embeddings against GraphSage embeddings as it is state-of-the-art embedding method that is also inductive. Figure 4 (a-b) shows the tSNE embeddings learned by Dyrep (left) and GraphSage (right) respectively. The visualization demonstrates that DyRep embeddings have more discriminative power as it can effectively capture the distinctive and evolving structural features over time as aligned with empirical evidence. Figure 4 (c-d) shows use case of two associated nodes (19 and 26) that has persistent edge but less communication for above two methods. DyRep keeps the embeddings nearby although not in same cluster (cos. dist. -0.649) which demonstrates its ability to learn the association and less communication dynamics between two nodes. For GraphSage the embeddings are on opposite ends of cluster with (cos. dist. -1.964). We provide more extensive analysis in Appendix D. We introduced a novel modeling framework for dynamic graphs that effectively and efficiently learns node representations by posing representation learning as latent mediation process bridging dynamic processes of topological evolution and node interactions. We proposed a deep temporal point process model parameterized by temporally attentive representation network that models these complex and nonlinearly evolving dynamic processes and learns to encode structural-temporal information over graph into low dimensional representations. Our superior evaluation performance demonstrates the effectiveness of our approach compared to state-of-the-art methods. We present this work as the first generic and unified representation learning framework that adopts a novel modeling paradigm for dynamic graphs and support wide range of dynamic graph characteristics which can potentially have many exciting adaptations. As a part of our framework, we also propose a novel temporal point process based attention mechanism that can attend over neighborhood based on the history of communications and association events in the graph. Currently, DyRep does not support network shrinkage due to following reasons: (i) It is difficult to procure data with fine grained deletion time stamps and (ii) The temporal point process model requires more sophistication to support deletion. For example, one can augment the model with a survival process formulation to account for lack of node/edge at future time. Another interesting future direction could be to support encoding higher order dynamic structures. contains h struct which is computed for updating each node involved in the event. For node u, the update will come from h v struct (green flow) and for node v, the update will come from h u struct (red flow). Please note all embeddings are dynamically evolving hence the information flow after every event is different and evolves in a complex fashion. With this mechanism, the information is passed from neighbors of node u to node v and neighbors of node v to node u. (i) Interaction events lead to temporary pathway -such events can occur between nodes which are not connected. In that case, this flow will occur only once but it will not make u and v neighbors of each other (e.g. meeting at a conference). (ii) Topological events lead to permanent pathway -in this case u and v becomes neighbor of each other and hence will contribute to structural properties moving forward (e.g. being academic friends). The difference in number of blue arrows on each side signify different importance of each node to node u and node v respectively. Overall Embedding Update Process. As a starting point, neighborhood only includes nodes connected by a structural edge. On observing an event, we update the embeddings of two nodes involved in the event using Eq 4. For a node u, the first term of Eq 4 (Localized Embedding Propagation) requires h struct which is the information that is passed from neighborhood (N v) of node v to node u via node v (one can visualize v as being the message passer from its neighborhood to u). This information is used to update the embedding of node u. However, we posit that node v does not relay equal amount of information from its neighbors to node u. Rather, node v receives its information to be relayed based on its communication and association history with its neighbors (which relates to importance of each neighbor). This requires to compute the attention coefficients on the structural edges between node v and its neighbors. For any edge, we want this coefficient to be dependent on rate of events between the two nodes (thereby emulating real world phenomenon that one gains more information from people one interacts more with). Hence, we parameterize our attention module with the temporal point process parameter S uv. Algorithm 1 outlines the process of computing the value of this parameter. where ∈ * ̅ is the node in neighborhood of node u. DISPLAYFORM0 Figure 6: Temporal Point Process based Self-Attention: This figure illustrates the computation of h u struct for node u to pass to node v for the same event described before between nodes u and v at time t with any k. h u struct is computed by aggregating information from neighbors of u. However, Nodes that are closely connected or has higher interactions tend to attend more to each other compared to nodes that are not connected or nodes between which interactions is less even in presence of connection. Further, every node has a specific attention span for other node and therefore attention itself is a temporally evolving quantity. DyRep computes the temporally evolving attention based on association and communication history between connected nodes. The attention coefficient function (q's) is parameterized by S which is computed using the intensity of events between connected nodes. Such attention mechanism allows the evolution of importance of neighbors to a particular node (u in this case) which aligns with real-world phenomenon. Connection to Marked Point Process. From a mathematical viewpoint, for any event e at time t, any information other than the time point can be considered a part of mark space describing the events. Hence, for DyRep, given a one-dimensional timeline, one can consider O = {(u, v, k) p, t p ) P p=1 as a marked process with the triple (u, v, k) representing the mark. However, from machine learning perspective, using a single-dimensional process with such marks does not allow to efficiently and effectively discover or model the structure in the point process useful for learning intricate dependencies between events, participants of the events and dynamics governing those events. Hence, it is often important to extract the information out of the mark space and build an abstraction that helps to discover the structure in point process and make this learning parameter efficient. In our case, this translates to two components:1. The nodes in the graph are considered as dimensions of the point process, thus making it a multi-dimensional point process where an event represents interaction/structure between the dimensions, thus allowing us to explicitly capture dependencies between nodes.2. The topological evolution of networks happen at much different temporal scale than activities on a fixed topology network (e.g. rate of making friends vs liking a post on a social network). However both these processes affect each other's evolution in a complex and nonlinear (c) u has a topological event with node 4. b changes to 0.2. b = 0.25 which is the previous b. Update happens to S u4 and S 4u based on intensity of event. Next attention for all other neighbors of both nodes (We only show for u here) are adjusted to reflect neighborhood size change. The matrix S is used for computing attention and hence does not get updated for interaction events between nodes which do not have an edge (for e.g. pair may have an interaction event S 12 won't be updated as they are not neighbors.fashion. Abstracting k to associate it with these different scales of evolution facilitates to model our purpose of expressing dynamic graphs at two time scales in a principled manner. It also provides an ability to explicitly capture the influential dynamics BID5 of topological evolution on dynamics of network activities and vice versa (through the learned embedding -aka evolution through mediation. Note that this distinction in use of mark information is also important as we learn representations for nodes (dimensions) but not for k. It is important to realize that k representing two different scales of event dynamics is not same as edge or interaction type. For instance, in case of typed persistent edge (e.g. wasbornIn, livesIn) or typed interaction (e.g. visit, fight), one would add type as another component in the mark space to represent an event while k still signifying different dynamic scales. Comparison to BID14. In the similar vein as above, the point process specification of BID14 can also be considered as a marked process that models the typed interaction dynamics at a single time-scale and does not model topological evolution. In contrast to that, our method explicitly models dynamic graph process at two time scales. While both models use a point process based formulation for modeling temporal dynamics, there are several significant methodological differences between the two approaches: Deep Point Process Model -While one can augment the event specification in BID14 ) with additional mark information, that itself is not adequate to achieve DyRep's modeling of dynamical process over graphs at multiple time scales. We employ a softplus function for f k which contains a dynamic specific scale parameter ψ k to achieve this while BID14 ) uses an exponential (exp) function for f with no scale parameter. Their intensity formulation attains a Rayleigh distribution which leads to a specific assumption about underlying dynamics which models fads where intensity of events drop rapidly between events after increasing. Our two-time scale model is more general and induces modularization, where each of two components allow complex, nonlinear and dependent dynamics towards a non-zero steady state intensity. Graph Structure-As shown in (b), the key idea behind representation learning over graphs is to capture both the global position and local neighborhood structural information of node into its representations. Hence, there has been significant research efforts invested in devising methods to incorporate graph structure into the computation of node representation. Aligned with these efforts, DyRep proposes a novel and sophisticated Localized Embedding Propagation principle that dynamically incorporates graph structure from both local neighborhood and faraway nodes (as interactions are allowed between nodes that do not have an edge). Contrary to that, BID14 uses single edge level information, specific to the relational setting, into their representations. Deep Temporal Point Process Based Self-Attention-For learning over graphs, attention has been shown to be extremely valuable as importance of nodes differ significantly relative to each other. The state-of-the-art approaches have focused solely on static graphs with Graph Attention Networks (Veličković et al., 2018) being the most recent one. Our attention mechanism for dynamic graphs present a significant and principled advancement over the existing state-of-the-art Graph based Neural Self-Attention techniques which only support static graphs. As do not incorporate graph structure, they do not use any kind of attention mechanism. Support for Node Attributes and Edge Types. Node types or attributes are supported in our work. In Eq. 4, z v (t p v) induces recurrence on node v's embedding, but when node v is observed for first time, z v (t p v) = x v where x v is randomly initialized or contains the raw node features available in data (which also includes type). One can also add an extra term in Eq. 4 to support high-dimension node attributes. Further, we also support different types of edges. If either the structural edge or an interaction has a type associated with it, our model can trivially support it in Eq. 3 and Eq. 4, first term h struct. Currently, for computing h struct, the formulation is shown to use aggregation over nodes. However, this aggregation can be augmented with edge type information as conventionally done in many representation learning frameworks (b). Further, for more direct effect, Eq 3 can include edge type as third feature vector in the concatenation for computing g k. Support for new nodes. As mentioned in Section 2.3 of the main paper, the data contains a set of dyadic events ordered in time. Hence, each event involves two nodes u and v. A new node will always appear as a part of such an event. Now, as mentioned above, the initial embedding of any new node u is given by z u (t p u) which can be randomly initialized or using the raw feature vector of the node u, x u. This allows the computation of intensity function for the event involving new node in Eq 1. Due to the inductive ability of our framework, we can then compute the embedding of the new node using Eq 4. There are two cases possible: Either one of the two nodes are new or both nodes are new. The mechanism for these two cases work as follows:-Only one new node in observed event -To compute the embedding of new nodes, h struct is computed using neighborhood of the existing (other) node, z(t u 0) s the feature vector of the node or random and drift is 0. To compute the new embedding of existing node, h struct is the feature vector of the new node, self-propation uses the most recent embedding of the node and drift is based on previous time point. -Both nodes in the observed event are new -h struct is the feature vector of the feature vector of the other nodes, z(t u 0) s the feature vector of the node or random and drift is 0. Finally, Algorithm 1 does not require to handle new nodes any differently. As already available in the paper, both A and S are qualified by time and hence the matrices get updated every time. The starting dimension of the two matrices can be specified in two ways: (i) Construct both matrices of dimension = total possible no. of nodes in dataset and make the rows belonging to unseen nodes 0.(ii) Expand the dimensions of matrices as you start seeing new nodes. While we implement the first case, (ii) will be required in real-world streaming scenario. DyRep framework unifies several components that contribute to its effectiveness in learning rich node representation over complex and nonlinear processes in dynamic graphs. In this section, we provide insights on each component and how it is indispensable to the learning mechanism by performing an ablation study on various design choices of our model. Specifically, DyRep can be divided into three main parts: Multi-time scale point process model, Representation Update Formulation and Conditional Intensity Based Attention Mechanism. We focus on design choices available in each component and evaluate them on large github dataset. DyRep in the FIG8 is the full model. Multiple Time-Scale Processes. For this component, we perform two major tests:• DyRep-Comm. In this variant, we make Eq 1., time-scale independent (i.e. remove k) and we train on only Communication Events. But we evaluate on both communication and association events. Please note that this is possible as our framework can compute representations for unseen nodes. Hence during training they will only learn representation parameters based on communication events. It is observed that compared to the full model, the performance of model degrades in prediction for both types of events. But the decline is more prominent for the Association events compared to Communication Events.• DyRep-Assoc. In this variant, similar to above, we make Eq 1., time-scale independent and we train on only Association Events. But we evaluate on both communication and association events. It is observed that compared to the full model, the performance of model degrades in prediction for both types of events. But the decline is more prominent for the Communication events compared to Association Events. The above two experiments show that considering events at a single time scale and not distinguishing between the processes hurt the performance. Although the performance is hurt more when communication events are not considered which may be due to the more availability of communication events due to its rapid frequency. We also performed a small test by training on all events but using a single scale parameter (ψ). The performance for both the dynamics degrades which demonstrates the effectiveness of ψ k.Representation Update Formulation. For this component, we focus on Eq. 4 and switch off the components to observe its effect.• DyRep-No-SP. In this variant, we switch off the self-propagation component and we observe that the overall performance is not hurt significantly by not using self-propagation. In general, this term provides a very weak feature and mainly captures the recurrent evolution of one's own latent features independent of others. It is observed that the deviation has increased for Association events which may point to the reason that there are few nodes who have links but highly varying frequency of communication and hence most of their features are either self-propagated or completely associated with others.• DyRep-No-Struct. In this variant, we remove the structural part of the model and as one would expect, the performance drops drastically in both the scenarios. This provides evidence to the necessity of building sophisticated structural encoders for dynamic graphs. Intensity Attention Mechanism. For this component, we focus on Section 3.2 which builds the novel intensity based attention mechanism. Specifically, we carry following test:• DyRep-No-Att. Here we completely remove the attention from the structural component and we see a significant drop in the performance.• DyRep-S-Comm. In this variant, we focus on Algorithm 1 and we only make update to the S matrix for Communication events but do not do it for Association events. This leads to slightly worse performance which helps to see how the S matrix is helping to mediate the two processes and not considering association events leads to loss of information.• DyRep-S-Assoc. In this variant, we focus on Algorithm 1 and we only make update to the S matrix for Association events but do not do it for Communication events. This leads to a significant drop in performance again validating the need for using both processes but its prominent effect also shows that communication events (dynamics on the network) is We assess the quality of learned embeddings and the ability of model to capture both temporal and structural information. Let t 0 be the time point when train ended. Let t 1 be the timepoint when the first test slot ends. Effect of Association and Communication on Embeddings. We conducted this experiment on Social dataset. We consider three use cases to demonstrate how the interactions and associations between the nodes changed their representations and visualize them to realize the effect.• Nodes that did not have association before test but got linked during first test slot. Nodes 46 and 76 got associated in test between test points 0 and 1. This reduced the cosine distance in both models but DyRep shows prominent effect of this association which should be the case. DyRep reduces the cosine distance from 1.231 to 0.005. Also, DyRep embeddings for these two points belong to different clusters initially but later converge to same cluster. In GraphSage, the cosine distance reduces from 1.011 to 0.199 and the embeddings still remain in original clusters. FIG10 shows the visualization of embeddings at the two time points in both the methods. This demonstrates that our embeddings can capture association events effectively.• Nodes that did not have association but many communication events. Nodes 27 and 70 is such a use case. DyRep embeddings consider the nodes to be in top 5 nearest neighbor of each other, in the same cluster and cosine distance of 0.005 which is aligned with the fact that nodes with large number of events tend to develop similar features over time. • Temporal evolution of DyRep embeddings. In FIG0 we visualize the embedding positions of the nodes (tracked in red) as they evolve through time and forms and breaks from clusters. Static Embedding Approaches. Representation Learning approaches for static graphs can be broadly classified into two categories -Node embedding approaches aim to encode structural information pertaining to a node to produce its low-dimensional representation BID4 BID17;; a; BID15 BID14. As they learn each individual node's representation, they are inherently transductive. Recently, (a) proposed GraphSage, an inductive method for learning functions to compute node representations that can be generalized to unseen nodes. Sub-graph embedding techniques learn to encode higher order graph structures into low dimensional vector representations (; ; . Further, various approaches to use convolutional neural networks (; BID3 BID8 develops extends skip-gram based approaches for network embedding to dynamic setting where the graphs a re observed as discrete time snapshot and the goal is to learn embeddings that can preserve the optimality of skip-gram objective. NetWalk is a discrete-time dynamic embedding approach specifically designed for anomaly detection which uses clique based embedding techniques to learn vertex representations. Recently, BID14 proposed Know-Evolve, a deep recurrent architecture to model multi-relational timestamped edges that addresses the communication process. Unlike our approach, Know-Evolve models all edges at a single timescale, works for setting restricted to relational graphs and uses only edge-level structural information with no attention mechanism. DANE BID14 proposes a network embedding method in dynamic environment but their dynamics consists of change in node's attributes over time and their current work can be considered orthogonal to our approach. proposes a dynamic network formation model to learn node representations by employing a Hawkes process to model the temporal evolution of neighborhood for nodes. This work only considers association events. proposes a continuous time embedding framework that employs a temporal version of traditional random walks in a simple manner to capture temporally evolving neighborhood information. Other models for dynamic networks. There exists a rich body of literature on temporal modeling of dynamic networks that focus on link prediction tasks but their goal is orthogonal to us as they build task specific methods and do not focus on representation learning. Further, there are several approaches in graph mining and temporal relational learning community (; ; BID10) that consider dynamic networks but are orthogonal to our current work. Research on learning dynamic embeddings has also progressed in linguistic community where the aim is to learn temporally evolving word embeddings BID2 ). BID14 ) include some other approaches that propose model of learning dynamic embeddings in graph data but none of these models consider time at finer level and do not capture both topological evolution and interactions. proposes subgraph pattern neural networks that focuses on evolution of subgraphs instead of single nodes and links. They build a novel neural network architecture for supervised learning where the hidden layers represent the subgraph patterns observed in the data and output layer is used to perform prediction. induces a dynamic graph from videos based on the visual correlation of object proposal that spans across the video. They further propose an LSTM based architecture to capture temporal dependencies over this induced graph and perform object detection. proposes a dynamic probabilistic model in bipartite case of user-item recommendation where the goal is to learn the evolution of user and item latent features under the context of Poisson factorization, thus considering the evolution processes of users' and items' latent features as independent of each other. Deep Temporal Point Process Models. Recently, BID9 has shown that fixed parametric form of point processes lead into the model misspecification issues ultimately affecting performance on real world datasets. BID9 therefore propose a data driven alternative to instead learn the conditional intensity function from observed events and thereby increase its flexibility. Following that work, there have been increased attraction in topic of learning conditional intensity function using deep learning and also intensity free approach using GANS for learning with deep generative temporal point process models. G IMPLEMENTATION DETAILS G.1 ADDITIONAL DATASET DETAILS We performed hyper parameter search for best performance for our method and all the baselines and used the following hyper-parameters to obtain the reported : -For social dataset: Num nodes = 100, Num Dynamics = 2, bptt (sequence length) = 200, embed_size = 32, hidden_unit_size = 32, nsamples (for survival) = 5, gradient_clip = 100 and no dropout.-For github dataset: Num nodes = 12328, Num Dynamics = 2, bptt (sequence length) = 300, embed_size = 256, hidden_unit_size = 256, nsamples (for survival) = 5, gradient_clip = 100.For baselines, we used the implementations provided by their authors and we report the range of configurations used for baseline here: max_iter = {1000, 5000, 10000}, bptt = {100, 200, 300}, lr = {0.0005, 0.0050.5, 0.1, 1}, embed_E = {32, 64, 128, 256}, embed_R = {32, 64, 128, 256}, hidden = {32, 64, 128, 256}, warm = 0, t_scale = 0.0001, w_scale = 0.1, num_epochs = {10, 50, 100, 500, 1000}. As mentioned in experiment section, we always train baselines with warmstart in a sliding window training fashion. The code provided by the authors was implemented in C++. GraphSage: The code was implemented in Tensorflow by the authors. We use only the unsupervised train module to generate embeddings. Node2Vec: We use the original python code with few changes in the hyper-parameters. We fix q in

represent the tldr for finding the corresponding scientific article

Models Representation Learning over dynamic graphs as latent hidden process bridging two observed processes of Topological Evolution of and Interactions on dynamic graphs.

represent this text to find a much much longer article about it with say hundreds-thousands of words

This work aims to provide quantitative answers to the relative importance of concepts of interest via concept activation vectors (CAV). In particular, this framework enables non-machine learning experts to express concepts of interest and test hypotheses using examples (e.g., a set of pictures that illustrate  the concept). We show that CAV can be learned given a relatively small set of examples. Hypothesis testing with CAV can answer whether a particular concept (e.g., gender) is more important in predicting a given class (e.g., doctor) than other sets of concepts. Interpreting networks with CAV does not require any retraining or modification of the network.


Question: Represent the scientific article to find a short TLDR:

Question: With the success of modern machine learning, it is becoming increasingly important to understand and control how learning algorithms interact. Unfortunately, negative from game theory show there is little hope of understanding or controlling general n-player games. We therefore introduce smooth markets (SM-games), a class of n-player games with pairwise zero sum interactions. SM-games codify a common design pattern in machine learning that includes some GANs, adversarial training, and other recent algorithms. We show that SM-games are amenable to analysis and optimization using first-order methods. As artificial agents proliferate, it is increasingly important to analyze, predict and control their collective behavior . Unfortunately, despite almost a century of intense research since von , game theory provides little guidance outside a few special cases such as two-player zero-sum, auctions, and potential games (; ; ; von). Nash equilibria provide a general solution concept, but are intractable in almost all cases for many different reasons (; ;). These and other negative suggest that understanding and controlling societies of artificial agents is near hopeless. Nevertheless, human societies -of billions of agents -manage to organize themselves reasonably well and mostly progress with time, suggesting game theory is missing some fundamental organizing principles. In this paper, we investigate how markets structure the behavior of agents. Market mechanisms have been studied extensively . However, prior work has restricted to concrete examples, such as auctions and prediction markets, and strong assumptions, such as convexity. Our approach is more abstract and more directly suited to modern machine learning where the building blocks are neural nets. Markets, for us, encompass discriminators and generators trading errors in GANs and agents trading wins and losses in StarCraft . The paper introduces a class of games where optimization and aggregation make sense. The phrase requires unpacking. "Optimization" means gradient-based methods. Gradient descent (and friends) are the workhorse of modern machine learning. Even when gradients are not available, gradient estimates underpin many reinforcement learning and evolutionary algorithms. "Aggregation" means weighted sums. Sums and averages are the workhorses for analyzing ensembles and populations across many fields. "Makes sense" means we can draw about the gradient-based dynamics of the collective by summing over properties of its members. As motivation, we present some pathologies that arise in even the simplest smooth games. Examples in section 2 show that coupling strongly concave profit functions to form a game can lead to uncontrolled behavior, such as spiraling to infinity and excessive sensitivity to learning rates. Hence, one of our goals is to understand how to'glue together agents' such that their collective behavior is predictable. Section 3 introduces a class of games where simultaneous gradient ascent behaves well and is amenable to analysis. In a smooth market (SM-game), each player's profit is composed of a personal objective and pairwise zero-sum interactions with other players. Zero-sum interactions are analogous to monetary exchange (my expenditure is your revenue), double-entry bookkeeping (credits balance debits), and conservation of energy (actions cause equal and opposite reactions). SM-games explicitly account for externalities. Remarkably, building this simple bookkeeping mechanism into games has strong implications for the dynamics of gradient-based learners. SM-games generalize adversarial games and codify a common design pattern in machine learning, see section 3.1. Section 4 studies SM-games from two points of view. Firstly, from that of a rational, profit-maximizing agent that makes decisions based on first-order profit forecasts. Secondly, from that of the game as a whole. SM-games are not potential games, so the game does not optimize any single function. A collective of profit-maximizing agents is not rational because they do not optimize a shared objective . We therefore introduce the notion of legibility, which quantifies how the dynamics of the collective relate to that of individual agents. Finally, section 5 applies legibility to prove some basic theorems on the dynamics of SM-games under gradient-ascent. We show that (i) Nash equilibria are stable; (ii) that if profits are strictly concave then gradient ascent converges to a Nash equilibrium for all learning rates; and (iii) the dynamics are bounded under reasonable assumptions. The are important for two reasons. Firstly, we identify a class of games whose dynamics are, at least in some respects, amenable to analysis and control. The kinds of pathologies described in section 2 cannot arise in SM-games. Secondly, we identify the specific quantities, forecasts, that are useful to track at the level of individual firms and can be meaningfully aggregated to draw about their global dynamics. It follows that forecasts should be a useful lever for mechanism design. A wide variety of machine learning markets and agent-based economies have been proposed and studied:;;;;; Kakade et al. (2003; 2005);;;;;;;;;. The goal of this paper is different. Rather than propose another market mechanism, we abstract an existing design pattern and elucidate some of its consequences for interacting agents. Our approach draws on work studying convergence in generative adversarial networks (; ; ; ;), related minimax problems , and monotone games (; ;). We consider dynamics in continuous time dw dt = ξ(w) in this paper. Discrete dynamics, w t+1 ← w t + ξ(w) require a more delicate analysis, e.g.. In particular, we do not claim that optimizing GANs and SM-games is easy in discrete time. Rather, our analyis shows that it is relatively easy in continuous time, and therefore possible in discrete time, with some additional effort. The contrast is with smooth games in general, where gradient-based methods have essentially no hope of finding local Nash equilibria even in continuous time. Figure 1: Effect of learning rates in two games. Note: x-axis is log-scale. Left: "half a game", e.g. 2. Right: minimal SM-game, e.g. 3. Top: Both players have same learning rate. Bottom: Second player has 1 8 learning rate of first (which is same as for top). Reducing the learning rate of the second player destabilizes the dynamics in "half a game", whereas the SM-game is essentially unaffected. Vectors are column-vectors. The notations S 0 and v 0 refer to a positive-definite matrix and vector with all entries positive respectively. Rather than losses, we work with profits. Proofs are in the appendix. We use economic terminology (firms, profits, forecasts, and sentiment) even though the examples of SM-games, such as GANs and adversarial training, are taken from mainstream machine learning. We hope the economic terminology provides an invigorating change of perspective. The underlying mathematics is no more than first and second-order derivatives. Smooth games model interacting agents with differentiable objectives. They are the kind of games that are played by neural nets. In practice, the differentiability assumption can be relaxed by replacing gradients with gradient estimates. Definition 1. A smooth game consists in n players [n] = {1, . . ., n}, equipped with twice continuously differentiable profit functions {π i : Player i controls the parameters w i . If players update their actions via simultaneous gradient ascent, then a smooth game yields a dynamical system specified by the differential equation . The setup can be recast in terms of minimizing losses by Smooth games are too general to be tractable since they encompass all dynamical systems. Lemma 1. Every continuous dynamical system on R d, for any d, arises as simultaneous gradient ascent on the profit functions of a smooth game. The next two sections illustrate some problems that arise in simple smooth games. Definition 2. We recall some solution concepts from dynamical systems and game theory: • A stable fixed point 1 w * satisfies ξ(w *) = 0 and v · J(w *) · v < 0 for all vectors v = 0. • A local Nash equilibrium w * has neighborhoods U i of w * i for all i, such that for all w i and all players i. Example 1 below shows that stable fixed points and local Nash equilibria do not necessarily coincide. The notion of classical Nash equilibrium is ill-suited to nonconcave settings. Intuitively, a fixed point is stable if all trajectories sufficiently nearby flow into it. A joint strategy is a local Nash if each player is harmed if it makes a small unilateral deviation. Local Nash differs from the classic definition in two ways. It is weaker, because it only allows small unilateral deviations. This is necessary since players are neural networks and profits are not usually concave. It is also stronger, because unilateral deviations decrease (rather than not increase) profits. A game is a potential game if ξ = ∇φ for some function φ, see for details. Example 1 (potential game). Fix a small > 0. Consider the two-player games with profit functions The game has a unique local Nash equilibrium at w = with π 1 = 0 = π 2. The game is chosen to be as nice as possible: π 1 and π 2 are strongly concave functions of w 1 and w 2 respectively. The game is a potential game since ξ = (w 2 − w 1, w 1 − w 2) = ∇φ for φ(w) = w 1 w 2 − 2 (w 2 1 + w 2 2). Nevertheless, the game exhibits three related problems. Firstly, the Nash equilibrium is unstable. Players at the Nash equilibrium can increase their profits via the joint update w ← + η ·, so π 1 (w) = η(1 − 2) = π 2 (w) > 0. The existence of a Nash equilibrium where players can improve their payoffs by coordinated action suggests the incentives are not well-designed. Secondly, the dynamics can diverge to infinity. Starting at w = and applying simultaneously gradient ascent causes the norm of vector w (t) 2 to increase without limit as t → ∞ -and at an accelerating rate -due to a positive feedback loop between the players' parameters and profits. Finally, players impose externalities on each other. The decisions of the first player affect the profits of the second, and vice versa. Obviously players must interact for a game to be interesting. However, positive feedback loops arise because the interactions are not properly accounted for. In short, simultaneous gradient ascent does not converge to the Nash -and can diverge to infinity. It is open to debate whether the fault lies with gradients, the concept of Nash, or the game structure. In this paper, we take gradients and Nash equilibria as given and seek to design better games. Gradient-based optimizers rarely follow the actual gradient. For example RMSProp and Adam use adaptive, parameter-dependent learning rates. This is not a problem when optimizing a function. Suppose f (w) is optimized with reweighted gradient (∇f) η:= (η 1 ∇ 1 f, . . ., η n ∇ n f) where η 0 is a vector of learning rates. Even though (∇f) η is not necessarily the gradient of any function, it behaves like ∇f because they have positive inner product when ∇f = 0: Parameter-dependent learning rates thus behave well in potential games where the dynamics derive from an implicit potential function ξ(w) = ∇φ(w). Severe problems can arise in general games. 1 use a different notion of stable fixed point that requires J has positive eigenvalues. Example 2 ("half a game"). Consider the following game, where the w 2 -player is indifferent to w 1: The dynamics are clear by inspection: the w 2 -player converges to w 2 = 0, and then the w 1 -player does the same. It is hard to imagine that anything could go wrong. In contrast, behavior in the next example should be worse because convergence is slowed down by cycling around the Nash: Example 3 (minimal SM-game). A simple SM-game, see definition 3, is. Figure 1 shows the dynamics of the games, in discrete time, with small learning rates and small gradient noise. In the top panel, both players have the same learning rate. Both games converge. Example 2 converges faster -as expected -without cycling around the Nash. In the bottom panels, the learning rate of the second player is decreased by a factor of eight. The SM-game's dynamics do not change significantly. In contrast, the dynamics of example 2 become unstable: although player 1 is attracted to the Nash, it is extremely sensitive to noise and does not stay there for long. One goal of the paper is to explain why SM-games are more robust, in general, to differences in relative learning rates. Tools for automatic differentiation (AD) such as TensorFlow and PyTorch include stop gradient operators that stop gradients from being computed. For example, let ). The use of stop gradient means f is not strictly speaking a function and so we use ∇ AD to refer to its gradient under automatic differentiation. which is the simultaneous gradient from example 2. Any smooth vector field is the gradient of a function augmented with stop gradient operators, see appendix D. Stop gradient is often used in complex neural architectures (for example when one neural network is fed into another leading to multiplicative interactions), and is thought to be mostly harmless. Section 2.2 shows that stop gradients can interact in unexpected ways with parameter-dependent learning rates. It is natural to expect individually well-behaved agents to also behave well collectively. Unfortunately, this basic requirement fails in even the simplest examples. Maximizing a strongly concave function is well-behaved: there is a unique, finite global maximum. However, example 1 shows that coupling concave functions can cause simultaneous gradient ascent to diverge to infinity. The dynamics of the game differs in kind from the dynamics of the players in isolation. Example 2 shows that reducing the learning rate of a well-behaved (strongly concave) player in a simple game destabilizes the dynamics. How collectives behave is sensitive not only to profits, but also to relative learning rates. Off-the-shelf optimizers such as Adam modify learning rates under the hood, which may destabilize some games. Let us restrict to more structured games. Take an accountant's view of the world, where the only thing we track is the flow of money. Interactions are pairwise. Money is neither created nor destroyed, so interactions are zero-sum. If we model the interactions between players by differentiable functions g ij (w i, w j) that depend on their respective strategies then we have an SM-game. All interactions are explicitly tracked. There are no externalities off the books. Positive interactions, g ij > 0, are revenue, negative are costs, and the difference is profit. The model prescribes that all firms are profit maximizers. More formally: Definition 3 (SM-game). A smooth market is a smooth game where interactions between players are pairwise zero-sum. The profits have the form The functions f i can act as regularizers. Alternatively, they can be interpreted as natural resources or dummy players that react too slowly to model as players. Dummy players provide firms with easy (non-adversarial) sources of revenue. Humans, unlike firms, are not profit-maximizers; humans typically buy goods because they value them more than the money they spend on them. Appendix C briefly discusses extending the model. SM-games codify a common design pattern: 1. Optimizing a function. A near-trivial case is where there is a single player with profit π 1 (w) = f 1 (w). 2. Generative adversarial networks and related architectures like CycleGANs are zero or near zero sum (; ;). 3. Zero-sum polymatrix games are SM-games where f i (w i) ≡ 0 and g ij (w i, w j) = w i A ij w j for some matrices A ij. Weights are constrained to probability simplices. The games have nice properties including: Nash equilibria are computed via a linear program and correlated equilibria marginalize onto Nash equilibria . 4. Intrinsic curiosity modules use games to drive exploration. One module is rewarded for predicting the environment and an adversary is rewarded for choosing actions whose outcomes are not predicted by the first module . The modules share some weights, so the setup is nearly, but not exactly, an SM-game. 5. Adversarial training is concerned with the minmax problem , y i obtains a star-shaped SM-game with the neural net (player 0) at the center and n adversaries -one per datapoint (x i, y i) -on the arms. 6. Task-suites where a population of agents are trained on a population of tasks, form a bipartite graph. If the tasks are parametrized and adversarially rewarded based on their difficulty for agents, then the setup is an SM-game. 7. Homogeneous games arise when all the coupling functions are equal up to sign (recall An example is population self-play which lives on a graph where g ij (w i, w j):= P (w i beats w j) − 1 2 comes from the probability that policy w i beats w j. Monetary exchanges in SM-games are quite general. The error signals traded between generators and discriminators and the wins and losses traded between agents in StarCraft are two very different special cases. How to analyze the behavior of the market as a whole? Adam Smith claimed that profit-maximizing leads firms to promote the interests of society, as if by an invisible hand (Smith, 1776). More formally, we can ask: Is there a measure that firms collectively increase or decrease? It is easy to see that firms do not collectively maximize aggregate profit (AP) or aggregate revenue (AR): Maximizing aggregate profit would require firms to ignore interactions with other firms. Maximizing aggregate revenue would require firms to ignore costs. In short, SM-games are not potential games; there is no function that they optimize in general. However, it turns out the dynamics of SM-games aggregates the dynamics of individual firms, in a sense made precise in section 4.3. Give an objective function to an agent. The agent is rational, relative to the objective, if it chooses actions because it forecasts they will lead to better outcomes as measured by the objective. In SM-games, agents are firms, the objective is profit, and forecasts are computed using gradients. Firms aim to increase their profit. Applying the first-order Taylor approximation obtains where {h.o.t.} refers to higher-order terms. Firm i's forecast of how profits will change if it modifies production by Forecasts encode how individual firms expect profits to change ceteris paribus 2. How does profit maximizing by individual firms look from the point of view of the market as a whole? Summing over all firms obtains where f v (w) = i f vi (w) is the aggregate forecast. Unfortunately, the left-hand side of Eq. is incoherent. It sums the changes in profit that would be experienced by firms updating their production in isolation. However, firms change their production simultaneously. Updates are not ceteris paribus and so profit is not a meaningful macroeconomic concept. The following minimal example illustrates the problem: Example 4. Suppose π 1 (w) = w 1 w 2 and π 2 (w) = −w 1 w 2. Fix w = (w 1, w 2) and let v = (w 2, −w 1). The sum of the changes in profit expected by the firms, reasoning in isolation, is whereas the actual change in aggregate profit is zero because π 1 (x) + π 2 (x) = 0 for any x. Tracking aggregate profits is therefore not useful. The next section shows forecasts are better behaved. Give a target function to every agent in a collective. The collective is legible, relative to the targets, if it increases or decreases the aggregate target according to whether its members forecast, on aggregate, they will increase or decrease their targets. We show that SM-games are legible. The targets are profit forecasts (note: not profits). Let us consider how forecasts change. Define the sentiment as the directional derivative of the forecast D vi f vi (w) = v i ∇f vi (w). The first-order Taylor expansion of the forecast shows that the sentiment is a forecast about the profit forecast: The perspective of firms can be summarized as: 1. Choose an update direction v i that is forecast to increase profit. 2. The firm is then in one of two main regimes: a. If sentiment is positive then forecasts increase as the firm modifies its productionforecasts become more optimistic. The firm experiences increasing returns-to-scale. b. If sentiment is negative then forecasts decrease as the firm modifies its productionforecasts become more pessimistic. The firm experiences diminishing returns-to-scale. Our main is that sentiment is additive, which means that forecasts are legible: Proposition 2 (forecasts are legible in SM-games). Sentiment is additive Thus, the aggregrate profit forecast f v increases or decreases according to whether individual forecasts f vi are expected to increase or decrease in aggregate. Section 5.1 works through an example that is not legible. Finally, we study the dynamics of gradient-based learners in SM-games. Suppose firms use gradient ascent. Firm i's updates are, infinitesimally, in the direction v i = ξ i (w) so that dwi dt = ξ i (w). Since updates are gradients, we can simplify our notation. Define firm i's forecast as f i (w):= We allow firms to choose their learning rates; firms with higher learning rates are more responsive. Define the η-weighted dynamics ξ η (w):= (η 1 ξ 1, . . ., η n ξ n) and η-weighted forecast as In this setting, proposition 2 implies that Proposition 3 (legibility under gradient dynamics). Fix dynamics dw dt:= ξ η (w). Sentiment decomposes additively: Thus, we can read off the aggregate dynamics from the dynamics of forecasts of individual firms. The pairwise zero-sum structure is crucial to legibility. It is instructive to take a closer look at example 1, where the forecasts are not legible. Suppose π 1 (w) = w 1 w 2 − 2 w 2 1 and π 2 (w) = w 1 w 2 − 2 w 2 2. Then ξ(w) = (w 2 − w 1, w 1 − w 2) and the firms' sentiments are df1 dt = − (w 2 − w 1) 2 and df2 dt = − (w 1 − w 2) 2 which are always non-positive. However, the aggregate sentiment is df dt which for small is dominated by w 1 w 2, and so can be either positive or negative. When w = we have Each firm expects their forecasts to decrease, and yet the opposite happens due to a positive feedback loop that ultimately causes the dynamics to diverge to infinity. We provide three fundamental on the dynamics of smooth markets. Firstly, we show that stability, from dynamical systems, and local Nash equilibrium, from game theory, coincide in SM-games: Theorem 4 (stability). A fixed point in an SM-game is a local Nash equilibrium iff it is stable. Thus, every local Nash equilibrium is contained in an open set that forms its basin of attraction. Secondly, we consider convergence. Lyapunov functions are tools for studying convergence. Given dynamical system dw dt = ξ(w) with fixed point w *, recall that V (w) is a Lyapunov function if: If a dynamical system has a Lyapunov function then the dynamics converge to the fixed point. Aggregate forecasts share properties (i) and (ii) with Lyapunov functions. (i) Shared global minima: f η (w) = 0 iff f η (w) = 0 for all η, η 0, which occurs iff w is a stationary point, ξ i (w) = 0 for all i. (ii) Positivity: f η (w) > 0 for all points that are not fixed points, for all η 0. We can therefore use forecasts to study convergence and divergence across all learning rates: Theorem 5. In continuous time, for all positive learning rates η 0, * is a stable fixed point (S ≺ 0), then there is an open neighborhood U w * where dfη dt (w) < 0 for all w ∈ U \ {w *}, so the dynamics converge to w * from anywhere in U. * is an unstable fixed point (S 0), there is an open neighborhood U w * such that dfη dt (w) > 0 for all w ∈ U \ {w *}, so the dynamics within U are repelled by w *. The theorem explains why SM-games are robust to relative differences in learning rates -in contrast to the sensitivity exhibited by the game in example 2. If a fixed point is stable, then for any dynamics dw dt = ξ η (w), there is a corresponding aggregate forecast f η (w) that can be used to show convergence. The aggregate forecasts provide a family of Lyapunov-like functions. Finally, we consider the setting where firms experience diminishing returns-to-scale for sufficiently large production vectors. The assumption is realistic for firms in a finite economy since revenues must eventually saturate whilst costs continue to increase with production. Theorem 6 (boundedness). Suppose all firms have negative sentiment for sufficiently large values of w i. Then the dynamics are bounded for all η 0. The theorem implies that the kind of positive feedback loops that caused example 1 to diverge to infinity, cannot occur in SM-games. One of our themes is that legibility allows to read off the dynamics of games. We make the claim visually explicit in this section. Let us start with a concrete game. Figure 3AB plots the dynamics of the SM-game in example 5, under two different learning rates for player 1. There is an unstable fixed point at the origin and an ovoidal cycle. Dynamics converge to the cycle from both inside and outside the ovoid. Changing player 1's learning rate, panel B, squashes the ovoid. Panels CD provide a cartoon map of the dynamics. There are two regions, the interior and exterior of the ovoid and the boundary formed by the ovoid itself. In general, the phase space of any SM-game is carved into regions where sentiment dfη dt (w) is positive and negative, with boundaries where sentiment is zero. The dynamics can be visualized as operating on a landscape where height at each point w corresponds to the value of the aggregate forecast f η (w). The dynamics does not always ascend or always descend the landscape. Rather, sentiment determines whether the dynamics ascends, descends, or remains on a level-set. Since sentiment is additive,, the decision to ascend or descend comes down to a weighted sum of the sentiments of the firms. 3 Changing learning rates changes the emphasis given to different firms' opinions, and thus changes the shapes of the boundaries between regions in a relatively straightforward manner. SM-games can thus express richer dynamics than potential games (cycles will not occur when performing gradient ascent on a fixed objective), which still admit a relatively simple visual description in terms of a landscape and decisions about which direction to go (upwards or downwards). Computing the landscape for general SM-games, as for neural nets, is intractable. Machine learning has got a lot of mileage out of treating differentiable modules like plug-and-play lego blocks. This works when the modules optimize a single loss and the gradients chain together seamlessly. Unfortunately, agents with differing objectives are far from plug-and-play. Interacting agents form games, and games are intractable in general. Worse, positive feedback loops can cause individually well-behaved agents to collectively spiral out of control. It is therefore necessary to find organizing principles -constraints -on how agents interact that ensure their collective behavior is amenable to analysis and control. The pairwise zero-sum condition that underpins SM-games is one such organizing principle, which happens to admit an economic interpretation. Our main is that SM-games are legible: changes in aggregate forecasts are the sum of how individual firms expect their forecasts to change. It follows that we can translate properties of the individual firms into guarantees on collective convergence, stability and boundedness in SM-games, see theorems 4-6. Legibility is a local-to-global principle, whereby we can draw qualitative about the behavior of collectives based on the nature of their individual members. Identifying and exploiting games that embed local-to-global principles will become increasingly important as artificial agents become more common. This section provides a physics-inspired perspective on smooth markets. Consider a dynamical system with n particles moving according to the differential equations: The kinetic energy of a particle is mass times velocity squared, mv 2, or in our case energy of i th particle = η where we interpret the learning rate squared η 2 i of particle i as its mass and ξ i as its velocity. The total energy of the system is the sum over the kinetic energies of the particles: For example, in a Hamiltonian game we have that energy is conserved:; for details. Energy is measured in joules (kg · m · s −2). The rate of change of energy with respect to time is power, measured in joules per second or watts (kg · m · s −3). Conservation of energy means that a (closed) Hamiltonian system, in aggregate, generates no power. The existence of an invariant function makes Hamiltonian systems easy to reason about in many ways. Smooth markets are more general than Hamiltonian games in that total energy is not necessarily conserved. Nevertheless, they are much more constrained than general dynamical systems. Legibility, proposition 3, says that the total power (total rate of energy generation) in smooth markets is the sum of the power (rate of energy generation) of the individual particles: Example where legibility fails. Once again, it is instructive to look at a concrete example where legibility fails. Recall the potential game in example 1 with profits and π 2 (w) = w 1 w 2 − 2 w 2 2. and sentiments Physically, the negative sentiments df1 dt < 0 and df2 dt < 0 mean that that each "particle" in the system, considered in isolation, is always dissipating energy. Nevertheless as shown in section 5.1 the system as a whole has df dt which is positive for some values of w. Thus, the system as a whole can generate energy through interaction effects between the (dissipative) particles. Proof of lemma 1. Lemma 1. Every continuous dynamical system on R d, for any d, arises as simultaneous gradient ascent on the profit functions of a smooth game. Proof. Specifically, we mean that every dynamical system of the form Proof of proposition 2. Before proving proposition 2, we first prove a lemma. Lemma 7 (generalized Helmholtz decomposition). The Jacobian decomposes into J(w) = S(w) + A(w) where S(w) and A(w) are symmetric and antisymmetric, respectively, for all w ∈ R d. Proof. Follows immediately. for details and explanation. Proposition 2. Sentiment is additive: Proof. For any collection of updates, we need to show that because A is antisymmetric and S is block-diagonal. Proof of proposition 3. First we prove a lemma. Proof. Observe by direct computation that It is then easy to see that where S = S since S is symmetric. By antisymmetry of A, we have that v A v = 0 for all v. The expression thus simplifies to by the block-diagonal structure of S. Proposition 3 (legibility under gradient dynamics). Fix dynamics Proof. Applying the chain rule obtains that where the second equality follows by construction of the dynamical system as dw dt = ξ η (w). Lemma 8 shows that for all i as required. Proof of theorem 4. Theorem 4. A fixed point in an SM-game is a local Nash equilibrium iff it is stable. Proof. Suppose that w * is a fixed point of the game, that is suppose ξ(w *) = 0. Recall from lemma 7 that the Jacobian of ξ decomposes uniquely into two components J(w) = S(w) + A(w) where S ≡ S is symmetric and A + A ≡ 0 is antisymmetric. It follows that v Jv = v Sv + v Av = v Sv since A is antisymmetric. Thus, w * is a stable fixed point iff S(w *) 0 is negative definite. In an SM-game, the antisymmetric component is arbitrary and the symmetric component is block diagonal -where blocks correspond to players' parameters. That is, S ij = 0 for i = j because the interactions between players i and j are pairwise zero-sum -and are therefore necessarily confined to the antisymmetric component of the Jacobian. Since S is block-diagonal, it follows that S is negative definite iff the submatrices S ii along the diagonal are negative definite for all players i. is strictly concave in the parameters controlled by player i at w *. The follows. Proof of theorem 5. Theorem 5. In continuous time, for all positive learning rates η 0, Proof. We prove the first part. The second follows by a symmetric argument. First, strict concavity implies ii π i is negative definite for all i. Second, since S is block-diagonal, with zeros in all blocks S ij for pairs of players i = j, it follows that S is also negative definite. Observe that for all ξ η = 0 since S is negative definite. Thus, simultaneous gradient ascent on the profits acts to infinitesimally reduce the function f η (w). Since ξ η reduces f η, it will converge to a stationary point satisfying ∇f η = 0. Observe that ∇f η = 0 iff ξ η = 0 since ∇f η = J ξ η and the symmetric component S of the Jacobian is negative definite. Finally, observe that all stationary points of f η, and hence ξ η, are stable fixed points of ξ η because S is negative definite, which implies that the fixed point is a Nash equilibrium. Proof of theorem 6. for the dynamical system defined by dw dt = ξ η. Since we are operating in continuous time, all that is required is to show that f η (w (t) ) = g < g implies that f η (w (t+) ) < g for all sufficiently small > 0. dt (w) < 0 for all w in a sufficiently small ball centered at w (t). In other words, the dynamics dw dt = ξ η reduce f η and the follows. Definition 3 proposes a model of monetary exchange in smooth markets. It ignores some major aspects of actual markets. For example, SM-games do not model inventories, investment, borrowing or interest rates. Moreover, in practice money is typically exchanged in return for goods or serviceswhich are ignored by the model. In this section, we sketch one way to extend SM-games to model the exchange of both money and goods -although still without accounting for inventories, which would more significantly complicate the model. The proposed extension is extremely simplistic. It is provided to indicate how the model's expressive power can be increased, and complications that . Suppose π i (w) = f i (w) + j =i α ij ω ij (w i, w j) − g ij (w i, w j). The functions ω ij measure the amount of goods (say, widgets) that are exchanged between firms i and j. We assume that ω ij + ω ji ≡ 0 since widgets are physically passed between the firms and therefore one firms increase must be the others decrease. For two firms to enter into an exchange it must be that they subjectively value the widgets differently, hence we introduce the parameters α ij. Note that if α ij = 1 for all ij then the model is equivalent to an SM-game. The transaction between firms i and j is net beneficial to both firms i and j if and, simultaneously α ji · ω ji (w i, w j) > g ji (w i, w j). We can interpret the inequalities as follows. First suppose that ω ij and g ij always have the same sign. The assumption is reasonable so long as firms do not pay to give away widgets. Further assume without loss of generality that ω ij and g ij are both greater than zero -in other words, firm i is buying widgets from firm j. The above inequalities can then be rewritten as α ij · ω ij (w i, w j) amount firm i values the widgets > g ij (w i, w j) amount firm i pays and α ji · ω ij (w i, w j) amount j values the widgets < g ij (w i, w j) amount j is paid It follows that both firms benefit from the transaction. Implications for dynamics. The off-block-diagonal terms of the symmetric and anti-symmetric components of the game Jacobian are and A ij = α ij + α ji 2 · ∇ 2 ij ω ij (w i, w j) where it is easy to check that S ij = S ji and A ij + A ji = 0. The off-block-diagonal terms of S has consequences for how forecasts behave: When are near SM-games well-behaved? If α ij = α ji for all i, j then the correction is zero; if α ij ∼ α ji then the corrections due to different valuations of goods will be negligible, and the game should be correspondingly well-behaved. What can go wrong? Eq implies that the dynamics of near SM-games -specifically whether the dynamics are increasing or decreasing the aggregate forecast -cannot be explained in terms of the sum of sentiments of individual terms. The correction terms involve interactions between dynamics of different firms and the (second-order) quantities of goods exchanged. In principle, these terms could be arbitrarily large positive or negative numbers. Concretely, the correction terms involving couplings between dynamics of different firms can lead to positive feedback loops, as in example 1, where the dynamics spiral off to infinity even though both players have strongly concave profit functions. Lemma 9. Any smooth vector field can be constructed as the gradient of a function augmented with stop gradient operators. Proof. Suppose ξ = (∂f1(w) ∂w1,..., f w i, stop gradient(wî) It follows that ∇ AD g(w) = ξ(w) as required.

Represent the short summary for finding the corresponding scientific article (long)

We introduce a class of n-player games suited to gradient-based methods.

We propose a hypothesis for why gradient descent generalizes based on how per-example gradients interact with each other.