Nume

nume

Authors:
(1) Halil Yigit Oksuz, Control Systems Group at Technische Universitat Berlin, Germany and Exzellenzcluster Science of Intelligence, Technische Universitat Berlin, Marchstr. 23, 10587, Berlin, Germany;
(2) Fabio Molinari, Control Systems Group at Technische Universitat Berlin, Germany;
(3) Henning Sprekeler, Exzellenzcluster Science of Intelligence, Technische Universit¨at Berlin, Marchstr. 23, 10587, Berlin, Germany and Modelling Cognitive Processes Group at Technische Universit¨at Berlin, Germany;
(4) Jorg Raisch, Control Systems Group at Technische Universitat Berlin, Germany and Exzellenzcluster Science of Intelligence, Technische Universitat Berlin, Marchstr. 23, 10587, Berlin, Germany. Table of Links Abstract and Introduction Problem Setup Federated fair over-the-air learning (FedAir) Algorithm Convergence Properties Numerical Example Conclusion and References V. NUMERICAL EXAMPLE Notice that the FedAVG algorithm achieves approximately 70 − 75% of classification accuracy after 100000 iterations as it can also be seen in Fig. 1. However, due to the heterogeneity in distribution of the data, we observe that the FedAVG algorithm cannot properly identify the samples of data with labels 0. This can be seen from the confusion matrices in Fig. 2, where the FedAVG model cannot successfully recognize the data labeled as 0, whereas the FedFAir algorithm performs much better by recognizing a large percentage of data, both labelled 0 and 1. nd 1. Additionally, we compare the FedFAir algorithm and the standard FedAVG [1] algorithm in terms of communication efficiency. For the latter, the TDMA scheme is used for communication between agents and the central unit. In this case, individual time slots are allocated for each agent to transmit its parameter vector at each communication round. After receiving parameter vectors, the central unit computes the average of them and sends it back to the agents. Since we consider a system with N = 12 agents, it takes N = 12 time slots per communication round for each agent to transmit its updated parameter vector while only 3 are needed for the FedFAir algorithm (see (13)), independent of the value of N. This makes the execution of one iteration of the FedFAir algorithm N/3 = 4 times faster than the execution of an iteration of the FedAVG algorithm. This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Halil Yigit Oksuz, Control Systems Group at Technische Universitat Berlin, Germany and Exzellenzcluster Science of Intelligence, Technische Universitat Berlin, Marchstr. 23, 10587, Berlin, Germany; (2) Fabio Molinari, Control Systems Group at Technische Universitat Berlin, Germany; (3) Henning Sprekeler, Exzellenzcluster Science of Intelligence, Technische Universit¨at Berlin, Marchstr. 23, 10587, Berlin, Germany and Modelling Cognitive Processes Group at Technische Universit¨at Berlin, Germany; (4) Jorg Raisch, Control Systems Group at Technische Universitat Berlin, Germany and Exzellenzcluster Science of Intelligence, Technische Universitat Berlin, Marchstr. 23, 10587, Berlin, Germany. Authors: Authors: (1) Halil Yigit Oksuz, Control Systems Group at Technische Universitat Berlin, Germany and Exzellenzcluster Science of Intelligence, Technische Universitat Berlin, Marchstr. 23, 10587, Berlin, Germany; (2) Fabio Molinari, Control Systems Group at Technische Universitat Berlin, Germany; (3) Henning Sprekeler, Exzellenzcluster Science of Intelligence, Technische Universit¨at Berlin, Marchstr. 23, 10587, Berlin, Germany and Modelling Cognitive Processes Group at Technische Universit¨at Berlin, Germany; (4) Jorg Raisch, Control Systems Group at Technische Universitat Berlin, Germany and Exzellenzcluster Science of Intelligence, Technische Universitat Berlin, Marchstr. 23, 10587, Berlin, Germany. Table of Links Abstract and Introduction Abstract and Introduction Problem Setup Problem Setup Federated fair over-the-air learning (FedAir) Algorithm Federated fair over-the-air learning (FedAir) Algorithm Convergence Properties Convergence Properties Numerical Example Numerical Example Conclusion and References Conclusion and References V. NUMERICAL EXAMPLE Notice that the FedAVG algorithm achieves approximately 70 − 75% of classification accuracy after 100000 iterations as it can also be seen in Fig. 1. However, due to the heterogeneity in distribution of the data, we observe that the FedAVG algorithm cannot properly identify the samples of data with labels 0. This can be seen from the confusion matrices in Fig. 2, where the FedAVG model cannot successfully recognize the data labeled as 0, whereas the FedFAir algorithm performs much better by recognizing a large percentage of data, both labelled 0 and 1. nd 1. Additionally, we compare the FedFAir algorithm and the standard FedAVG [1] algorithm in terms of communication efficiency. For the latter, the TDMA scheme is used for communication between agents and the central unit. In this case, individual time slots are allocated for each agent to transmit its parameter vector at each communication round. After receiving parameter vectors, the central unit computes the average of them and sends it back to the agents. Since we consider a system with N = 12 agents, it takes N = 12 time slots per communication round for each agent to transmit its updated parameter vector while only 3 are needed for the FedFAir algorithm (see (13)), independent of the value of N. This makes the execution of one iteration of the FedFAir algorithm N/3 = 4 times faster than the execution of an iteration of the FedAVG algorithm. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

Boosting Fairness and Robustness in Over-the-Air Federated Learning: Numerical Example

Table of Links Abstract and 1. Introduction 1.1 Option Pricing 1.2 Asymptotic Notation (Big O) 1.3 Finite Difference 1.4 The Black-Schole Model 1.5 Monte Carlo Simulation and Variance Reduction Techniques 1.6 Our Contribution Literature Review
Methodology 3.1 Model Assumption 3.2 Theorems and Model Discussion Result Analysis
Conclusion and References 1.3 FINITE DIFFERENCE Finite difference methods are numerical techniques used to approximate derivatives and solve differential equations by discretizing the domain into a grid of points. This approach is based on Taylor series expansions, where derivatives are expressed as combinations of function values at nearby points. Consider a function 𝑓(𝑥) and its derivative 𝑓′(𝑥) then finite difference approximation of the derivative at a point 𝑥𝑖 is given by: In this plot, the tangent line represents the true derivative 𝑓 ′ (𝑥0) , Meanwhile, the secant line represents the finite difference approximation. As the step size ℎ decreases, the secant line becomes closer to the tangent line, demonstrating the convergence of the finite difference approximation to the true derivative as ℎ approaches zero. The application of finite difference methods in option pricing allows for more accurate simulations of market dynamics and estimation of option prices. These methods enable practitioners to account for various factors affecting option values, such as changes in asset prices, volatility, and interest rates. Finite difference methods offer flexibility and scalability, making them suitable for pricing various types of options and constructing hedging strategies. Despite their computational complexity, advancements in numerical algorithms and computing power have made finite difference methods increasingly accessible and efficient for option pricing applications [4]. Authors:
(1) Agni Rakshit, Department of Mathematics, National Institute of Technology, Durgapur, Durgapur, India (spiritualagnimath.statml@gmail.com);
(2) Gautam Bandyopadhyay, Department of Management Studies, National Institute of Technology, Durgapur, Durgapur, India (gbandyopadhyay.dms@nitdgp.ac.in);
(3) Tanujit Chakraborty, Department of Science and Engineering & Sorbonne Center for AI, Sorbonne University, Abu Dhabi, United Arab Emirates (tanujit.chakraborty@sorbonne.ae). This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license. Table of Links Abstract and 1. Introduction Abstract and 1. Introduction Abstract and 1. Introduction 1.1 Option Pricing 1.1 Option Pricing 1.2 Asymptotic Notation (Big O) 1.2 Asymptotic Notation (Big O) 1.3 Finite Difference 1.3 Finite Difference 1.4 The Black-Schole Model 1.4 The Black-Schole Model 1.5 Monte Carlo Simulation and Variance Reduction Techniques 1.5 Monte Carlo Simulation and Variance Reduction Techniques 1.6 Our Contribution 1.6 Our Contribution Literature Review Methodology Literature Review Literature Review Literature Review Methodology Methodology 3.1 Model Assumption 3.1 Model Assumption 3.2 Theorems and Model Discussion 3.2 Theorems and Model Discussion Result Analysis Conclusion and References Result Analysis Result Analysis Result Analysis Conclusion and References Conclusion and References Conclusion and References 1.3 FINITE DIFFERENCE Finite difference methods are numerical techniques used to approximate derivatives and solve differential equations by discretizing the domain into a grid of points. This approach is based on Taylor series expansions, where derivatives are expressed as combinations of function values at nearby points. Consider a function 𝑓(𝑥) and its derivative 𝑓′(𝑥) then finite difference approximation of the derivative at a point 𝑥𝑖 is given by: In this plot, the tangent line represents the true derivative 𝑓 ′ (𝑥0) , Meanwhile, the secant line represents the finite difference approximation. As the step size ℎ decreases, the secant line becomes closer to the tangent line, demonstrating the convergence of the finite difference approximation to the true derivative as ℎ approaches zero. The application of finite difference methods in option pricing allows for more accurate simulations of market dynamics and estimation of option prices. These methods enable practitioners to account for various factors affecting option values, such as changes in asset prices, volatility, and interest rates. Finite difference methods offer flexibility and scalability, making them suitable for pricing various types of options and constructing hedging strategies. Despite their computational complexity, advancements in numerical algorithms and computing power have made finite difference methods increasingly accessible and efficient for option pricing applications [4]. Authors: (1) Agni Rakshit, Department of Mathematics, National Institute of Technology, Durgapur, Durgapur, India (spiritualagnimath.statml@gmail.com); (2) Gautam Bandyopadhyay, Department of Management Studies, National Institute of Technology, Durgapur, Durgapur, India (gbandyopadhyay.dms@nitdgp.ac.in); (3) Tanujit Chakraborty, Department of Science and Engineering & Sorbonne Center for AI, Sorbonne University, Abu Dhabi, United Arab Emirates (tanujit.chakraborty@sorbonne.ae). Authors: Authors: (1) Agni Rakshit, Department of Mathematics, National Institute of Technology, Durgapur, Durgapur, India (spiritualagnimath.statml@gmail.com); (2) Gautam Bandyopadhyay, Department of Management Studies, National Institute of Technology, Durgapur, Durgapur, India (gbandyopadhyay.dms@nitdgp.ac.in); (3) Tanujit Chakraborty, Department of Science and Engineering & Sorbonne Center for AI, Sorbonne University, Abu Dhabi, United Arab Emirates (tanujit.chakraborty@sorbonne.ae). This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license. This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license. available on arxiv available on arxiv

Finite Difference Methods: A Numerical Approach to Option Pricing and Derivatives

Authors:
(1) Chengfeng Shen, School of Mathematical Sciences, Peking University, Beijing;
(2) Yifan Luo, School of Mathematical Sciences, Peking University, Beijing;
(3) Zhennan Zhou, Beijing International Center for Mathematical Research, Peking University. Table of Links Abstract and 1. Introduction 2 Model and 2.1 Optimal Stopping and Obstacle Problem 2.2 Mean Field Games with Optimal Stopping 2.3 Pure Strategy Equilibrium for OSMFG 2.4 Mixed Strategy Equilibrium for OSMFG 3 Algorithm Construction and 3.1 Fictitious Play 3.2 Convergence of Fictitious Play to Mixed Strategy Equilibrium 3.3 Algorithm Based on Fictitious Play 3.4 Numerical Analysis 4 Numerical Experiments and 4.1 A Non-local OSMFG Example 4.2 A Local OSMFG Example 5 Conclusion, Acknowledgement, and References 4 Numerical Experiments In this section, we conduct several numerical experiments to demonstrate the effectiveness of the proposed semi-implicit finite difference algorithm (Algorithm 2). Through these experiments, we examine the convergence properties of our algorithm highlighting the implementation of the fictitious play. We demonstrate that our requirement for δn in (3.3) is a sufficient yet unnecessary condition. However, in certain cases where the pure strategy equilibrium may not exist, the iteration method may not converge if the condition (3.3) is violated. 4.1 A Non-local OSMFG Example Setup. In this example, the state of the representative agent belongs to the domain [0, 1]×R. It dynamic is a Brownian motion, i.e. Intuitively, as the agent aims to minimize expected cost, the running cost encourages the agent to remain in the game when its state is below the average state of other remaining agents, while the stopping cost encourages the agent to continue playing for a longer duration. It is easy to check that the cost functions above are equivalent with In Figure 2, log-log plots of error versus iteration numbers are shown for different learning rates δn. For this example, taking δn = 1 leads to the fastest convergence, although with δn = 1 no fictitious play is implemented. The reason for this is that the convergence requirement for the learning rate δn in Definition 3.1 is only a sufficient condition, rather than a necessary one. For problems with a pure strategy equilibrium, the condition in definition 3.1 can be relaxed and a more aggressive learning rate can be taken to obtain faster convergence. However, we would like to stress that we could not know a priori whether a pure strategy equilibrium exists, but the proposed algorithm, which is based on fictitious play, always produces convergence results. This paper is available on arxiv under CC 4.0 license. Authors: (1) Chengfeng Shen, School of Mathematical Sciences, Peking University, Beijing; (2) Yifan Luo, School of Mathematical Sciences, Peking University, Beijing; (3) Zhennan Zhou, Beijing International Center for Mathematical Research, Peking University. Authors: Authors: (1) Chengfeng Shen, School of Mathematical Sciences, Peking University, Beijing; (2) Yifan Luo, School of Mathematical Sciences, Peking University, Beijing; (3) Zhennan Zhou, Beijing International Center for Mathematical Research, Peking University. Table of Links Abstract and 1. Introduction Abstract and 1. Introduction 2 Model and 2.1 Optimal Stopping and Obstacle Problem 2 Model and 2.1 Optimal Stopping and Obstacle Problem 2.2 Mean Field Games with Optimal Stopping 2.2 Mean Field Games with Optimal Stopping 2.3 Pure Strategy Equilibrium for OSMFG 2.3 Pure Strategy Equilibrium for OSMFG 2.4 Mixed Strategy Equilibrium for OSMFG 2.4 Mixed Strategy Equilibrium for OSMFG 3 Algorithm Construction and 3.1 Fictitious Play 3 Algorithm Construction and 3.1 Fictitious Play 3.2 Convergence of Fictitious Play to Mixed Strategy Equilibrium 3.2 Convergence of Fictitious Play to Mixed Strategy Equilibrium 3.3 Algorithm Based on Fictitious Play 3.3 Algorithm Based on Fictitious Play 3.4 Numerical Analysis 3.4 Numerical Analysis 4 Numerical Experiments and 4.1 A Non-local OSMFG Example 4 Numerical Experiments and 4.1 A Non-local OSMFG Example 4.2 A Local OSMFG Example 4.2 A Local OSMFG Example 5 Conclusion, Acknowledgement, and References 5 Conclusion, Acknowledgement, and References 4 Numerical Experiments In this section, we conduct several numerical experiments to demonstrate the effectiveness of the proposed semi-implicit finite difference algorithm (Algorithm 2). Through these experiments, we examine the convergence properties of our algorithm highlighting the implementation of the fictitious play. We demonstrate that our requirement for δ n in (3.3) is a sufficient yet unnecessary condition. However, in certain cases where the pure strategy equilibrium may not exist, the iteration method may not converge if the condition (3.3) is violated. n 4.1 A Non-local OSMFG Example Setup . In this example, the state of the representative agent belongs to the domain [0, 1]×R. It dynamic is a Brownian motion, i.e. Setup Intuitively, as the agent aims to minimize expected cost, the running cost encourages the agent to remain in the game when its state is below the average state of other remaining agents, while the stopping cost encourages the agent to continue playing for a longer duration. It is easy to check that the cost functions above are equivalent with In Figure 2, log-log plots of error versus iteration numbers are shown for different learning rates δn. For this example, taking δn = 1 leads to the fastest convergence, although with δn = 1 no fictitious play is implemented. The reason for this is that the convergence requirement for the learning rate δn in Definition 3.1 is only a sufficient condition, rather than a necessary one. For problems with a pure strategy equilibrium, the condition in definition 3.1 can be relaxed and a more aggressive learning rate can be taken to obtain faster convergence. However, we would like to stress that we could not know a priori whether a pure strategy equilibrium exists, but the proposed algorithm, which is based on fictitious play, always produces convergence results. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Fictitious Play for Mixed Strategy Equilibria in Mean Field Games: Numerical Experiments

Authors:
(1) Chengfeng Shen, School of Mathematical Sciences, Peking University, Beijing;
(2) Yifan Luo, School of Mathematical Sciences, Peking University, Beijing;
(3) Zhennan Zhou, Beijing International Center for Mathematical Research, Peking University. Table of Links Abstract and 1. Introduction 2 Model and 2.1 Optimal Stopping and Obstacle Problem 2.2 Mean Field Games with Optimal Stopping 2.3 Pure Strategy Equilibrium for OSMFG 2.4 Mixed Strategy Equilibrium for OSMFG 3 Algorithm Construction and 3.1 Fictitious Play 3.2 Convergence of Fictitious Play to Mixed Strategy Equilibrium 3.3 Algorithm Based on Fictitious Play 3.4 Numerical Analysis 4 Numerical Experiments and 4.1 A Non-local OSMFG Example 4.2 A Local OSMFG Example 5 Conclusion, Acknowledgement, and References 3.4 Numerical Analysis In this part, our goal is to prove the convergence of algorithm 2 when implicit scheme (3.25) and (3.26) are applied. The convergence analysis mirrors the proof for Theorem 3.1, requiring only adapting the arguments to a discretized version. Definition 3.4 (implicit discretized system for mixed strategy equilibrium) We define the complementary condition will be weaker than the following one Before stating the main result, we present a property of the implicit scheme for obstacle equations: the discretized solution u continuously depends on the discretized source term f. Lemma 3.1 Consider the following discrete obstacle problem: Now we can state the main convergence result in this section. Proof The spirit of the proof is analog to the one in theorem 3.1. We divide the proof into 3 steps just parallel to the proof of theorem 3.1. with equality if and only if 3. We conclude that any cluster point (u∗, m∗) is a solution to (3.29). We first verify that u∗ will satisfy the discretized obstacle problem as follows: This paper is available on arxiv under CC 4.0 license. Authors: (1) Chengfeng Shen, School of Mathematical Sciences, Peking University, Beijing; (2) Yifan Luo, School of Mathematical Sciences, Peking University, Beijing; (3) Zhennan Zhou, Beijing International Center for Mathematical Research, Peking University. Authors: Authors: (1) Chengfeng Shen, School of Mathematical Sciences, Peking University, Beijing; (2) Yifan Luo, School of Mathematical Sciences, Peking University, Beijing; (3) Zhennan Zhou, Beijing International Center for Mathematical Research, Peking University. Table of Links Abstract and 1. Introduction Abstract and 1. Introduction 2 Model and 2.1 Optimal Stopping and Obstacle Problem 2 Model and 2.1 Optimal Stopping and Obstacle Problem 2.2 Mean Field Games with Optimal Stopping 2.2 Mean Field Games with Optimal Stopping 2.3 Pure Strategy Equilibrium for OSMFG 2.3 Pure Strategy Equilibrium for OSMFG 2.4 Mixed Strategy Equilibrium for OSMFG 2.4 Mixed Strategy Equilibrium for OSMFG 3 Algorithm Construction and 3.1 Fictitious Play 3 Algorithm Construction and 3.1 Fictitious Play 3.2 Convergence of Fictitious Play to Mixed Strategy Equilibrium 3.2 Convergence of Fictitious Play to Mixed Strategy Equilibrium 3.3 Algorithm Based on Fictitious Play 3.3 Algorithm Based on Fictitious Play 3.4 Numerical Analysis 3.4 Numerical Analysis 4 Numerical Experiments and 4.1 A Non-local OSMFG Example 4 Numerical Experiments and 4.1 A Non-local OSMFG Example 4.2 A Local OSMFG Example 4.2 A Local OSMFG Example 5 Conclusion, Acknowledgement, and References 5 Conclusion, Acknowledgement, and References 3.4 Numerical Analysis In this part, our goal is to prove the convergence of algorithm 2 when implicit scheme (3.25) and (3.26) are applied. The convergence analysis mirrors the proof for Theorem 3.1, requiring only adapting the arguments to a discretized version. Definition 3.4 (implicit discretized system for mixed strategy equilibrium) We define Definition 3.4 (implicit discretized system for mixed strategy equilibrium) We define the complementary condition the complementary condition will be weaker than the following one will be weaker than the following one Before stating the main result, we present a property of the implicit scheme for obstacle equations: the discretized solution u continuously depends on the discretized source term f . f Lemma 3.1 Consider the following discrete obstacle problem: Lemma 3.1 Consider the following discrete obstacle problem: Now we can state the main convergence result in this section. Proof The spirit of the proof is analog to the one in theorem 3.1. We divide the proof into 3 steps just parallel to the proof of theorem 3.1. Proof with equality if and only if 3. We conclude that any cluster point (u∗, m∗) is a solution to (3.29). We first verify that u∗ will satisfy the discretized obstacle problem as follows: This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Fictitious Play for Mixed Strategy Equilibria in Mean Field Games: Numerical Analysis

Authors:
(1) Enis Chenchene, Department of Mathematics and Scientific Computing, University of Graz;
(2) Hui Huang, Department of Mathematics and Scientific Computing, University of Graz;
(3) Jinniao Qiu, Department of Mathematics and Statistics, University of Calgary. Table of Links Abstract and 1 Introduction 2 Global convergence 2.1 Quantitative Laplace principle 2.2 Global convergence in mean-field law 3 Numerical experiments and 3.1 One-dimensional illustrative example 3.2 Nonlinear oligopoly games with several goods 4 Conclusion, Acknowledgments, Appendix, and References 3 Numerical experiments In this section, we present our numerical experiments, which are performed in Python on a 12thGen. Intel(R) Core(TM) i7–1255U, 1.70–4.70 GHz laptop with 16 Gb of RAM and are available for reproducibility at https://github.com/echnen/CBO-multiplayer. As usual in CBO schemes, we discretize the interacting particle system in (1.2) with a Euler– Maruyama time discretization scheme [34], resulting in the method depicted in Algorithm 1. 3.1 One-dimensional illustrative example 3.1.1 Experimental setup 3.1.2 Results and discussion This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Enis Chenchene, Department of Mathematics and Scientific Computing, University of Graz; (2) Hui Huang, Department of Mathematics and Scientific Computing, University of Graz; (3) Jinniao Qiu, Department of Mathematics and Statistics, University of Calgary. Authors: Authors: (1) Enis Chenchene, Department of Mathematics and Scientific Computing, University of Graz; (2) Hui Huang, Department of Mathematics and Scientific Computing, University of Graz; (3) Jinniao Qiu, Department of Mathematics and Statistics, University of Calgary. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Global convergence 2 Global convergence 2.1 Quantitative Laplace principle 2.1 Quantitative Laplace principle 2.2 Global convergence in mean-field law 2.2 Global convergence in mean-field law 3 Numerical experiments and 3.1 One-dimensional illustrative example 3 Numerical experiments and 3.1 One-dimensional illustrative example 3.2 Nonlinear oligopoly games with several goods 3.2 Nonlinear oligopoly games with several goods 4 Conclusion, Acknowledgments, Appendix, and References 4 Conclusion, Acknowledgments, Appendix, and References 3 Numerical experiments In this section, we present our numerical experiments, which are performed in Python on a 12thGen. Intel(R) Core(TM) i7–1255U, 1.70–4.70 GHz laptop with 16 Gb of RAM and are available for reproducibility at https://github.com/echnen/CBO-multiplayer. As usual in CBO schemes, we discretize the interacting particle system in (1.2) with a Euler– Maruyama time discretization scheme [34], resulting in the method depicted in Algorithm 1. 3.1 One-dimensional illustrative example 3.1.1 Experimental setup 3.1.1 Experimental setup 3.1.2 Results and discussion 3.1.2 Results and discussion This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

A Consensus-Based Algorithm for Non-Convex Multiplayer Games: Numerical Experiments

Author:
(1) Yigit Ege Bayiz, Electrical and Computer Engineering The University of Texas at Austin Austin, Texas, USA (Email: egebayiz@utexas.edu);
(2) Ufuk Topcu, Aerospace Engineering and Engineering Mechanics The University of Texas at Austin Austin, Texas, USA (Email: utopcu@utexas.edu). Table of Links Abstract and Introduction Related Works Preliminaries Optimal Prebunking Problem Deterministic Baseline Policies Temporally Equidistant Prebunking Numerical Results Conclusion and References VII. NUMERICAL RESULTS A. Algorithm Comparison We compare Algorithms 1, 2, and 3 by evaluating their performance on simulated misinformation propagations in large scale-free networks. We simulate the misinformation propagation as an SI process on a Chung-Lu model [23]. where C and γ are tunable parameters. By Lemma 3.0.1 from Fasino et al. [24], this choice for wi guarantees the resulting Chung-Lu model is scale-free. We selected the parameters C and γ by tuning them so that at each step, the resulting SI propagation most closely resembles the daily message propagation in a real social networking platform. To do so, we chose the Twitter WICO dataset [25], which is a collection of timestamped propagations containing tweets/re-tweets, in two misinformation and one non-misinformation categories. We then tuned the the parameters C and γ so that the number of infected users in the simulated SI cascade on the resulting Chung-Lu model matches the misinformation propagation in the WICO dataset. Fig. 1 shows a small example of this Chung-Lu network consisting of 100 users. We test each algorithm by first choosing random user to guard against misinformation, which we call c as before. We then construct a local neighborhood of radius m around c by finding the subgraph containing all users that are at most m graph distance away from c. Fig. 2 shows the distributions of the accumulated maximal cost C(A) across four different choices of m. For each m we repeat the experiment 10 times and plot the mean and the deviations of C(A) across these runs. Fig. 2 shows that Algorithm 3 clearly achieves prebunking with less cost than the baselines, with its average cost being approximately half of the other two algorithms for m ≥ 2. Note that all three algorithms achieve the same cost for m = 1 as the feasibility restrictions force all three algorithms to induce the same policy in this case. That is, their behavior are identical for m = 1. Also note that since the diameter of the original network is 4, we restrict m to be less than 4. B. Effects of Prebunking on the Misinformation Propagation So far we have discussed policies to guard a single user c against misinformation by issuing them prebunks before their corresponding misinformation content. In a social networking platform, however, the goal is often to guard as many users as possible against misinformation. In this paper we mainly focus on optimizing the prebunking delivery to a single user since protecting singular users c extends naturally to protect the entire network, as it is possible to significantly reduce the propagation of misinformation by applying these prebunking algorithms to a selected group of users, inoculating them against misinformation and preventing them from spreading misinformation to users they influence. We test the effect of Algorithm 3 on the misinformation propagation by simulating a misinformation cascade on a Chung-Lu network with 2000 users, using the same parameters as in section VII-A. However, instead of providing prebunks to a single user, we provide prebunks to a small subset of users with maximal expected degrees. We show the resulting misinformation propagation curves in Fig. 3. It is evident that applying Algorithm 3 to deliver prebunks to a small number of nodes significantly delays the propagation of misinformation, at least for the scale-free networks with which we are experimenting. This is not surprising in and of itself, as it is consistent with the existing literature which demonstrates that the shortest path lengths between nodes in a scale-free network is often sensitive to the removal of the highly connected nodes [26], [27]. In addition, prebunking reduces the variance between different misinformation cascades, making their propagation more predictable. This paper is available on arxiv under CC 4.0 license. Author: (1) Yigit Ege Bayiz, Electrical and Computer Engineering The University of Texas at Austin Austin, Texas, USA (Email: egebayiz@utexas.edu); (2) Ufuk Topcu, Aerospace Engineering and Engineering Mechanics The University of Texas at Austin Austin, Texas, USA (Email: utopcu@utexas.edu). Author: Author: (1) Yigit Ege Bayiz, Electrical and Computer Engineering The University of Texas at Austin Austin, Texas, USA (Email: egebayiz@utexas.edu); (2) Ufuk Topcu, Aerospace Engineering and Engineering Mechanics The University of Texas at Austin Austin, Texas, USA (Email: utopcu@utexas.edu). Table of Links Abstract and Introduction Abstract and Introduction Related Works Related Works Preliminaries Preliminaries Optimal Prebunking Problem Optimal Prebunking Problem Deterministic Baseline Policies Deterministic Baseline Policies Temporally Equidistant Prebunking Temporally Equidistant Prebunking Numerical Results Numerical Results Conclusion and References Conclusion and References VII. NUMERICAL RESULTS A. Algorithm Comparison A. Algorithm Comparison We compare Algorithms 1, 2, and 3 by evaluating their performance on simulated misinformation propagations in large scale-free networks. We simulate the misinformation propagation as an SI process on a Chung-Lu model [23]. where C and γ are tunable parameters. By Lemma 3.0.1 from Fasino et al. [24], this choice for wi guarantees the resulting Chung-Lu model is scale-free. We selected the parameters C and γ by tuning them so that at each step, the resulting SI propagation most closely resembles the daily message propagation in a real social networking platform. To do so, we chose the Twitter WICO dataset [25], which is a collection of timestamped propagations containing tweets/re-tweets, in two misinformation and one non-misinformation categories. We then tuned the the parameters C and γ so that the number of infected users in the simulated SI cascade on the resulting Chung-Lu model matches the misinformation propagation in the WICO dataset. Fig. 1 shows a small example of this Chung-Lu network consisting of 100 users. We test each algorithm by first choosing random user to guard against misinformation, which we call c as before. We then construct a local neighborhood of radius m around c by finding the subgraph containing all users that are at most m graph distance away from c. Fig. 2 shows the distributions of the accumulated maximal cost C(A) across four different choices of m. For each m we repeat the experiment 10 times and plot the mean and the deviations of C(A) across these runs. Fig. 2 shows that Algorithm 3 clearly achieves prebunking with less cost than the baselines, with its average cost being approximately half of the other two algorithms for m ≥ 2. Note that all three algorithms achieve the same cost for m = 1 as the feasibility restrictions force all three algorithms to induce the same policy in this case. That is, their behavior are identical for m = 1. Also note that since the diameter of the original network is 4, we restrict m to be less than 4. B. Effects of Prebunking on the Misinformation Propagation B. Effects of Prebunking on the Misinformation Propagation So far we have discussed policies to guard a single user c against misinformation by issuing them prebunks before their corresponding misinformation content. In a social networking platform, however, the goal is often to guard as many users as possible against misinformation. In this paper we mainly focus on optimizing the prebunking delivery to a single user since protecting singular users c extends naturally to protect the entire network, as it is possible to significantly reduce the propagation of misinformation by applying these prebunking algorithms to a selected group of users, inoculating them against misinformation and preventing them from spreading misinformation to users they influence. We test the effect of Algorithm 3 on the misinformation propagation by simulating a misinformation cascade on a Chung-Lu network with 2000 users, using the same parameters as in section VII-A. However, instead of providing prebunks to a single user, we provide prebunks to a small subset of users with maximal expected degrees. We show the resulting misinformation propagation curves in Fig. 3. It is evident that applying Algorithm 3 to deliver prebunks to a small number of nodes significantly delays the propagation of misinformation, at least for the scale-free networks with which we are experimenting. This is not surprising in and of itself, as it is consistent with the existing literature which demonstrates that the shortest path lengths between nodes in a scale-free network is often sensitive to the removal of the highly connected nodes [26], [27]. In addition, prebunking reduces the variance between different misinformation cascades, making their propagation more predictable. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Numerical Analysis of Prebunking Algorithms

Authors:
(1) Iason Ofeidis, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution};
(2) Diego Kiedanski, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution};
(3) Leandros TassiulasLevon Ghukasyan, Activeloop, Mountain View, CA, USA, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven. Table of Links Abstract and Intro
Dataloaders
Experimental Setup
Numerical Results
Discussion
Related Work
Conclusion, Acknowledgments, and References
A. Numerical Results Cont. 4. NUMERICAL RESULTS For the first set of experiments, we evaluated the performance of all libraries when changing the number of workers (see 2) as well as the batch size. These experiments were run in a local server with the following specifications: Intel(R) Core(TM) i9-10900K, 2 x NVIDIA GeForce RTX 3090, and an HDD with 10TB of storage (6GB/s) [5]. We evaluated the three modes: default (single GPU), distributed (two GPUs), and filtering (single GPU) for all possible combinations of 0, 1, and 2 workers. For CIFAR10 and RANDOM, the batch size was either 16, 64, or 128. For CoCo, we used smaller values: 1, 2, and 4. All these experiments used a cutoff of 10 and the variant that runs the model (forward & backward pass). 4.1 Speed as a function of batch size and workers The first thing we notice while examining the experiments is that the variance between libraries depends on the problem and the dataset used. Figure 4 shows one such comparison for CIFAR10 on a single GPU, whereas 5 show the same result for CoCo, also on a single GPU. This was to be expected given that in the latter, the time taken to compute the forward and backward pass dominates the overall running time, which is not the case for image classification. You may also note the overall difference in speed: from 4000 samples per second to only 20. Secondly, we point out that increasing the batch size increases processing speed in almost all cases. However, this is not the case for the number of workers. We can observe in Figure 6 that FFCV performance degrades as the number of workers increases, while Deep Lake plateaus at 1 worker and not 2. One explanation is that the libraries have their own internal algorithms that decide how to span threads and processes as needed. The point above is relevant for users of these libraries, as experience with one of them might not translate well into another one. 4.2 Speed Gains when using DDP A desirable feature of a dataloader is its ability to scale linearly with the number of GPUs. This is not always possible and depends on the internal loading mechanism of each library. We explore how these libraries performed by comparing the speed increase when using one or two GPUs. Figure 7 shows the results for the RANDOM dataset. Each bar represents the maximum speed achieved across all batch sizes, number of workers, and repetitions. In a way, this reflects the maximum speed achievable by the library. We observe that libraries speed up about 40%, less than half of a linear increase on average. Two cases are particularly surprising. On the one hand, Torchdata performs worse with two GPUs than on a single one. On the other hand, FFCV achieved a speed increase of more than theoretically possible. There are several artifacts that can be at play here, but most likely, it is due to the limited number of repetitions we were able to run (due to limited resources). Also, this might indicate a misconfiguration in Torchdata: the documentation on running experiments in multi-GPU environments is limited for most libraries. 4.3 Comparison between with and without forward and backward pass As we discussed when presenting Algorithm 1, we had to decide whether we would incorporate the forward and backward passes into the speed calculation. There are arguments for both. On the one hand, including the forward and backward passes better reflect the algorithm’s actual training time. At the same time, some libraries might preemptively optimize steps normally done during the forward pass, so stopping there would seem as if they take longer than they do. On the other hand, if the time taken by the forward and backward pass is much larger than the time it takes for only loading the data, including that time in the calculation would inevitably hide the difference between libraries. To understand if the behavior change was noticeable, we used the RANDOM dataset to compare the difference in average speed when including the two model operations in the calculation and when not. The results are presented in Figure 8. We can observe that most libraries have a slightly increased speed when excluding the model (except for FFCV, whose performance drops in half), and most importantly, the relative performance among libraries remains almost the same. 4.4 Speed trade-offs when filtering data For our filtering experiments, we selected two classes to keep for CIFAR10 and RANDOM: dog and truck, and 0 and 13, respectively. For CoCO we selected three classes: pizza, couch, cat. We observed that most libraries do not have a good filtering mechanism that avoids iterating over the whole dataset. For example, our PyTorch filtering implementation requires building a custom sampler with the indices of the desired images. This is quite fast for a small dataset but becomes unfeasible for large datasets: filtering CoCo using PyTorch was prohibitively expensive. In general, performance was quite similar when filtering and when not[6]. Similarly to Figure 7, in Figure 9, we can see the slowdown as a result of filtering: even though it was considerable for Torchdata and Webdataset, we saw a reversal of the results when working with the CoCo Dataset. 4.5 Training while streaming over the network Ideally, we could decouple the dataset storage from the machine learning training process and simply connect the database storing our data to the ML framework of choice, regardless of where the two are located. That involves sending the training data over a network and losing considerable speed. With the high costs involved in renting GPU accelerated hardware on the cloud, it might seem that the convenience is not worth it. But is it not? Some of the libraries considered in this paper allow specifying a dataset accessible via the internet: Webdataset, Hub, and Deep Lake are particularly good at this[7]. The question then becomes: how big is the tradeoff between ease of usage and running time? We set up the following experiment to offer some insight into this question. We ran two full epochs of the RANDOM dataset for the three libraries: Hub, Deep Lake, and Webdataset, while changing the origin of the data. Three locations were considered: a local copy in the machine running the experiments’ hard drive, a copy in an S3 bucket (in the closest region to our machine), and a copy stored in MinIO (an open source equivalent of S3 that can be hosted locally) running in a similar machine within the same local network (both machines were connected via WiFi). The experiments’ computer had an Intel(R) Core(TM) i7-7700 CPU @ 3.60GHz, 16 GB of RAM, NVIDIA GeForce RTX 2070 Rev, and a Samsung SSD 850 hard drive with 256 GB of storage. Regarding latency, the Round Trip Time from the workstation running the experiments to the MinIO server (located in the same room and in the same local WiFi) took 59.2 ± 58.5ms (min. 8.8ms), while to the S3-bucket in AWS servers took 17.3 ± 1.3ms (min. 14.8ms). Figure 10 depicts the total running times for the nine experiments, and the white percentages denote the slowdown (increase in running time) compared to the local case. We can observe that even though for Hub and Webdataset there is a significant increase when moving to AWS, Deep Lake managed to maintain almost the same speed with an increase of only 13%. Another helpful insight could be extracted from the result: the MinIO setting shows a slowdown almost twice as bad as the AWS setting, as seen in Figure 10. This output could be explained primarily by the difference in average Round Trip Times shown above, highlighting that local networks (e.g., internal company networks[8]) might not be the most efficient way to host datasets due to their complex configurations and restrictions. Furthermore, this result also indicates that the storage serving the datasets over the network plays a crucial role in enabling remote training and might trigger questions on best practices to serve datasets. Namely, data from S3 is served in parallel from different servers with load balancing while we had access to a single MinIO instance. The plots for all additional experiments can be found in Appendix A. This paper is available on arxiv under CC 4.0 license. [5] https://www.seagate.com/www-content/productcontent/barracuda-fam/barracuda-new/enus/docs/100835983b.pdf [6] in speed. Building the sampler for PyTorch is done upfront, considerably affecting the total running time. [7] Squirrel has this capability, but we did not manage to specify a MinIO address, so we excluded it from the comparison. We had a similar issue with Torchdata. [8] In this case a university network Authors: (1) Iason Ofeidis, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution}; (2) Diego Kiedanski, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution}; (3) Leandros TassiulasLevon Ghukasyan, Activeloop, Mountain View, CA, USA, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven. Authors: Authors: (1) Iason Ofeidis, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution}; (2) Diego Kiedanski, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution}; (3) Leandros TassiulasLevon Ghukasyan, Activeloop, Mountain View, CA, USA, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven. Table of Links Abstract and Intro Dataloaders Experimental Setup Numerical Results Discussion Related Work Conclusion, Acknowledgments, and References A. Numerical Results Cont. Abstract and Intro Abstract and Intro Dataloaders Dataloaders Experimental Setup Experimental Setup Numerical Results Numerical Results Discussion Discussion Related Work Related Work Conclusion, Acknowledgments, and References Conclusion, Acknowledgments, and References A. Numerical Results Cont. A. Numerical Results Cont. 4. NUMERICAL RESULTS For the first set of experiments, we evaluated the performance of all libraries when changing the number of workers (see 2) as well as the batch size. These experiments were run in a local server with the following specifications: Intel(R) Core(TM) i9-10900K, 2 x NVIDIA GeForce RTX 3090, and an HDD with 10TB of storage (6GB/s) [5]. We evaluated the three modes: default (single GPU), distributed (two GPUs), and filtering (single GPU) for all possible combinations of 0, 1, and 2 workers. For CIFAR10 and RANDOM, the batch size was either 16, 64, or 128. For CoCo, we used smaller values: 1, 2, and 4. All these experiments used a cutoff of 10 and the variant that runs the model (forward & backward pass). 4.1 Speed as a function of batch size and workers The first thing we notice while examining the experiments is that the variance between libraries depends on the problem and the dataset used. Figure 4 shows one such comparison for CIFAR10 on a single GPU, whereas 5 show the same result for CoCo, also on a single GPU. This was to be expected given that in the latter, the time taken to compute the forward and backward pass dominates the overall running time, which is not the case for image classification. You may also note the overall difference in speed: from 4000 samples per second to only 20. Secondly, we point out that increasing the batch size increases processing speed in almost all cases. However, this is not the case for the number of workers. We can observe in Figure 6 that FFCV performance degrades as the number of workers increases, while Deep Lake plateaus at 1 worker and not 2. One explanation is that the libraries have their own internal algorithms that decide how to span threads and processes as needed. The point above is relevant for users of these libraries, as experience with one of them might not translate well into another one. 4.2 Speed Gains when using DDP A desirable feature of a dataloader is its ability to scale linearly with the number of GPUs. This is not always possible and depends on the internal loading mechanism of each library. We explore how these libraries performed by comparing the speed increase when using one or two GPUs. Figure 7 shows the results for the RANDOM dataset. Each bar represents the maximum speed achieved across all batch sizes, number of workers, and repetitions. In a way, this reflects the maximum speed achievable by the library. We observe that libraries speed up about 40%, less than half of a linear increase on average. Two cases are particularly surprising. On the one hand, Torchdata performs worse with two GPUs than on a single one. On the other hand, FFCV achieved a speed increase of more than theoretically possible. There are several artifacts that can be at play here, but most likely, it is due to the limited number of repetitions we were able to run (due to limited resources). Also, this might indicate a misconfiguration in Torchdata: the documentation on running experiments in multi-GPU environments is limited for most libraries. 4.3 Comparison between with and without forward and backward pass As we discussed when presenting Algorithm 1, we had to decide whether we would incorporate the forward and backward passes into the speed calculation. There are arguments for both. On the one hand, including the forward and backward passes better reflect the algorithm’s actual training time. At the same time, some libraries might preemptively optimize steps normally done during the forward pass, so stopping there would seem as if they take longer than they do. On the other hand, if the time taken by the forward and backward pass is much larger than the time it takes for only loading the data, including that time in the calculation would inevitably hide the difference between libraries. To understand if the behavior change was noticeable, we used the RANDOM dataset to compare the difference in average speed when including the two model operations in the calculation and when not. The results are presented in Figure 8. We can observe that most libraries have a slightly increased speed when excluding the model (except for FFCV, whose performance drops in half), and most importantly, the relative performance among libraries remains almost the same. 4.4 Speed trade-offs when filtering data For our filtering experiments, we selected two classes to keep for CIFAR10 and RANDOM: dog and truck, and 0 and 13, respectively. For CoCO we selected three classes: pizza, couch, cat. We observed that most libraries do not have a good filtering mechanism that avoids iterating over the whole dataset. For example, our PyTorch filtering implementation requires building a custom sampler with the indices of the desired images. This is quite fast for a small dataset but becomes unfeasible for large datasets: filtering CoCo using PyTorch was prohibitively expensive. In general, performance was quite similar when filtering and when not[6]. Similarly to Figure 7, in Figure 9, we can see the slowdown as a result of filtering: even though it was considerable for Torchdata and Webdataset, we saw a reversal of the results when working with the CoCo Dataset. 4.5 Training while streaming over the network Ideally, we could decouple the dataset storage from the machine learning training process and simply connect the database storing our data to the ML framework of choice, regardless of where the two are located. That involves sending the training data over a network and losing considerable speed. With the high costs involved in renting GPU accelerated hardware on the cloud, it might seem that the convenience is not worth it. But is it not? Some of the libraries considered in this paper allow specifying a dataset accessible via the internet: Webdataset, Hub, and Deep Lake are particularly good at this[7]. The question then becomes: how big is the tradeoff between ease of usage and running time? We set up the following experiment to offer some insight into this question. We ran two full epochs of the RANDOM dataset for the three libraries: Hub, Deep Lake, and Webdataset, while changing the origin of the data. Three locations were considered: a local copy in the machine running the experiments’ hard drive, a copy in an S3 bucket (in the closest region to our machine), and a copy stored in MinIO (an open source equivalent of S3 that can be hosted locally) running in a similar machine within the same local network (both machines were connected via WiFi). The experiments’ computer had an Intel(R) Core(TM) i7-7700 CPU @ 3.60GHz, 16 GB of RAM, NVIDIA GeForce RTX 2070 Rev, and a Samsung SSD 850 hard drive with 256 GB of storage. Regarding latency, the Round Trip Time from the workstation running the experiments to the MinIO server (located in the same room and in the same local WiFi) took 59.2 ± 58.5ms (min. 8.8ms), while to the S3-bucket in AWS servers took 17.3 ± 1.3ms (min. 14.8ms). Figure 10 depicts the total running times for the nine experiments, and the white percentages denote the slowdown (increase in running time) compared to the local case. We can observe that even though for Hub and Webdataset there is a significant increase when moving to AWS, Deep Lake managed to maintain almost the same speed with an increase of only 13%. Another helpful insight could be extracted from the result: the MinIO setting shows a slowdown almost twice as bad as the AWS setting, as seen in Figure 10. This output could be explained primarily by the difference in average Round Trip Times shown above, highlighting that local networks (e.g., internal company networks[8]) might not be the most efficient way to host datasets due to their complex configurations and restrictions. Furthermore, this result also indicates that the storage serving the datasets over the network plays a crucial role in enabling remote training and might trigger questions on best practices to serve datasets. Namely, data from S3 is served in parallel from different servers with load balancing while we had access to a single MinIO instance. The plots for all additional experiments can be found in Appendix A. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv [5] https://www.seagate.com/www-content/productcontent/barracuda-fam/barracuda-new/enus/docs/100835983b.pdf [6] in speed. Building the sampler for PyTorch is done upfront, considerably affecting the total running time. [7] Squirrel has this capability, but we did not manage to specify a MinIO address, so we excluded it from the comparison. We had a similar issue with Torchdata. [8] In this case a university network

An Overview of the Data-Loader Landscape: Numerical Results

ডেটা-লোডার ল্যান্ডস্কেপের একটি ওভারভিউ: সংখ্যাসূচক ফলাফল

Ein Überblick über die Data-Loader-Landschaft: Numerische Ergebnisse

Una descripción general del panorama del cargador de datos: resultados numéricos

Un aperçu du paysage des chargeurs de données : résultats numériques

डेटा-लोडर परिदृश्य का अवलोकन: संख्यात्मक परिणाम

データローダーの概要: 数値結果

Data-Loader 환경 개요: 수치 결과

Uma visão geral do cenário do Data-Loader: resultados numéricos

Обзор ландшафта загрузчиков данных: численные результаты

Veri Yükleyici Ortamına Genel Bakış: Sayısal Sonuçlar

Tổng quan về bối cảnh trình tải dữ liệu: Kết quả bằng số

数据加载器概况：数值结果

Authors:
(1) Iason Ofeidis, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution};
(2) Diego Kiedanski, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution};
(3) Leandros TassiulasLevon Ghukasyan, Activeloop, Mountain View, CA, USA, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven. Table of Links Abstract and Intro
Dataloaders
Experimental Setup
Numerical Results
Discussion
Related Work
Conclusion, Acknowledgments, and References
A. Numerical Results Cont. A. NUMERICAL RESULTS CONT. In this appendix, we include a collection of plots for which we did not have space in the core pages of the article. This paper is available on arxiv under CC 4.0 license. Authors: (1) Iason Ofeidis, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution}; (2) Diego Kiedanski, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution}; (3) Leandros TassiulasLevon Ghukasyan, Activeloop, Mountain View, CA, USA, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven. Authors: Authors: (1) Iason Ofeidis, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution}; (2) Diego Kiedanski, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven {Equal contribution}; (3) Leandros TassiulasLevon Ghukasyan, Activeloop, Mountain View, CA, USA, Department of Electrical Engineering, and Yale Institute for Network Science, Yale University, New Haven. Table of Links Abstract and Intro Dataloaders Experimental Setup Numerical Results Discussion Related Work Conclusion, Acknowledgments, and References A. Numerical Results Cont. Abstract and Intro Abstract and Intro Dataloaders Dataloaders Experimental Setup Experimental Setup Numerical Results Numerical Results Discussion Discussion Related Work Related Work Conclusion, Acknowledgments, and References Conclusion, Acknowledgments, and References A. Numerical Results Cont. A. Numerical Results Cont. A. NUMERICAL RESULTS CONT. In this appendix, we include a collection of plots for which we did not have space in the core pages of the article. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

An Overview of the Data-Loader Landscape: Numerical Results Cont.

ডেটা-লোডার ল্যান্ডস্কেপের একটি ওভারভিউ: সংখ্যাসূচক ফলাফল কনট.

Ein Überblick über die DataLoader-Landschaft: Numerische Ergebnisse, Fortsetzung.

Una descripción general del panorama del cargador de datos: resultados numéricos (cont.)

Un aperçu du paysage des chargeurs de données : résultats numériques, suite.

डेटा-लोडर परिदृश्य का अवलोकन: संख्यात्मक परिणाम जारी।

データローダーの概要: 数値結果の続き。

Data-Loader 환경 개요: 수치 결과 계속.

Uma Visão Geral do Cenário do Data-Loader: Resultados Numéricos Cont.

Обзор ландшафта загрузчиков данных: численные результаты (продолжение).

Veri Yükleyici Ortamına Genel Bir Bakış: Sayısal Sonuçlar (Devamı)

Tổng quan về bối cảnh trình tải dữ liệu: Kết quả số Tiếp theo.

数据加载器概况：数值结果续。

Author:
(1) Yitang Zhang. Table of Links Abstract & Introduction
Notation and outline of the proof
The set Ψ1
Zeros of L(s, ψ)L(s, χψ) in Ω
Some analytic lemmas
Approximate formula for L(s, ψ)
Mean value formula I
Evaluation of Ξ11
Evaluation of Ξ12
Proof of Proposition 2.4
Proof of Proposition 2.6
Evaluation of Ξ15
Approximation to Ξ14
Mean value formula II
Evaluation of Φ1
Evaluation of Φ2
Evaluation of Φ3
Proof of Proposition 2.5 Appendix A. Some Euler products Appendix B. Some arithmetic sums References 9. Evaluation of Ξ12 Thus, in a way similar to the proof of (8.12), we deduce that where It follows by Proposition 7.1 that This yields where with Numerical calculation shows that It follows that This paper is available on arxiv under CC 4.0 license. Author: (1) Yitang Zhang. Author: Author: (1) Yitang Zhang. Table of Links Abstract & Introduction Notation and outline of the proof The set Ψ1 Zeros of L(s, ψ)L(s, χψ) in Ω Some analytic lemmas Approximate formula for L(s, ψ) Mean value formula I Evaluation of Ξ11 Evaluation of Ξ12 Proof of Proposition 2.4 Proof of Proposition 2.6 Evaluation of Ξ15 Approximation to Ξ14 Mean value formula II Evaluation of Φ1 Evaluation of Φ2 Evaluation of Φ3 Proof of Proposition 2.5 Abstract & Introduction Abstract & Introduction Notation and outline of the proof Notation and outline of the proof The set Ψ1 The set Ψ1 Zeros of L(s, ψ)L(s, χψ) in Ω Zeros of L(s, ψ)L(s, χψ) in Ω Some analytic lemmas Some analytic lemmas Approximate formula for L(s, ψ) Approximate formula for L(s, ψ) Mean value formula I Mean value formula I Evaluation of Ξ11 Evaluation of Ξ11 Evaluation of Ξ12 Evaluation of Ξ12 Proof of Proposition 2.4 Proof of Proposition 2.4 Proof of Proposition 2.6 Proof of Proposition 2.6 Evaluation of Ξ15 Evaluation of Ξ15 Approximation to Ξ14 Approximation to Ξ14 Mean value formula II Mean value formula II Evaluation of Φ1 Evaluation of Φ1 Evaluation of Φ2 Evaluation of Φ2 Evaluation of Φ3 Evaluation of Φ3 Proof of Proposition 2.5 Proof of Proposition 2.5 Appendix A. Some Euler products Appendix A. Some Euler products Appendix B. Some arithmetic sums Appendix B. Some arithmetic sums References References 9. Evaluation of Ξ12 Thus, in a way similar to the proof of (8.12), we deduce that where It follows by Proposition 7.1 that This yields where with Numerical calculation shows that It follows that This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Numerical Calculation of Ξ12: Detailed Analysis and Findings

Neural Network for Valuing Bitcoin: Numerical Results, Implementation and Discussion

Stories, News & Mentions about NUME

Nume’s Stories on HackerNoon