Gradient

gradient

The use of gradients is common in modern web design. We see them everywhere from hero backgrounds to illustrations, text colors, borders, hover animations, and many more. Creating them directly in CSS might take a lot of time and would require some knowledge of how different types of gradients are constructed. To help you out in this article, I compiled some of my favorite gradient makers. I will provide you with the direct link to the tools, give you a concise description, and include a screenshot of the tool, so you can get an initial impression on the fly. Web Gradients A free collection of 180 linear gradients that you can use as content backdrops in any part of your website. Easy copy CSS3 cross-browser code, and use it in a moment! Grabient Add up to 6 colors, and change the angle of the gradient with the modern-looking UI. UI-Gradients Browse lots of predefined gradients from the gallery, and edit the gradient direction in the generator. Opensource, add your own gradients via code. HyperColor A curated collection of beautiful Tailwind CSS gradients using the full range of Tailwind CSS colors. Easily copy and paste the class names, CSS, or even save the gradients as an image. Gradient King Browse lots of gradients based on the color theme. Also includes an option to generate the gradient based on uploaded image colors. Option to sign in, and save your favorites. CoolHue Try the Coolhue Gradient Palette Plugin. With it, you can directly access gradient color palettes from right inside your favorite prototyping tools like Sketch App and Figma. GradientHunt Gradient Hunt is a free and open platform for color inspiration with thousands of trendy hand-made color gradients. CSS Gradient Gradient generator with modern-looking UI and lots of customization options. Gradient Png Supports adding up to 5 colors, switching their positions, changing their weight, and other customization options. Random mode to come up with awesome presets. Mycolor.space Generate a CSS Color Gradient with 2 or 3 colors. Change directions and copy the CSS code when ready. Color Gradient CSS color generator for cool backgrounds and UI elements. Gradient Generator Advanced CSS gradient generator by Josh W.Comeau. Lots of customization options such as color mode, angle, and easing curve. CSS Gradient Generator Create linear and radial gradients. Experiment with random color modes and edit gradient directions. Switch between HEX and RGBA modes. Did You Like the Resources? Here's More 👇 Over the previous months, I've compiled The Ultimate Bundle with every resource you need from starting to learn to code to landing your dream tech role! Includes 900+ resources in total, further divided into 99 categories for easier navigation and access! Save 1000s of hours, and focus on what matters! I'm currently offering 50% OFF just for my readers! Don't miss out on this! ⭐ Get it here: Ultimate Resources Bundle to Land a Job in Tech! ⭐ Writing has always been my passion, and it gives me pleasure to help and inspire people. If you have any questions, feel free to reach out! Make sure to receive the best resources, tools, productivity tips, and career growth tips I discover by subscribing to my newsletter! Also, connect with me on Twitter, LinkedIn, and GitHub! Also published here. The use of gradients is common in modern web design. We see them everywhere from hero backgrounds to illustrations, text colors, borders, hover animations, and many more. Creating them directly in CSS might take a lot of time and would require some knowledge of how different types of gradients are constructed. To help you out in this article, I compiled some of my favorite gradient makers. I will provide you with the direct link to the tools, give you a concise description, and include a screenshot of the tool, so you can get an initial impression on the fly. Web Gradients Web Gradients A free collection of 180 linear gradients that you can use as content backdrops in any part of your website. Easy copy CSS3 cross-browser code, and use it in a moment! Grabient Grabient Add up to 6 colors, and change the angle of the gradient with the modern-looking UI. UI-Gradients UI-Gradients Browse lots of predefined gradients from the gallery, and edit the gradient direction in the generator. Opensource, add your own gradients via code. HyperColor HyperColor A curated collection of beautiful Tailwind CSS gradients using the full range of Tailwind CSS colors. Easily copy and paste the class names, CSS, or even save the gradients as an image. Gradient King Gradient King Browse lots of gradients based on the color theme. Also includes an option to generate the gradient based on uploaded image colors. Option to sign in, and save your favorites. CoolHue CoolHue Try the Coolhue Gradient Palette Plugin. With it, you can directly access gradient color palettes from right inside your favorite prototyping tools like Sketch App and Figma. GradientHunt GradientHunt Gradient Hunt is a free and open platform for color inspiration with thousands of trendy hand-made color gradients. CSS Gradient CSS Gradient Gradient generator with modern-looking UI and lots of customization options. Gradient Png Gradient Png Supports adding up to 5 colors, switching their positions, changing their weight, and other customization options. Random mode to come up with awesome presets. Mycolor.space Mycolor.space Generate a CSS Color Gradient with 2 or 3 colors. Change directions and copy the CSS code when ready. Color Gradient Color Gradient CSS color generator for cool backgrounds and UI elements. Gradient Generator Gradient Generator Advanced CSS gradient generator by Josh W.Comeau . Lots of customization options such as color mode, angle, and easing curve. Josh W.Comeau CSS Gradient Generator CSS Gradient Generator Create linear and radial gradients. Experiment with random color modes and edit gradient directions. Switch between HEX and RGBA modes. Did You Like the Resources? Here's More 👇 Over the previous months, I've compiled The Ultimate Bundle with every resource you need from starting to learn to code to landing your dream tech role! Includes 900+ resources in total, further divided into 99 categories for easier navigation and access! Save 1000s of hours, and focus on what matters! I'm currently offering 50% OFF just for my readers! Don't miss out on this! ⭐ Get it here: Ultimate Resources Bundle to Land a Job in Tech ! ⭐ Get it here: Ultimate Resources Bundle to Land a Job in Tech Ultimate Resources Bundle to Land a Job in Tech Writing has always been my passion, and it gives me pleasure to help and inspire people. If you have any questions, feel free to reach out! Make sure to receive the best resources, tools, productivity tips, and career growth tips I discover by subscribing to my newsletter ! my newsletter my newsletter Also, connect with me on Twitter , LinkedIn , and GitHub ! Twitter Twitter LinkedIn LinkedIn GitHub GitHub Also published here . here

Every Web Designer Should Know These 13 Beautiful Gradient Tools 💯👍

In this article I will be giving a intuition of gradient descent and the reason behind moving in the direction opposite to the gradient. mathematical I assume prior knowledge in partial derivatives, ,Taylor Series and a basic understanding of neural networks. vector algebra So let’s dive in. In neural networks we always need to learn the weights and biases from the data we have such that we reach the absolute minimum of the loss function and so we need to have a principled way of reaching the absolute minimum of the loss function. Error Surface Our main objective is to navigate through the error surface inorder to reach a point where the error is less or close to zero. Let us assume θ where w & b are the weights and the biases respectively. θ is an arbitrary point on the error surface.To start with w & b are randomly initialized and this is our starting point. = [ ] w,b θ is a vector of parameters w and b such that θ ∈ R . ² Let us assume Δθ **= [**Δw , Δb] where Δw & Δb are the changes that we make to the weights and biases such that we move in the direction of reduced loss and land up at places where the error is less. Δθ is a vector in the direction of reduced loss. Δθ is a vector of parameters Δw and Δb such that Δθ ∈ R . ² Now we need to move from θ to θ+Δθ such that we move towards the direction of minimum loss. Loss Function If we add up Δθ to θ we obtain a new vector. Let the new vector be θ_new._ Hence as you can see from the figure above the vector θ is moving in the direction of the vector Δθ. But it would be better if we don’t make huge strides towards Δθ although we are interested in moving in that direction.If we take huge strides we have a chance of missing the absolute minimum of the loss function. So instead we take smaller steps towards Δθ. This is governed by a scalar “ η”. The scalar “ η ” is called the learning rate. η is generally less than 1.So we will move in the direction of Δθ scaled down by a factor of η. Hence θ_new =_ θ + η.Δθ where Δθ is the direction of reduced loss. So we start from a random value of θ. And then we move in the direction of Δθ which ensures that our loss decreases. And we need to do this in a cyclic manner to reach the global minimum. But what is Δθ ? And what is the right value for Δθ? Hang on we will get to it. So the answer for the question above comes from Taylor Series. For simpicity lets assume Δθ =u . And here we go. Taylor Series What Taylor Series tells us is that if we are at a certain value of θ and we make a small change to the value of θ then what will be the new value of the loss function. L(θ) is called the loss function. Here ∇L(θ) = [∂L(θ)/∂w , ∂L(θ)/∂b] is the gradient vector which is a collection of partial derivatives with respect to the components of θ. The value of η is usually taken to be less than 1. And that η² <<<1. So we might as well ignore the higher order terms. And we end up with the equation as below. So we have some value of θ and we want to move away from that direction such that the new loss L(θ+ηu) is less than the old loss L(θ). So a desired value for “ u ” is obtained when the following condition holds. This implies, This condition should hold for the vector u that we are trying to choose so that we can be sure that we have chosen a good value for “ u ”. A good value of “ u ” can be obtained if the loss of the new step is less than the loss of the previous step. So the range is ± ||u|| || ∇L(θ)|| .This is just the dot product of u and ∇L(θ). Let us assume β as the angle between the vector u and the gradient vector ∇L(θ).Then we know that, And assuming k = ||u|| || ∇L(θ)|| the inequalities simplify to, We want the difference between the new loss and old loss to be as negative as possible. The more negative it is, the more the loss will decrease. So the dot product of the vector u and ∇L(θ) should be as negative as possible and so should be equal to . The value of cos(β) should be equal to -1 in this case. -k This is in accordance with the condition u.∇L(θ) < 0. The value of cos(β) will be equal to -1 when the angle between the vector u and the gradient is 180°. The direction “u” that we intend to move in should be at 180° with respect to the gradient. And this is the reason why need to move in the direction opposite to the Gradient. So what the gradient descent rule tells us is that if we are at a particular value of θ and if we want to move to a new value of θ such that the new loss is less than the current loss then we should move in the direction opposite to the gradient. Now these are the parameter update equations. And they follow what we have discussed so far. I guess this article would have given you a mathematical intuition of gradient descent and the reason behind moving in the direction opposite to the gradient. Any feedback will be appreciated. Citation: https://onlinecourses.nptel.ac.in/noc18_cs41

The reason behind moving in the direction opposite to the Gradient

Gradient Descent. Image taken from - https://community.deeplearning.ai/t/difference-between-rmsprop-and-adam/310187 What Is Gradient Descent? Gradient descent is like hiking downhill with your eyes closed, following the slope until you hit the bottom (or at least a nice flat spot to rest). Technically, it is a method to minimize an objective function F(θ), parameterized by a model’s parameters θ∈Rn, by updating them in the opposite direction of the gradient ∇F(θ). The size of each step is controlled by the learning rate α. Think of α as the cautious guide who ensures you don’t tumble down too fast. If this sounds like Greek, feel free to check out my previous article, Quick Glance At Gradient Descent In Machine Learning — I promise it’s friendlier than it sounds! 🙂 Circle back: An objective function is the mathematical formula or function that your model aims to minimize (or maximize, depending on the goal) during training. It represents a measure of how far off your model’s predictions are from the actual outcomes or desired values.
For example:In machine learning, it could be a loss function like Mean Squared Error (MSE) for regression tasks or Cross-Entropy Loss for classification tasks.The objective function maps the model’s predictions to a numerical value, where smaller values indicate better performance.In simpler terms:It’s like a “fitness tracker” for your model — it tells you how good or bad your model’s predictions are. During optimization, gradient descent helps adjust the model’s parameters θ to reduce this value step by step, moving closer to an ideal solution. Got it? 😄 Gradient Descent Variants Gradient descent isn’t a one-size-fits-all deal. It comes in three variants, each like a different hiker — some take the scenic route, others sprint downhill, and a few prefer shortcuts (like me 😅). These variants balance accuracy and speed, depending on how much data they use to calculate the gradient. 1. Batch Gradient Descent Batch gradient descent, the “all-or-nothing” hiker, uses the entire dataset to compute the gradient of the cost function: Imagine stopping to look 👀 at every rock 🪨, tree 🌴, and bird 🕊 before deciding where to place your foot 🦶🏽next. It’s thorough, but not ideal if your dataset is as big as, say, the Amazon rainforest 😩. It’s also not great if you need to learn on the fly — like updating your hiking route after spotting a bear 🐻‍❄️. Code Example: for i in range(nb_epochs):
    params_grad = evaluate_gradient(loss_function, data, params)
    params = params - learning_rate * params_grad Batch gradient descent shines when you have all the time in the world and a dataset that fits neatly into memory. It’s guaranteed to find the global minimum for convex surfaces (smooth hills) or a local minimum for non-convex surfaces (rugged mountains). 2. Stochastic Gradient Descent (SGD) SGD is the “impulsive” hiker who takes one step at a time based on the current terrain: It’s faster because it doesn’t bother calculating gradients for the entire landscape. Instead, it uses one training example at a time. While this saves time, the frequent updates can make SGD look like it’s zigzagging downhill, which can be both exciting and a little chaotic. 😅 Imagine updating your grocery list after each aisle — you get to the essentials faster, but your cart might look wild in the process. However, with a learning rate that slows down over time, SGD can eventually reach the bottom (or the best local minimum). Code Example: for i in range(nb_epochs):
    np.random.shuffle(data)
    for example in data:
        params_grad = evaluate_gradient(loss_function, example, params)
        params = params - learning_rate * params_grad 3. The Hero of the Day: Adam 🙌🏽 Now let’s talk about Adam — the “hiking guru” who combines the wisdom of Momentum and RMSprop. Adaptive Moment Estimation (Adam) is like having a smart guide who tracks the terrain and adjusts your steps based on past experiences and current conditions. It’s the go-to optimizer when you want to train neural networks and still have time for coffee. Why You’ll Love Adam Low Memory Requirements: It’s like carrying a lightweight backpack — efficient but still packed with essentials.


Minimal Hyperparameter Tuning: Adam works well out of the box, so you won’t need to fiddle with too many knobs (just keep an eye on the learning rate).


Practical Use: From improving product recommendations to recognizing images of cats on the internet, Adam powers machine learning systems that make your everyday tech smarter. How Adam Works Adam maintains moving averages of gradients (mt​) and squared gradients (vt​) to adapt learning rates for each parameter: Here’s the cool part: Adam corrects biases to ensure accuracy, and updates parameters using this formula: where m^t and v^t are bias-corrected estimates, and epsilon ϵ is a small number to prevent division by zero. Conclusion Adam is the Swiss Army knife of optimizers — versatile, efficient, and reliable. Whether you’re training neural networks to detect fraud or create next-gen chatbots, Adam helps you get there faster and with fewer headaches. So, embrace Adam, take confident steps, and enjoy the view from the summit of machine learning success! References: https://www.ceremade.dauphine.fr/\~waldspurger/tds/22_23_s1/advanced_gradient_descent.pdf https://www.geeksforgeeks.org/rmsprop-optimizer-in-deep-learning/ Gradient Descent. Image taken from - https://community.deeplearning.ai/t/difference-between-rmsprop-and-adam/310187 Gradient Descent. Image taken from - https://community.deeplearning.ai/t/difference-between-rmsprop-and-adam/310187 What Is Gradient Descent? Gradient descent is like hiking downhill with your eyes closed, following the slope until you hit the bottom (or at least a nice flat spot to rest). Technically, it is a method to minimize an objective function F(θ ), parameterized by a model’s parameters θ∈Rn, by updating them in the opposite direction of the gradient ∇F(θ). objective function F(θ The size of each step is controlled by the learning rate α. Think of α as the cautious guide who ensures you don’t tumble down too fast. If this sounds like Greek, feel free to check out my previous article, Quick Glance At Gradient Descent In Machine Learning — I promise it’s friendlier than it sounds! 🙂 Circle back: An objective function is the mathematical formula or function that your model aims to minimize (or maximize, depending on the goal) during training. It represents a measure of how far off your model’s predictions are from the actual outcomes or desired values. For example: In machine learning, it could be a loss function like Mean Squared Error (MSE) for regression tasks or Cross-Entropy Loss for classification tasks. The objective function maps the model’s predictions to a numerical value, where smaller values indicate better performance. In simpler terms: It’s like a “fitness tracker” for your model — it tells you how good or bad your model’s predictions are. During optimization, gradient descent helps adjust the model’s parameters θ to reduce this value step by step, moving closer to an ideal solution. Got it? 😄 Circle back: An objective function is the mathematical formula or function that your model aims to minimize (or maximize, depending on the goal) during training. It represents a measure of how far off your model’s predictions are from the actual outcomes or desired values. Circle back: objective function For example: In machine learning , it could be a loss function like Mean Squared Error (MSE) for regression tasks or Cross-Entropy Loss for classification tasks. machine learning loss function The objective function maps the model’s predictions to a numerical value , where smaller values indicate better performance. numerical value In simpler terms: It’s like a “fitness tracker” for your model — it tells you how good or bad your model’s predictions are. During optimization, gradient descent helps adjust the model’s parameters θ to reduce this value step by step, moving closer to an ideal solution. Got it? 😄 Gradient Descent Variants Gradient descent isn’t a one-size-fits-all deal. It comes in three variants, each like a different hiker — some take the scenic route, others sprint downhill, and a few prefer shortcuts (like me 😅). These variants balance accuracy and speed, depending on how much data they use to calculate the gradient. 1. Batch Gradient Descent Batch gradient descent, the “all-or-nothing” hiker, uses the entire dataset to compute the gradient of the cost function: Imagine stopping to look 👀 at every rock 🪨, tree 🌴, and bird 🕊 before deciding where to place your foot 🦶🏽next. It’s thorough, but not ideal if your dataset is as big as, say, the Amazon rainforest 😩. It’s also not great if you need to learn on the fly — like updating your hiking route after spotting a bear 🐻‍❄️. Code Example: Code Example: for i in range(nb_epochs):
    params_grad = evaluate_gradient(loss_function, data, params)
    params = params - learning_rate * params_grad for i in range(nb_epochs):
    params_grad = evaluate_gradient(loss_function, data, params)
    params = params - learning_rate * params_grad Batch gradient descent shines when you have all the time in the world and a dataset that fits neatly into memory. It’s guaranteed to find the global minimum for convex surfaces (smooth hills) or a local minimum for non-convex surfaces (rugged mountains). 2. Stochastic Gradient Descent (SGD) SGD is the “impulsive” hiker who takes one step at a time based on the current terrain: It’s faster because it doesn’t bother calculating gradients for the entire landscape. Instead, it uses one training example at a time. While this saves time, the frequent updates can make SGD look like it’s zigzagging downhill, which can be both exciting and a little chaotic. 😅 Imagine updating your grocery list after each aisle — you get to the essentials faster, but your cart might look wild in the process. However, with a learning rate that slows down over time, SGD can eventually reach the bottom (or the best local minimum). Code Example: Code Example: for i in range(nb_epochs):
    np.random.shuffle(data)
    for example in data:
        params_grad = evaluate_gradient(loss_function, example, params)
        params = params - learning_rate * params_grad for i in range(nb_epochs):
    np.random.shuffle(data)
    for example in data:
        params_grad = evaluate_gradient(loss_function, example, params)
        params = params - learning_rate * params_grad 3. The Hero of the Day: Adam 🙌🏽 Now let’s talk about Adam — the “hiking guru” who combines the wisdom of Momentum and RMSprop . Adaptive Moment Estimation (Adam) is like having a smart guide who tracks the terrain and adjusts your steps based on past experiences and current conditions. It’s the go-to optimizer when you want to train neural networks and still have time for coffee. Momentum RMSprop Why You’ll Love Adam Low Memory Requirements: It’s like carrying a lightweight backpack — efficient but still packed with essentials. Minimal Hyperparameter Tuning: Adam works well out of the box, so you won’t need to fiddle with too many knobs (just keep an eye on the learning rate). Practical Use: From improving product recommendations to recognizing images of cats on the internet, Adam powers machine learning systems that make your everyday tech smarter. Low Memory Requirements: It’s like carrying a lightweight backpack — efficient but still packed with essentials. Low Memory Requirements: It’s like carrying a lightweight backpack — efficient but still packed with essentials. Low Memory Requirements: Minimal Hyperparameter Tuning: Adam works well out of the box, so you won’t need to fiddle with too many knobs (just keep an eye on the learning rate). Minimal Hyperparameter Tuning: Adam works well out of the box, so you won’t need to fiddle with too many knobs (just keep an eye on the learning rate). Minimal Hyperparameter Tuning: Practical Use: From improving product recommendations to recognizing images of cats on the internet, Adam powers machine learning systems that make your everyday tech smarter. Practical Use: From improving product recommendations to recognizing images of cats on the internet, Adam powers machine learning systems that make your everyday tech smarter. Practical Use: How Adam Works Adam maintains moving averages of gradients (mt​) and squared gradients (vt​) to adapt learning rates for each parameter: Here’s the cool part: Adam corrects biases to ensure accuracy, and updates parameters using this formula: where m^t and v^t are bias-corrected estimates, and epsilon ϵ is a small number to prevent division by zero. Conclusion Adam is the Swiss Army knife of optimizers — versatile, efficient, and reliable. Whether you’re training neural networks to detect fraud or create next-gen chatbots, Adam helps you get there faster and with fewer headaches. So, embrace Adam, take confident steps, and enjoy the view from the summit of machine learning success! References: https://www.ceremade.dauphine.fr/\~waldspurger/tds/22_23_s1/advanced_gradient_descent.pdf https://www.ceremade.dauphine.fr/\~waldspurger/tds/22_23_s1/advanced_gradient_descent.pdf https://www.geeksforgeeks.org/rmsprop-optimizer-in-deep-learning/ https://www.geeksforgeeks.org/rmsprop-optimizer-in-deep-learning/

Extending Stochastic Gradient Optimization with ADAM

Authors:
(1) Dorian W. P. Amaral, Department of Physics and Astronomy, Rice University and These authors contributed approximately equally to this work;
(2) Mudit Jain, Department of Physics and Astronomy, Rice University, Theoretical Particle Physics and Cosmology, King’s College London and These authors contributed approximately equally to this work;
(3) Mustafa A. Amin, Department of Physics and Astronomy, Rice University;
(4) Christopher Tunnell, Department of Physics and Astronomy, Rice University. Table of Links Abstract and 1 Introduction 2 Calculating the Stochastic Wave Vector Dark Matter Signal 2.1 The Dark Photon Field 2.2 The Detector Signal 3 Statistical Analysis and 3.1 Signal Likelihood 3.2 Projected Exclusions 4 Application to Accelerometer Studies 4.1 Recasting Generalised Limits onto B − L Dark Matter 5 Future Directions 6 Conclusions, Acknowledgments, and References A Equipartition between Longitudinal and Transverse Modes B Derivation of Marginal Likelihood with Stochastic Field Amplitude C Covariance Matrix D The Case of the Gradient of a Scalar D The Case of the Gradient of a Scalar In this case, there is a preferential direction because ∇a points in the direction of the local DM velocity. Aligning the lab’s working coordinate system such that this local velocity vector is parallel to the z axis, the amplitudes associated with the three different directions in Eq. (2.9) are not all the same. Effectively, there is an extra factor associated with the z direction, and the random signal in frequency space (c.f. Eq. (2.9)) takes the following form where (and following the notation of [45]) Proceeding similarly as in Appendix B, the marginalized likelihood is which we can evaluate by proceeding in the same fashion as in Appendix B; i.e. making redefinitions of the variables so they become independent and the integral becomes analytically tractable. We arrive at the following: where This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Dorian W. P. Amaral, Department of Physics and Astronomy, Rice University and These authors contributed approximately equally to this work; (2) Mudit Jain, Department of Physics and Astronomy, Rice University, Theoretical Particle Physics and Cosmology, King’s College London and These authors contributed approximately equally to this work; (3) Mustafa A. Amin, Department of Physics and Astronomy, Rice University; (4) Christopher Tunnell, Department of Physics and Astronomy, Rice University. Authors: Authors: (1) Dorian W. P. Amaral, Department of Physics and Astronomy, Rice University and These authors contributed approximately equally to this work; (2) Mudit Jain, Department of Physics and Astronomy, Rice University, Theoretical Particle Physics and Cosmology, King’s College London and These authors contributed approximately equally to this work; (3) Mustafa A. Amin, Department of Physics and Astronomy, Rice University; (4) Christopher Tunnell, Department of Physics and Astronomy, Rice University. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Calculating the Stochastic Wave Vector Dark Matter Signal 2.1 The Dark Photon Field 2.1 The Dark Photon Field 2.2 The Detector Signal 2.2 The Detector Signal 3 Statistical Analysis and 3.1 Signal Likelihood 3 Statistical Analysis and 3.1 Signal Likelihood 3.2 Projected Exclusions 3.2 Projected Exclusions 4 Application to Accelerometer Studies 4 Application to Accelerometer Studies 4.1 Recasting Generalised Limits onto B − L Dark Matter 4.1 Recasting Generalised Limits onto B − L Dark Matter 5 Future Directions 5 Future Directions 6 Conclusions, Acknowledgments, and References 6 Conclusions, Acknowledgments, and References A Equipartition between Longitudinal and Transverse Modes A Equipartition between Longitudinal and Transverse Modes B Derivation of Marginal Likelihood with Stochastic Field Amplitude B Derivation of Marginal Likelihood with Stochastic Field Amplitude C Covariance Matrix C Covariance Matrix D The Case of the Gradient of a Scalar D The Case of the Gradient of a Scalar D The Case of the Gradient of a Scalar In this case, there is a preferential direction because ∇a points in the direction of the local DM velocity. Aligning the lab’s working coordinate system such that this local velocity vector is parallel to the z axis, the amplitudes associated with the three different directions in Eq. (2.9) are not all the same. Effectively, there is an extra factor associated with the z direction, and the random signal in frequency space (c.f. Eq. (2.9)) takes the following form where (and following the notation of [45]) Proceeding similarly as in Appendix B, the marginalized likelihood is which we can evaluate by proceeding in the same fashion as in Appendix B; i.e. making redefinitions of the variables so they become independent and the integral becomes analytically tractable. We arrive at the following: where 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

Exploring the Gradient of a Scalar in Dark Matter Velocity Analysis

Authors:
(1) Rafael Rafailo, Stanford University and Equal contribution; more junior authors listed earlier;
(2) Archit Sharma, Stanford University and Equal contribution; more junior authors listed earlier;
(3) Eric Mitchel, Stanford University and Equal contribution; more junior authors listed earlier;
(4) Stefano Ermon, CZ Biohub;
(5) Christopher D. Manning, Stanford University;
(6) Chelsea Finn, Stanford University. Table of Links Abstract and 1. Introduction 2 Related Work 3 Preliminaries 4 Direct Preference Optimization 5 Theoretical Analysis of DPO 6 Experiments 7 Discussion, Acknowledgements, and References Author Contributions A Mathematical Derivations A.1 Deriving the Optimum of the KL-Constrained Reward Maximization Objective A.2 Deriving the DPO Objective Under the Bradley-Terry Model A.3 Deriving the DPO Objective Under the Plackett-Luce Model A.4 Deriving the Gradient of the DPO Objective and A.5 Proof of Lemma 1 and 2 A.6 Proof of Theorem 1 B DPO Implementation Details and Hyperparameters C Further Details on the Experimental Set-Up and C.1 IMDb Sentiment Experiment and Baseline Details C.2 GPT-4 prompts for computing summarization and dialogue win rates C.3 Unlikelihood baseline D Additional Empirical Results D.1 Performance of Best of N baseline for Various N and D.2 Sample Responses and GPT-4 Judgments D.3 Human study details A.4 Deriving the Gradient of the DPO Objective In this section we derive the gradient of the DPO objective: We can rewrite the RHS of Equation 21 as Using the properties of sigmoid function σ ′ (x) = σ(x)(1 − σ(x)) and σ(−x) = 1 − σ(x), we obtain the final gradient A.5 Proof of Lemma 1 and 2 In this section, we will prove the two lemmas from Section 5. Lemma 1 Restated. Under the Plackett-Luce preference framework, and in particular the Bradley-Terry framework, two reward functions from the same equivalence class induce the same preference distribution. which completes the proof. Lemma 2 Restated. Two reward functions from the same equivalence class induce the same optimal policy under the constrained RL problem. which completes the proof. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: (1) Rafael Rafailo, Stanford University and Equal contribution; more junior authors listed earlier; (2) Archit Sharma, Stanford University and Equal contribution; more junior authors listed earlier; (3) Eric Mitchel, Stanford University and Equal contribution; more junior authors listed earlier; (4) Stefano Ermon, CZ Biohub; (5) Christopher D. Manning, Stanford University; (6) Chelsea Finn, Stanford University. Authors: Authors: (1) Rafael Rafailo, Stanford University and Equal contribution; more junior authors listed earlier; (2) Archit Sharma, Stanford University and Equal contribution; more junior authors listed earlier; (3) Eric Mitchel, Stanford University and Equal contribution; more junior authors listed earlier; (4) Stefano Ermon, CZ Biohub; (5) Christopher D. Manning, Stanford University; (6) Chelsea Finn, Stanford University. Table of Links Abstract and 1. Introduction Abstract and 1. Introduction 2 Related Work 2 Related Work 3 Preliminaries 3 Preliminaries 4 Direct Preference Optimization 4 Direct Preference Optimization 5 Theoretical Analysis of DPO 5 Theoretical Analysis of DPO 6 Experiments 6 Experiments 7 Discussion, Acknowledgements, and References 7 Discussion, Acknowledgements, and References Author Contributions Author Contributions A Mathematical Derivations A.1 Deriving the Optimum of the KL-Constrained Reward Maximization Objective A.1 Deriving the Optimum of the KL-Constrained Reward Maximization Objective A.2 Deriving the DPO Objective Under the Bradley-Terry Model A.2 Deriving the DPO Objective Under the Bradley-Terry Model A.3 Deriving the DPO Objective Under the Plackett-Luce Model A.3 Deriving the DPO Objective Under the Plackett-Luce Model A.4 Deriving the Gradient of the DPO Objective and A.5 Proof of Lemma 1 and 2 A.4 Deriving the Gradient of the DPO Objective and A.5 Proof of Lemma 1 and 2 A.6 Proof of Theorem 1 A.6 Proof of Theorem 1 B DPO Implementation Details and Hyperparameters B DPO Implementation Details and Hyperparameters C Further Details on the Experimental Set-Up and C.1 IMDb Sentiment Experiment and Baseline Details C Further Details on the Experimental Set-Up and C.1 IMDb Sentiment Experiment and Baseline Details C.2 GPT-4 prompts for computing summarization and dialogue win rates C.2 GPT-4 prompts for computing summarization and dialogue win rates C.3 Unlikelihood baseline C.3 Unlikelihood baseline D Additional Empirical Results D.1 Performance of Best of N baseline for Various N and D.2 Sample Responses and GPT-4 Judgments D.1 Performance of Best of N baseline for Various N and D.2 Sample Responses and GPT-4 Judgments D.3 Human study details D.3 Human study details A.4 Deriving the Gradient of the DPO Objective In this section we derive the gradient of the DPO objective: We can rewrite the RHS of Equation 21 as Using the properties of sigmoid function σ ′ (x) = σ(x)(1 − σ(x)) and σ(−x) = 1 − σ(x), we obtain the final gradient A.5 Proof of Lemma 1 and 2 In this section, we will prove the two lemmas from Section 5. Lemma 1 Restated. Under the Plackett-Luce preference framework, and in particular the Bradley-Terry framework, two reward functions from the same equivalence class induce the same preference distribution. Lemma 1 Restated. Under the Plackett-Luce preference framework, and in particular the Bradley-Terry framework, two reward functions from the same equivalence class induce the same preference distribution. which completes the proof. Lemma 2 Restated. Two reward functions from the same equivalence class induce the same optimal policy under the constrained RL problem. Lemma 2 Restated. Two reward functions from the same equivalence class induce the same optimal policy under the constrained RL problem. which completes the proof. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. available on arxiv

Deriving the Gradient of the DPO Objective

Visualizing Colors: The Gradient Oscillation Hyperspace

ভিজ্যুয়ালাইজিং কালার: গ্রেডিয়েন্ট অসিলেশন হাইপারস্পেস

Farben visualisieren: Der Gradientenoszillations-Hyperraum

Visualización de colores: el hiperespacio de oscilación de gradiente

Visualisation des couleurs : l'hyperespace d'oscillation de dégradé

रंगों का दृश्यांकन: ग्रेडिएंट ऑसिलेशन हाइपरस्पेस

色の視覚化: 勾配振動ハイパースペース

색상 시각화: 그라데이션 진동 초공간

Visualizando Cores: O Hiperespaço de Oscilação de Gradiente

Визуализация цветов: гиперпространство градиентных колебаний

Renkleri Görselleştirmek: Degrade Salınım Hiperuzayı

Trực quan hóa màu sắc: Siêu không gian dao động chuyển màu

可视化颜色：梯度振荡超空间

Gradient descent is the most popular optimization technique in machine learning (ML) modeling. The algorithm minimizes the error between the predicted values and the ground truth. Since the technique considers each data point to understand and minimize the error, its performance depends on the training data size. Techniques like Stochastic Gradient Descent (SGD) are designed to improve the calculation performance but at the cost of convergence accuracy. Stochastic Average Gradient balances the classic approach, known as Full Gradient Descent and SGD, and offers both benefits. But before we can use the algorithm, we must first understand its significance for model optimization. Optimizing Machine Learning Objectives with Gradient Descent Every ML algorithm has an associated loss function that aims to minimize or improve the model’s performance. Mathematically, the loss can be defined as: It is simply the difference between the actual and the predicted output, and minimizing this difference means that our model comes closer to the ground truth values. The minimization algorithm uses gradient descent to traverse the loss function and find a global minimum. Each traversal step involves updating the algorithm's weights to optimize the output. Plain Gradient Descent The conventional gradient descent algorithm uses the average of all the gradients calculated across the entire dataset. The lifecycle of a single training example looks like the following: The weight update equation looks like the following: Where W represents the model weights and dJ/dW is the derivative of the loss function with respect to the model weight. The conventional method has a high convergence rate but becomes computationally expensive when dealing with large datasets comprising millions of data points. Stochastic Gradient Descent (SGD) The SGD methodology remains the same as plain GD, but instead of using the entire dataset to calculate the gradients, it uses a small batch from the inputs. The method is much more efficient but may hop too much around the global minima since each iteration uses only a part of the data for learning. Stochastic Average Gradient The Stochastic Average Gradient (SAG) approach was introduced as a middle ground between GD and SGD. It selects a random data point and updates its value based on the gradient at that point and a weighted average of the past gradients stored for that particular data point. Similar to SGD, SAG models every problem as a finite sum of convex, differentiable functions. At any given iteration, it uses the present gradients and the average of previous gradients for weight updation. The equation takes the following form: Convergence Rate Between the two popular algorithms, full gradient (FG) and stochastic gradient descent (SGD), the FG algorithm has a better convergence rate since it utilizes the entire data set during each iteration for calculation. Although SAG has a structure similar to SGD, its convergence rate is comparable to and sometimes better than the full gradient approach. Table 1 below summarizes the results from the experiments of Schmidt et. al. Further Modifications Despite its amazing performance, several modifications have been proposed to the original SGD algorithm to help improve performance. Re-weighting in Early Iterations: SAG convergence remains slow during the first few iterations since the algorithm normalizes the direction with n (total number of data points). This provides an inaccurate estimate as the algorithm has yet to see many data points. The modification suggests normalizing by the m instead of n, where m is the number of data points seen at least once until that particular iteration.
Mini-batches: The Stochastic Gradient approach uses mini-batches to process multiple data points simultaneously. The same approach can be applied to SAG. This allows for vectorization and parallelization for improved computer efficiency. It also reduces memory load, a prominent challenge for the SAG algorithm.
Step-Size experimentation: The step size mentioned earlier (116L) provides amazing results, but the authors further experimented by using the step size of 1L. The latter provided even better convergence. However, the authors were unable to present a formal analysis of the improved results. They conclude that the step size should be experimented with to find the optimal one for the specific problem. Final Thoughts Gradient descent is a popular optimization used for locating global minima of the provided objective functions. The algorithm uses the gradient of the objective function to traverse the function slope until it reaches the lowest point. Full Gradient Descent (FG) and Stochastic Gradient Descent (SGD) are two popular variations of the algorithm. FG uses the entire dataset during each iteration and provides a high convergence rate at a high computation cost. At each iteration, SGD uses a subset of data to run the algorithm. It is far more efficient but with an uncertain convergence. Stochastic Average Gradient (SAG) is another variation that provides the benefits of both previous algorithms. It uses the average of past gradients and a subset of the dataset to provide a high convergence rate with low computation. The algorithm can be further modified to improve its efficiency using vectorization and mini-batches. Gradient descent is the most popular optimization technique in machine learning (ML) modeling. The algorithm minimizes the error between the predicted values and the ground truth. Since the technique considers each data point to understand and minimize the error, its performance depends on the training data size. Techniques like Stochastic Gradient Descent (SGD) are designed to improve the calculation performance but at the cost of convergence accuracy. Stochastic Average Gradient balances the classic approach, known as Full Gradient Descent and SGD, and offers both benefits. But before we can use the algorithm, we must first understand its significance for model optimization. Stochastic Average Gradient balances the classic approach, known as Full Gradient Descent and SGD, and offers both benefits. But before we can use the algorithm, we must first understand its significance for model optimization. Optimizing Machine Learning Objectives with Gradient Descent Optimizing Machine Learning Objectives with Gradient Descent Every ML algorithm has an associated loss function that aims to minimize or improve the model’s performance. Mathematically, the loss can be defined as: It is simply the difference between the actual and the predicted output, and minimizing this difference means that our model comes closer to the ground truth values. The minimization algorithm uses gradient descent to traverse the loss function and find a global minimum. Each traversal step involves updating the algorithm's weights to optimize the output. Plain Gradient Descent Plain Gradient Descent The conventional gradient descent algorithm uses the average of all the gradients calculated across the entire dataset. The lifecycle of a single training example looks like the following: The weight update equation looks like the following: Where W represents the model weights and dJ/dW is the derivative of the loss function with respect to the model weight. The conventional method has a high convergence rate but becomes computationally expensive when dealing with large datasets comprising millions of data points. W dJ/dW Stochastic Gradient Descent (SGD) Stochastic Gradient Descent (SGD) The SGD methodology remains the same as plain GD, but instead of using the entire dataset to calculate the gradients, it uses a small batch from the inputs. The method is much more efficient but may hop too much around the global minima since each iteration uses only a part of the data for learning. Stochastic Average Gradient Stochastic Average Gradient The Stochastic Average Gradient (SAG) approach was introduced as a middle ground between GD and SGD. It selects a random data point and updates its value based on the gradient at that point and a weighted average of the past gradients stored for that particular data point. Similar to SGD, SAG models every problem as a finite sum of convex, differentiable functions. At any given iteration, it uses the present gradients and the average of previous gradients for weight updation. The equation takes the following form: Convergence Rate Convergence Rate Between the two popular algorithms, full gradient (FG) and stochastic gradient descent (SGD), the FG algorithm has a better convergence rate since it utilizes the entire data set during each iteration for calculation. Although SAG has a structure similar to SGD, its convergence rate is comparable to and sometimes better than the full gradient approach. Table 1 below summarizes the results from the experiments of Schmidt et. al . Schmidt et. al Schmidt et. al Further Modifications Further Modifications Despite its amazing performance, several modifications have been proposed to the original SGD algorithm to help improve performance. Re-weighting in Early Iterations: SAG convergence remains slow during the first few iterations since the algorithm normalizes the direction with n (total number of data points). This provides an inaccurate estimate as the algorithm has yet to see many data points. The modification suggests normalizing by the m instead of n, where m is the number of data points seen at least once until that particular iteration. Mini-batches: The Stochastic Gradient approach uses mini-batches to process multiple data points simultaneously. The same approach can be applied to SAG. This allows for vectorization and parallelization for improved computer efficiency. It also reduces memory load, a prominent challenge for the SAG algorithm. Step-Size experimentation: The step size mentioned earlier (116L) provides amazing results, but the authors further experimented by using the step size of 1L. The latter provided even better convergence. However, the authors were unable to present a formal analysis of the improved results. They conclude that the step size should be experimented with to find the optimal one for the specific problem. Re-weighting in Early Iterations: SAG convergence remains slow during the first few iterations since the algorithm normalizes the direction with n (total number of data points). This provides an inaccurate estimate as the algorithm has yet to see many data points. The modification suggests normalizing by the m instead of n, where m is the number of data points seen at least once until that particular iteration. Re-weighting in Early Iterations: Mini-batches: The Stochastic Gradient approach uses mini-batches to process multiple data points simultaneously. The same approach can be applied to SAG. This allows for vectorization and parallelization for improved computer efficiency. It also reduces memory load, a prominent challenge for the SAG algorithm. Mini-batches: Step-Size experimentation: The step size mentioned earlier (116L) provides amazing results, but the authors further experimented by using the step size of 1L. The latter provided even better convergence. However, the authors were unable to present a formal analysis of the improved results. They conclude that the step size should be experimented with to find the optimal one for the specific problem. Step-Size experimentation: Final Thoughts Final Thoughts Gradient descent is a popular optimization used for locating global minima of the provided objective functions. The algorithm uses the gradient of the objective function to traverse the function slope until it reaches the lowest point. Full Gradient Descent (FG) and Stochastic Gradient Descent (SGD) are two popular variations of the algorithm. FG uses the entire dataset during each iteration and provides a high convergence rate at a high computation cost. At each iteration, SGD uses a subset of data to run the algorithm. It is far more efficient but with an uncertain convergence. Stochastic Average Gradient (SAG) is another variation that provides the benefits of both previous algorithms. It uses the average of past gradients and a subset of the dataset to provide a high convergence rate with low computation. The algorithm can be further modified to improve its efficiency using vectorization and mini-batches.

Understanding Stochastic Average Gradient

Verstaan Stogastiese Gemiddelde Gradiënt

የስቶካስቲክ አማካኝ ቀስ በቀስ መረዳት

فهم متوسط التدرج العشوائي

Gradiente Promedio Estocástico uka amuyt’aña

Stokastik orta qradientin başa düşülməsi

Разуменне стахастычнага сярэдняга градыенту

Разбиране на стохастичния среден градиент

Razumijevanje stohastičkog prosječnog gradijenta

Comprensió del gradient mitjà estocàstic

Pochopení Stochastického průměrného gradientu

Forståelse af stokastisk gennemsnitsgradient

Κατανόηση της Στοχαστικής Μέσης Κλίσης

Batez besteko gradiente estokastikoa ulertzea

درک گرادیان میانگین تصادفی

Stokastisen keskigradientin ymmärtäminen

Comprensión do gradiente medio estocástico

הבנת שיפוע ממוצע סטוכסטי

Konprann stochastic mwayèn gradyan

A sztochasztikus átlagos gradiens megértése

Հասկանալով ստոխաստիկ միջին գրադիենտը

Memahami Gradien Rata-rata Stokastik

Comprensione del gradiente medio stocastico

სტოქასტური საშუალო გრადიენტის გაგება

Стохастикалық орташа градиентті түсіну

ការយល់ដឹងអំពីជម្រាលមធ្យម Stochastic

Стохастикалык орточо градиентти түшүнүү

Kososola Gradient Moyenne Stochastique

ຄວາມເຂົ້າໃຈ Stochastic Gradient ສະເລ່ຍ

Stochastinio vidutinio gradiento supratimas

Stohastiskā vidējā gradienta izpratne

Fahatakarana ny Stochastic Average Gradient

Разбирање на стохастички просечен градиент

Стохастик дундаж градиентийг ойлгох

Memahami Kecerunan Purata Stokastik

Stochastic औसत ग्रेडियन्ट बुझ्दै

Stochastische gemiddelde gradiënt begrijpen

Go kwešiša Gradient ya Palogare ya Stochastic

Zrozumienie stochastycznego średniego gradientu

د Stochastic اوسط تدریجي پوهیدل

Gradiente Promedio Estocástico nisqamanta hamut’ay

Înțelegerea gradientului mediu stocastic

Gusobanukirwa Impuzandengo Yimpuzandengo

Stochastic Average Gradient අවබෝධ කර ගැනීම

Pochopenie Stochastického priemerného gradientu

Kunzwisisa Stochastic Avhareji Gradient

Fahamka Celceliska Celceliska Stochastic Gradient

Kuptimi i gradientit mesatar stokastik

Разумевање стохастичког просечног градијента

Förstå stokastisk medelgradient

Kuelewa Gradient ya Wastani ya Stochastic

சீரற்ற சராசரி சாய்வு புரிந்து கொள்ளுதல்

Фаҳмидани градиенти миёнаи стохастикӣ

ทำความเข้าใจการไล่ระดับค่าเฉลี่ยสุ่ม

ስቶካስቲክ ማእከላይ ደረጃ ምዕባለ ምርዳእ

Stoxastiki ortaça gradiýente düşünmek

Pag-unawa sa Stochastic Average Gradient

Ku twisisa Stochastic Average Gradient

Розуміння стохастичного середнього градієнта

اسٹاکسٹک اوسط گریڈینٹ کو سمجھنا

Stokastik o'rtacha gradientni tushunish

Ukuqonda iStochastic Average Gradient

Ukuqonda I-Stochastic Average Gradient

This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Zhipeng Wang, Department of Computing, Imperial College London; (2) Nanqing Dong Department of Computer Science, University of Oxford; (3) Jiahao Sun, Data Science Institute, Imperial College London; (4) William Knottenbelt, Department of Computing, Imperial College London. TABLE OF LINKS Abstract & Introduction Related Work & Preliminaries Methodology Theoretical and Empirical Analysis Results Conclusion & References Conclusion We present a novel and pioneering approach called zkFL, which utilizes ZKPs to ensure a trustworthy aggregation process on the centralized aggregator. Through rigorous theoretical analysis, we establish that zkFL effectively addresses the challenge posed by a malicious aggregator during the model aggregation phase. Moreover, we extend zkFL to a blockchain-based system, significantly reducing the verification burden on the clients. The empirical analysis demonstrates that our design achieves superior levels of security and privacy compared to traditional FL systems while maintaining a favorable training speed for the clients. These results showcase the practical feasibility and potential advantages of zkFL
and its blockchain-based version in real-world applications. Acknowledgments This work was supported in part by the FLock Research Grant. References Diego F Aranha, Emil Madsen Bennedsen, Matteo Campanelli, Chaya Ganesh,
Claudio Orlandi, and Akira Takahashi. Eclipse: enhanced compiling method for
pedersen-committed zksnark engines. In IACR International Conference on PublicKey Cryptography, pages 584–614. Springer, 2022. Karim Baghery, Markulf Kohlweiss, Janno Siim, and Mikhail Volkhov. Another
look at extraction and randomization of groth’s zk-snark. In Financial Cryptography and Data Security: 25th International Conference, FC 2021, Virtual Event,
March 1–5, 2021, Revised Selected Papers, Part I 25, pages 457–475. Springer, Nir Bitansky. Verifiable random functions from non-interactive witnessindistinguishable proofs. Journal of Cryptology, 33(2):459–493, 2020. Joseph Bonneau, Andrew Miller, Jeremy Clark, Arvind Narayanan, Joshua A Kroll, and Edward W Felten. Sok: Research perspectives and challenges for bitcoin and cryptocurrencies. In 2015 IEEE Symposium on Security and Privacy, pages 104– 121. IEEE, 2015. Sean Bowe, Jack Grigg, and Daira Hopwood. Recursive proof composition without a trusted setup. Cryptology ePrint Archive, 2019. Lukas Burkhalter, Hidde Lycklama, Alexander Viand, Nicolas K¨uchler, and Anwar Hithnawi. Rofl: Attestable robustness for secure federated learning. arXiv preprint arXiv:2107.03311, 2021. Xiaoyu Cao and Neil Zhenqiang Gong. Mpaf: Model poisoning attacks to federated learning based on fake clients. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 3396–3404, 2022. Nanqing Dong, Zhipeng Wang, Jiahao Sun, Michael Kampffmeyer, Yizhe Wen, Shuoying Zhang, William Knottenbelt, and Eric Xing. Defending against malicious behaviors in federated learning with blockchain. arXiv preprint arXiv:2307.00543, 2023. Haohua Duan, Liyao Xiang, Xinbing Wang, Pengzhi Chu, and Chenghu Zhou. A new zero knowledge argument for general circuits and its application. IEEE Transactions on Information Forensics and Security, 2023. Juan Garay and Aggelos Kiayias. Sok: A consensus taxonomy in the blockchain era. In Topics in Cryptology–CT-RSA 2020: The Cryptographers’ Track at the RSA Conference 2020, San Francisco, CA, USA, February 24–28, 2020, Proceedings, pages 284–318. Springer, 2020. Oded Goldreich and Yair Oren. Definitions and properties of zero-knowledge proof systems. Journal of Cryptology, 7(1):1–32, 1994. Jens Groth. On the size of pairing-based non-interactive arguments. In International Conference on the Theory and Applications of Cryptographic Techniques, pages 305–326. Springer, 2016. Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pages 770–778, 2016. Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, pages 4700–4708, 2017. Huawei Huang, Wei Kong, Sicong Zhou, Zibin Zheng, and Song Guo. A survey of state-of-the-art on blockchains: Theories, modelings, and tools. ACM Computing Surveys (CSUR), 54(2):1–42, 2021. Wael Issa, Nour Moustafa, Benjamin Turnbull, Nasrin Sohrabi, and Zahir Tari. Blockchain-based federated learning for securing internet of things: A comprehensive survey. ACM Computing Surveys, 55(9):1–43, 2023. Peter Kairouz, H Brendan McMahan, Brendan Avent, Aur´elien Bellet, Mehdi Bennis, Arjun Nitin Bhagoji, Kallista Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. Foundations and Trends® in Machine Learning, 14(1–2):1–210, 2021. Joe Kilian. A note on efficient zero-knowledge proofs and arguments. In Proceedings of the twenty-fourth annual ACM symposium on Theory of computing, pages 723– 732, 1992. Hyesung Kim, Jihong Park, Mehdi Bennis, and Seong-Lyun Kim. Blockchained ondevice federated learning. IEEE Communications Letters, 24(6):1279–1283, 2019. Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. Yijing Li, Xiaofeng Tao, Xuefei Zhang, Junjie Liu, and Jin Xu. Privacy-preserved federated learning for autonomous driving. IEEE Transactions on Intelligent Transportation Systems, 23(7):8423–8434, 2021. Tianyi Liu, Xiang Xie, and Yupeng Zhang. Zkcnn: Zero knowledge proofs for convolutional neural network predictions and accuracy. In ACM SIGSAC Conference on Computer and Communications Security, pages 2968–2985, 2021. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In AISTATS, pages 1273–1282. PMLR, 2017. Silvio Micali, Michael Rabin, and Salil Vadhan. Verifiable random functions. In 40th annual symposium on foundations of computer science (cat. No. 99CB37039), pages 120–130. IEEE, 1999. Satoshi Nakamoto. Bitcoin: A peer-to-peer electronic cash system. Decentralized business review, 2008. Torben Pryds Pedersen. Non-interactive and information-theoretic secure verifiable secret sharing. In Annual international cryptology conference, pages 129–140. Springer, 1991. Youyang Qu, Md Palash Uddin, Chenquan Gan, Yong Xiang, Longxiang Gao, and John Yearwood. Blockchain-enabled federated learning: A survey. ACM Computing Surveys, 55(4):1–35, 2022. Eli Ben Sasson, Alessandro Chiesa, Christina Garman, Matthew Green, Ian Miers, Eran Tromer, and Madars Virza. Zerocash: Decentralized anonymous payments from bitcoin. In 2014 IEEE Symposium on Security and Privacy, pages 459–474. IEEE, 2014. Xiaoqiang Sun, F Richard Yu, Peng Zhang, Zhiwei Sun, Weixin Xie, and Xiang Peng. A survey on zero-knowledge proof in blockchain. IEEE network, 35(4):198– 205, 2021. Zhipeng Wang, Stefanos Chaliasos, Kaihua Qin, Liyi Zhou, Lifeng Gao, Pascal Berrang, Benjamin Livshits, and Arthur Gervais. On how zero-knowledge proof blockchain mixers improve, and worsen user privacy. In Proceedings of the ACM Web Conference 2023, pages 2022–2032, 2023. Jiasi Weng, Jian Weng, Gui Tang, Anjia Yang, Ming Li, and Jia-Nan Liu. pvcnn: Privacy-preserving and verifiable convolutional neural network testing. IEEE Transactions on Information Forensics and Security, 18:2218–2233, 2023. Jiasi Weng, Jian Weng, Jilian Zhang, Ming Li, Yue Zhang, and Weiqi Luo. Deepchain: Auditable and privacy-preserving deep learning with blockchain-based incentive. IEEE Transactions on Dependable and Secure Computing, 18(5):2438– 2455, 2019. Gavin Wood. Ethereum: A secure decentralised generalised transaction ledger. Ethereum project yellow paper, 151:1–32, 2014. Juncen Zhu, Jiannong Cao, Divya Saxena, Shan Jiang, and Houda Ferradi. Blockchain-empowered federated learning: Challenges, solutions, and future directions. ACM Computing Surveys, 55(11):1–31, 2023.

Zero Knowledge Proof based Gradient Aggregation for Federated Learning: Conclusion & References

This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Zhipeng Wang, Department of Computing, Imperial College London; (2) Nanqing Dong Department of Computer Science, University of Oxford; (3) Jiahao Sun, Data Science Institute, Imperial College London; (4) William Knottenbelt, Department of Computing, Imperial College London. TABLE OF LINKS Abstract & Introduction Related Work & Preliminaries Methodology Theoretical and Empirical Analysis Results Conclusion & References Results Training Time We commence our evaluation by conducting an in-depth analysis of the total training time per epoch for each network backbone, focusing on the conventional FL approach without the integration of zkFL. This evaluation encompasses three crucial components that contribute to the overall training time: the local training time of each individual client, the time required for aggregating local model updates on the central aggregator, and the synchronization. time. As shown in Figs. 3(b) 4(b) 5(b) 6(b) 7(b) 8(b), our findings indicate that the local training time of each client is the primary contributor to the total training time. Moreover, as the number of clients increases, the local training time for individual clients decreases due to the effective distribution of training tasks among them. Encryption and Aggregation Time We conduct a thorough evaluation of the encryption time for clients and the aggregation time for the central aggregator within the zkFL system. In addition to the computational costs associated with the FL training protocol, the client-side tasks involve computing commitments, such as encryption computations for each model update parameter. Our results demonstrate that this additional cost varies based on the choice of underlying network backbones and increases with the number of parameters in the network. For instance, the encryption time for ResNet18 (i.e., 10 − 20 mins) is lower than that for ResNet34 (i.e., 25 − 45 mins), as the latter has a larger number of network parameters. Moreover, as illustrated in Figs 3(d) 4(d) 5(d) 6(d) 7(d) 8(d), the aggregation time of the central aggregator in zkFL is influenced by the network parameters and exhibits an approximately linear relationship with the number of clients in the FL system. ZKP Proof Generation and Verification Time As depicted in Fig. 9, the time required for Halo2 ZKP generation and verification exhibits variations depending on the chosen network and increases with the size of the network parameters. Among the six networks evaluated, ResNet50 demands the longest time for proof generation, taking approximately 54.72 ± 0.12 mins. Notably, the proof verification time is approximately half of the generation time. This favorable characteristic makes zkFL more practical, as the aggregator, equipped with abundant computing power, can efficiently generate the proof, while the source-limited clients can verify it without significant computational overhead. This highlights the feasibility and applicability of zkFL in real-world scenarios, where the FL clients may have constrained resources compared to the central aggregator. Communication Costs Compared to the traditional FL, zkFL will also increase the communication costs for the clients and the aggregator, as the encrypted local training model updates Enc(wi) (1 ≤ i ≤ n) and the ZKP proof π. As shown in Table 1, for each network backbone, we compare the size of encrypted data with the size of the model updates in plaintext. We show that the size of encrypted data grows linearly in the number of parameters. Thus, the communication costs are dominated by the encrypted data. For ResNet50, the network backbone with the largest number of model parameters in our experiment, the additional data transmitted to the centralized aggregator per client is approximately 2× compared to the plaintext). However, it is of utmost importance to underscore that although the relative size increase might appear significant, the absolute size of the updates is merely equivalent to a few minutes of compressed HD video. As a result, the data size remains well within the capabilities of the FL clients utilizing wireless or mobile connections. Training Performance and Convergence Analysis In addition to analyzing the additional computation and communication costs introduced by zkFL, we thoroughly investigate its potential impact on training performance, including accuracy and convergence speed. Theoretically, we demonstrate that compared to traditional FL, zkFL solely affects the data output from the clients, leaving the training process unaffected. Our experimental results provide strong evidence supporting this claim. As illustrated in Figs 3(a) 4(a) 5(a) 6(a) 7(a) 8(a), the final training results’ accuracy and convergence speed do not exhibit any significant difference between FL settings with and without zkFL. Furthermore, we observe that the convergence speed is primarily influenced by the number of clients involved in the process. This reaffirms the practical viability of zkFL as it maintains training performance while enhancing security and privacy in the federated learning framework.

Zero Knowledge Proof based Gradient Aggregation for Federated Learning: Results

This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Zhipeng Wang, Department of Computing, Imperial College London; (2) Nanqing Dong Department of Computer Science, University of Oxford; (3) Jiahao Sun, Data Science Institute, Imperial College London; (4) William Knottenbelt, Department of Computing, Imperial College London. TABLE OF LINKS Abstract & Introduction Related Work & Preliminaries Methodology Theoretical and Empirical Analysis Results Conclusion & References Theoretical Analysis In the following, we provide analyses to show that our zkFL and blockchain-based zkFL systems can achieve the goals of security and privacy, while merely bringing an acceptable decrease in the FL training efficiency. Security Analysis Our zkFL and blockchain-based zkFL can achieve the security goal through the following techniques: The signatures sigi of each encrypted local update Enc(wi) ensure the local updates’ integrity from the clients and prevent the aggregator from tampering with their content and the statement . statement = (Enc(w1), sig1, ..., Enc(wn), sign, Enc(w)) The completeness and soundness properties of the ZKP proof π play a critical role in safeguarding the aggregation process from adversarial manipulation by the aggregator. These properties ensure that the aggregator cannot deviate from the intended behaviors: If the aggregator abandons the model update generated from one client j, then the aggregated results will be ˆw = Pn i=1,j̸=i wi. In this case, the corresponding circuit C(statement, witness) outputs 0, and the proof π will be invalid. If the aggregator replaces the model update generated from one client j by wˆj, then the aggregated results will be ˆw = Pn i=1,j̸=i wi + ˆwj. In this case, the corresponding circuit C(statement, witness) outputs 0, and the proof π will be invalid. If the aggregator inserts one fake model update generated ˆw0, then the aggregated results will be ˆw = Pn i=1 wi+ ˆw0. In this case, the corresponding circuit C(statement, witness) outputs 0, and the proof π will be invalid. Therefore, the proof π will only be valid if the aggregator honestly conducts the local model updates aggregation to generate the global model update P w = n i=1 wi. Privacy Analysis In zkFL, privacy is inherently ensured as only the aggregator and the participating clients are involved in the training and aggregation process, eliminating the need for external parties. As a result, only these authorized entities possess knowledge of the aggregated model updates at each round. In the context of the blockchain-based zkFL system, the blockchain miners receive encrypted the local model updates Enc(wi) (1 ≤ i ≤ n), the encrypted global model update Enc(w), and the ZKP proof π from the aggregator. However, due to the zero-knowledge property of ZKP, the miners can only verify whether Enc(w) is correctly executed or not, without gaining any access to information about the individual local model updates wi (1 ≤ i ≤ n) or the global model update w. Additionally, storing the encrypted data of Enc(w) on the blockchain does not compromise the privacy of the global model update w. Our system maintains a robust level of privacy throughout the blockchain-based zkFL process. Efficiency Analysis In the following, we calculate the expected computation time of the aggregator and a client per round, to analyze the system efficiency of zkFL and blockchain-based zkFL. In both zkFL and blockchain-based zkFL systems, the aggregator is responsible for aggregating the local model updates and generating the ZKP proof. The expected computation time of the aggregator is: Eaggregator = E(aggr) + E(ZKP.gen) In the zkFL system, a client needs to train the local model, encrypt the local model update and verify the ZKP proof generated by the aggregator. The expected computation time of a client is: Eclient = E(train) + E(enc) + E(ZKP.ver) In the blockchain-based zkFL system, a client still needs to train the local model and encrypt the local model update. However, the blockchain miners will take charge of verifying the ZKP proof generated by the aggregator, and the clients only need to read the data on the blockchain. The expected computation time of a client is: E block client = E(train) + E(enc) + O(1) Empirical Analysis In this section, we quantify the overhead of zkFL and show that it can be used
to train practical FL models. Experiment Setup Implementation. We develop a prototype of zkFL. We implement the prototype in and interface it with Python to train deep learning models withPyTorch 1.13. We adopt the elliptic curve Curve25519 (i.e. 126-bit security) implementation from the for cryptographic encryption operations. We build Pedersen commitments [1] over the elliptic curves and integrate it with Halo2 [5], a ZKP system that is being used by the . Rust dalek curve25519 library Zcash blockchain We test our zkFL system with two families of network architectures: ResNets [13] (ResNet18, ResNet34, ResNet50) and DenseNets [14] (DenseNet121, DenseNet169, and DenseNet201). We use this setup to evaluate the sensitivity of zkFL to network architectures and number of parameters. We use a standard Adam optimizer [20] with fixed learning rate 0.001 with batch size 50. We use the area under the receiver operating curve (AUROC) as the evaluation metric. All tests are implemented in PyTorch 1.10.1 on an NVIDIA Tesla T4 GPU with 16GB memory. Data and Task We consider a benchmark classification task under the common federated setup. We use FedAVG [23] as the base FL method to evaluate zkFL and use CIFAR-10 dataset with the default train-test split. The training set is split into K subsets of equal size and distributed across K clients. For each client, 10% of distributed data is assigned as the validation set. In each epoch, clients train their models separately with local data. Then, the aggregator synchronizes local models and performs the model evaluation. For each network backbone, we conduct the tasks for zkFL with 1, 4, 8, 16, and 32 client(s). For each task, we record the training time without using zkFL, the encryption and aggregation time with zkFL, as well as the ZKP generation and verification time under zkFL. We also evaluate the performance of each task with various network backbones and client numbers.

Zero Knowledge Proof based Gradient Aggregation for Federated Learning: Theoretical Analysis

Stories, News & Mentions about GRADIENT

Gradient’s Stories on HackerNoon