Gradient AI is a fast-growing startup, bringing state-of-the-art Artificial Intelligence (AI) and Machine Learning (ML) solutions to the trillion-dollar insurance industry

Gradient AI

gradientai

A little prologue from the author: It all begun with Transformers — not the robots — a deep learning technique released by google for predicting words in a very good sequence. Suddenly we have achieved artificial intelligence, at least some form of it. But the true question remains: Where the hell are my robots! Well, fear not dear roboticist. MachinaScript is here to help you bring next-gen robotics to your garage. You can start making incredibly intelligent robots right away. Anakin built C3PO when he was 9 years old. How about you? - babycommando, made with love for the maker community. Introducing MachinaScript For Robots A set of tools and a LLM-JSON-based language designed to empower humans in the creation of their own mechanical companions. It facilitates the , the integration of , and with a high degree of autonomy. animation of generative movements motion personality teaching a set of instructions (skills) With MachinaScript, you can control a wide range of electronics like Arduinos, Raspberry Pis, servo motors, cameras, sensors, and much more. Our goal is to make a wide modular generative format more accessible, as no robot design is the same for anyone. How does it work, and some tips A robot is naturally built on top of computers, motors and other cool electronical components. They are also built around a physical design. There’s a lot of “ ” out there already. They work pretty much like remote-controller toys: robot dogs, humanoids, R2D2 clones… how to arduino robots We are just . And trust me, they perform well on this. Motion design can display a lot of personality. switching the controls to a multimodal large language model very Consider for example a robot that have a have a pair of cat ears. LLMs knows incredibly accurate ways to move them to express feelings when talking. You just need a way to tell the robot they have cat ears… Enter The MachinaScript Language The MachinaScript language is built on a LLM-JSON-based synthax with incredibly modular capailities because it is generative. As long as your “Brain” code is adapted to understand it, you literally have no ending for your creativity. Hook up all your components and limit a set of rules on how the robot may use them to fulfill the future inputs. The current version of MachinaScript was built in this format: At the top layer there are a set of actions. Inside actions we have a set of movements to be executed to achieve a goal in an animated motion way. Movements contain the set of motors, degrees for each to move and additional configuration like movement speed. Also inside of an action, we have the “useSkill” — a set of skills to be used in an order to also achieve a goal. They are similar to function calling, with some code ready to be activated. Take a picture, text to speech, blink a led, etc. Sudo make me a sandwich? Let’s go. Note you can even change the complete synthax for the language structure for your needs! You see, MachinaScript is more of a philosophy for building generative robots than anything else. This is the true power of natural language processing. Additionally, you may want to finetune a llm to make even better/faster generations for your own machines and specs. Training local models are pretty easy nowadays with tools like or even the official openAi one if you are using their models. gradient.ai A Brain and a Body Robot design patterns for MachinaScript to work are pretty straight forward: a computer represents brain, a microcontroller represents the body. Motors, sensors and other dispositives can be hooked to them in different setups and controlled from the MachinaScript generative set of instuctions and skills. The actions, movements and skills are then serially encoded in a sequence to be executed — in deep specification if needed. For example: Move slowly for taking a whole-night long exposure picture of the milky way center. Start now at 45 degrees north and only stop at 5 am. This set of orders comes from the LLM encoded in the MachinaScript JSON format. For arduino serial communication to be very fast, we must serialize this data and pass from the “Brain” to the “Body”. Engineers and hackers, behold the for a full working example ready to be customized. github repo here How to Make a Robot One of the wildests capabilities of the MachinaScript is the ability to metamorph into any robotic body shape. It learns in no-time how to control your design, being it two or four legged, aerial, terrestrial or submarine. As long as the capabilities are well prompted, mapped and parsed in the and the Body/Brain codes, you are good to go. Grab some scrap metal, some very cheap servos and start playing around. Find an enclosure, make it have a personality. Or maybe ask it who it wants to be. Who knows. And suddenly the dream of building intelligent robots is not a dream anymore. Join the , share your designs, skills, 3D models, hacks and crafts with us! We really wanna see your robots :] discord community MachinaScript for Robots is and always will be free and open source for everyone. Contribute to the . You can find some early code examples to start making your robots right now. github repo here MachinaScript for Robots is in very early beta. Use at your own risk. Also published . here

Introducing LLM-Powered Robots: MachinaScript for Robots

A simple guide — for everyone. quick-dive AI, Machine Learning, Chatbots, NLP — all the buzzwords these days. From developers to analysts to business owners, everyone wants their business to benefit from the magic of AI they have all been hearing so much about. It has come to a point where developers building even a simple computer program have started calling it ‘ ’. ( ) Artificial Intelligence I recently came across a ‘non-traditional’ chess game which was dubbed as AI, but to be honest, I have seen better chess algos in the 90s. This is what it has come to. AI and Machine Learning have become terms that are thrown around in casual conversations these days. Every single business executive wants to incorporate AI in their business processes, but as it happens with almost anything that becomes an ‘ ’, many of these people are not able to comprehend what AI or ML really is — . in thing not fully at least FIRST THINGS FIRST, I AM NOT A DATA SCIENTIST So why the hell am I talking about data science and machine learning? And what makes me think that I am to talk about these things I obviously do not have an expertise in? **even qualified** Actually, it is my relative unfamiliarity with the topic that makes me the best person to talk about it. Since it gives me the unique perspective to talk about it from the point of view of someone who understands business processes, but has just started understanding data science. If you are an expert in data science, this story might not be for you; but if you — — are interested in improving your understanding of AI and machine learning, well — Do read on. like so many out there Off late, I have been working quite closely with a group of amazing data scientists, and so as to make myself a useful participant in the discussions we have ( ), I needed to understand things better. I needed to get to a point where at least I understood things and how they happen. And that is what I have been doing. and more importantly, to avoid making a complete ass of myself WHAT IS MACHINE LEARNING, DEEP LEARNING AND AI? The first thing you need to understand is when you see people talking of Machine Learning, more often than not, they are talking of Deep Learning. This is what Google displays in a card on Deep Learning — Wiki But, you aren’t interested in Deep Learning, are you? You aren’t even that much interested in Machine Learning. You are interested in AI. Right? Wrong! That is the first thing most of us get wrong. You are always interested in machine learning; that is what will make your artificial intelligence . intelligent AI or Artificial Intelligence is a replication of human intelligence or behavior in machines. It has been there for decades. Remember those chess games you used to play vs computer as a kid? That IS AI. The program is fed rules and scenarios and trained to take specific actions based on different triggers. The more data and scenarios you feed into the program, the better your AI would get in reacting to triggers. Machine Learning, on the other hand, enables the programs to learn on their own. The machine is now able to come up with its own set of actions based on an understanding and analysis of huge data sets; no longer dependent on hard coded rules and scenarios traditionally fed. SO HOW DOES IT HAPPEN? Let us get back to the chess game. How exactly were the first chess programs written? Let us start with a simple 3x3 grid. Source for chess images — A step-by-step guide to building a simple chess AI This is how the first chess games were built. Every possible move leads to a possibility of more moves, with obvious good or bad moves. Here comes the kicker. The computer doesn’t yet know what qualifies as a good/bad move. You — need to teach it that. Once you have done that — — the computer is ready to play. More scenarios you feed into the system, better equipped it would be at gameplay. the programmer — by feeding in various possible scenarios and assigning weightages to different moves However, I must admit, in that image, a couple of things do not make perfect sense to me. For example, bottom row, third image from the left. It can't or at least shouldn't have the same score as the first two since in that particular scenario, the black rook is at obvious risk. Fifth from the left - same. But, to drive my point home, that image serves its purpose, so let us ignore the technicalities here. I am sure there is a logic behind it. I have to admit, I didn't read it much; not a techie. For even a simple first move, there exist multiple scenarios. There would be two more moves for the knight on the right. That is how you teach the computer different scenarios to expect during gameplay. Now, you can add in a further layer of complexity and teach the computer to anticipate your countermoves based on the computer’s moves. The number of possibilities increases exponentially with each next level you want the computer to anticipate, and weightage of different moves will also change. So, in this particular case, the computer was trained using specific data sets, each of which had inputs and expected and probable outputs. For a good period of time, this is exactly how different AI programs were trained. Deep learning will work differently. It will simultaneously be both more simplified and more complex. It would learn from data sets with no pre-defined or specific structure. A most rudimentary example in this case would be a game of chess designed in such a way that the computer can come up with possible moves for each piece independently on its own — — and access and assign favorable scores to different moves. When you train an AI in this fashion, you are enabling the AI in making logical classifications of the data. for every possible scenario of the gameplay DIVING A BIT DEEPER Before we talk more on deep learning, let’s take a moment to understand . neural network or artificial neural network Without getting into the technical details, think of it this way. Everything YOU see and do — ranging from identifying images, differentiating between colors and sounds, processing speech and text — is attributed to neurons. They take inputs and pass along outputs. Artificial neural network is essentially replicating that same behavior in a computer program. This is how the neural network would look like for a deep learning algorithm. To put it more in context, imagine a face recognition algorithm. Instead of you training your program using individual input parameters, you built it to identify specific parameters and analyze data on those to come up with desired results. ( ) That’s slightly oversimplifying things, but in layman’s language, that’s exactly what it is. LET’S TAKE AN EXAMPLE I used to work with a fashion e-retailer, so let’s pick that. Consider an AI that uses deep learning to suggest optimal pricing points for products. ( ) Yes, discounts!! So what input variables would I include in my algo? Possibly: : How much exposure are products getting? ( ) Visibility For sub-par visibility items, discounting is pointless. Fix visibility first. : Pivotal sizes or off sizes? ( ) Sizes E.g. for men t-shirts M, L, XL are pivotal sizes, S, XXL off sizes : Historical data? Sell thru rate Category Brand ….. For obvious reasons, more parameters you add to the mix, more complex your algo will get, but more robust as well. For now, let’s live with just 5. This is an example of what the neural network will look like — first column represents input variables, and visualization on right represents final output. Focus on just the five columns in between. These are the . hidden layers Notice the number of connections between different neurons? Something that’s noteworthy here would be the ‘ ’ assigned to connections between various neurons. These represent importance of the input value. Initially, are randomly assigned ( ). weight weights weights or assigned based on your understanding of the criticality of various parameters — aka random We would skip on Activation function. What does it do? Standardizes output from each neuron, making the model more accurate. NOW COMES THE DEEP LEARNING. ACTUALLY NOW COMES TRAINING YOUR AI This is when the actual work starts to happen. To train your AI and to make it precise, a large data set is needed. In our case, historical data of pricing patterns and the correlation they have with different parameters we chose. … … Long story cut short, the AI would be trained based on historical input data and comparing the output from your algorithm vs actual output witnessed ( ). The AI would give wrong results to begin with, and that is when the ‘ ’ associated to different neural connections start getting optimised. Your algo automatically takes care of this process, and once done, you’re left with a that you can accurately use on your website. historically weights optimal price suggestion engine Interesting, wasn’t it? ( ). The more I look at it, the more it fascinates me. And it’s not just data from your business, even demographics data, social media data — it all adds up. The way you can use seemingly irrelevant and non-contextual data in driving impact to your business — who wouldn’t love that? Even if the story wasn’t, the business implications surely would have been Btw, if you got overwhelmed there, two things: I actually skipped over a bunch of technical terminologies — , , etc. To keep things simple. Activation Function Loss Function Gradient Descent With more and more out of shelf deep learning algos released by tech majors, the dependency deep learning AI systems have on having access to humongous data sets before they can work is reducing with every passing day. ( ). You’ll still need historical data to improve, but the ‘massive data’ dependency is reducing Another quick simplified pictorial example Also, if you’re a machine learning expert feeling repulsed by the shabby presentation, my apologies. Just trying to help others understand this extremely complex but equally beautiful piece of technology in the simplest way possible. That’s it for today; see you tomorrow! I am Abhishek. I am here... there.... Everywhere... Medium | Twitter | Facebook | Quora | LinkedIn | E-mail Click here to get the best scoop on marketing and business strategy If you want to learn deep learning and neural networks, has a . Michael Nielsen free book

What exactly is deep learning, and how does the magic happen?

15+ Rocking Trends Web Designers Should Know in 2022🤩

Here I would like to talk about converting large, complex data into an easy visual representation format. For that, I pick the most commonly used charts - line, bar, and pie. Actually, there are plenty of charts, but you can find these three in most of the applications made for data analysis or representation. Next, I will explain how to build them by using the popular library D3.js. I’ve created a small demo application. It is a simple dashboard with those charts. I did not use any framework, just HTML, CSS, and JavaScript. Also, I added 3 separate files with data set for each of the charts. I think it is more than enough to begin drawing the charts. But first, let’s take a look at the HTML structure: D3 charts D3 Dashboard Line chart Bar chart Pie chart <!doctype html> < = > html lang "en" < > head < = /> meta charset "UTF-8" < > title </ > title < = = > link rel "stylesheet" href "styles.css" < = = > link href "https://fonts.googleapis.com/css2?family=Roboto&display=swap" rel "stylesheet" < = > script src "https://d3js.org/d3.v7.min.js" </ > script < = = > script type "module" src "charts/bar-chart.js" defer </ > script < = = > script type "module" src "charts/line-chart.js" defer </ > script < = = > script type "module" src "charts/pie-chart.js" defer </ > script </ > head < > body < > header < > span </ > span </ > header < > section < = > div class "bar-line-charts" < = > div class "chart-widget" < = > div class "widget-header" < > span </ > span </ > div < = = > div id "line-chart" class "chart" </ > div </ > div < = > div class "chart-widget" < = > div class "widget-header" < > span </ > span </ > div < = = > div id "bar-chart" class "chart" </ > div </ > div </ > div < = > div class "pie-chart" < = > div class "chart-widget" < = > div class "widget-header" < > span </ > span </ > div < = = = > div id "d3-chart" class "chart" style "padding: 90px" </ > div </ > div </ > div </ > section </ > body </ > html Let’s draw the first chart, it is going to be a pie, then I will continue with the line and bar chart. Pie Chart data element = .getElementById( ); margin = ,
    width = ,
    height = ; radius = .min(width, height) / - margin; svg = d3.select(element)
    .append( )
    .attr( , width)
    .attr( , height)
    .attr( , )
    .append( )
    .attr( , + width / + + height / + ); color = d3.scaleOrdinal()
    .domain(data)
    .range([ , , ]); pie = d3.pie()
    .value( { d[ ].value;
    }); data_ready = pie( .entries(data)); arcGenerator = d3.arc()
    .innerRadius( )
    .outerRadius(radius); svg.selectAll( )
    .data(data_ready)
    .enter()
    .append( )
    .attr( , arcGenerator)
    .attr( , { (color(d.data[ ].name))
    }); svg.selectAll( )
    .data(data_ready)
    .enter()
    .append( )
    .text( { d.data[ ].name
    })
    .attr( , { + arcGenerator.centroid(d) + ;
    })
    .style( , )
    .style( , ); import from '../data/pie-data.js' // Selecting the element const document 'd3-chart' // Setting dimensions const 10 400 400 // Setting the radius of the pie const Math 2 const "svg" "width" "height" "style" "margin-top: -32px !important" "g" "transform" "translate(" 2 "," 2 ")" // Setting the color scale const "#43ab92" "#f75f00" "#512c62" // Setting the position of each group on the pie const ( ) function d return 1 const Object // Building arcs const 0 // Building the pie chart 'slices' 'path' 'd' 'fill' ( ) function d return 1 // Adding titles to pie slices 'slices' 'text' ( ) function d return 1 "transform" ( ) function d return "translate(" ")" "text-anchor" "middle" "font-size" 20 Line Chart lineData element = .getElementById( ); margin = { : , : , : , : },
    width = - margin.left - margin.right,
    height = - margin.top - margin.bottom; createGradient = { gradient = select
        .select( )
        .append( )
        .attr( , )
        .attr( , )
        .attr( , )
        .attr( , )
        .attr( , );

    gradient.append( )
        .attr( , )
        .attr( , );

    gradient.append( )
        .attr( , )
        .attr( , );
} createGlowFilter = { filter = select
        .select( )
        .append( )
        .attr( , )

    filter.append( )
        .attr( , )
        .attr( , ); femerge = filter
        .append( );

    femerge.append( )
        .attr( , );

    femerge.append( )
        .attr( , );
} parseTime = d3.timeParse( ); parsedData = lineData.map( (
    { : item.values.map( ({ : val.total, : parseTime(val.date)
        }))
    })); svg = d3.select(element)
    .append( )
    .attr( , width + margin.left + margin.right)
    .attr( , + margin.top + margin.bottom)
    .attr( , )
    .append( )
    .attr( , ); xScale = d3.scaleTime()
    .domain([
        d3.min(parsedData, (d) => d3.min(d.values, (v) => v.date)),
        d3.max(parsedData, (d) => d3.max(d.values, (v) => v.date))
    ])
    .range([ , width]); yScale = d3.scaleLinear()
    .domain([
        d3.min(parsedData, (d) => d3.min(d.values, (v) => v.total)),
        d3.max(parsedData, (d) => d3.max(d.values, (v) => v.total))
    ])
    .range([height, ]); svg.append( );
svg.call(createGradient);
svg.call(createGlowFilter); line = d3.line()
    .x( { xScale(d.date);
    })
    .y( { yScale(d.total);
    })
    .curve(d3.curveCatmullRom.alpha( )); svg.selectAll( )
    .data(parsedData)
    .enter()
    .append( )
    .attr( , { lineValues = line(d.values).slice( ); splitedValues = lineValues.split( ); })
    .style( , ); svg.selectAll( )
    .data(parsedData)
    .enter()
    .append( )
    .attr( , { line(d.values)
    })
    .attr( , )
    .style( , )
    .style( , )
    .attr( , ); svg.append( )
    .attr( , + height + )
    .call(d3.axisBottom(xScale)); svg.append( )
    .call(d3.axisLeft(yScale)); import from '../data/line-data.js' // Selecting the element const document 'line-chart' // Setting dimensions const top 40 right 30 bottom 7 left 50 900 300 // Adding helper functions to make the line look nice // The <defs> element is used to store graphical objects that will be used at a later time. const ( ) function select const 'defs' 'linearGradient' 'id' 'gradient' 'x1' '0%' 'y1' '100%' 'x2' '0%' 'y2' '0%' 'stop' 'offset' '0%' 'style' 'stop-color:#da6e2a;stop-opacity:0.05' 'stop' 'offset' '100%' 'style' 'stop-color:#da6e2a;stop-opacity:.5' const ( ) function select const 'defs' 'filter' 'id' 'glow' 'feGaussianBlur' 'stdDeviation' '4' 'result' 'coloredBlur' const 'feMerge' 'feMergeNode' 'in' 'coloredBlur' 'feMergeNode' 'in' 'SourceGraphic' // Parsing timestamps const '%Y/%m/%d' const => item values ( ) => val total date // Appending svg to a selected element const 'svg' 'width' 'height' 300 "viewBox" `0 40 ` ${width + } 80 ${height} 'g' 'transform' `translate( , )` ${margin.left} ${margin.top} // Setting X,Y scale ranges const 0 const 0 // Appending <defs> 'defs' // Drawing line with inner gradient // Adding functionality to make line curved const ( ) function d return ( ) function d return 0.5 // Drawing inner part of a line '.line' 'path' 'd' ( ) function d const 1 const ',' return `M0, , ,l0, ` ${height} ${lineValues} ${height - splitedValues[splitedValues.length - ]} 1 'fill' 'url(#gradient)' // Drawing a line '.line' 'path' 'd' ( ) function d return 'stroke-width' '2' 'fill' 'none' 'filter' 'url(#glow)' 'stroke' '#ff6f3c' // Adding the x Axis "g" "transform" "translate(0," ")" // Adding the y Axis "g" Bar Chart barData element = .getElementById( ); margin = { : , : , : , : },
    width = - margin.left - margin.right,
    height = - margin.top - margin.bottom; xScale = d3.scaleBand()
    .range([ , width])
    .padding( ); yScale = d3.scaleLinear()
    .range([height, ]); svg = d3.select(element).append( )
    .attr( , width + margin.left + margin.right)
    .attr( , height + margin.top + margin.bottom)
    .attr( , )
    .append( )
    .attr( , + margin.left + + margin.top + ); barData.forEach( {
    d.value = +d.value;
}); xScale.domain(barData.map( { d.name;
}));
yScale.domain([ , d3.max(barData, { d.value;
})]); svg.selectAll( )
    .data(barData)
    .enter().append( )
    .attr( , { xScale(d.name);
    })
    .attr( , xScale.bandwidth())
    .attr( , { yScale(d.value);
    })
    .attr( , { height - yScale(d.value);
    })
    .style( , ); svg.append( )
    .attr( , + height + )
    .call(d3.axisBottom(xScale)); svg.append( )
    .call(d3.axisLeft(yScale)); import from '../data/bar-data.js' // Selecting the element const document 'bar-chart' // Setting dimensions const top 40 right 20 bottom 50 left 50 900 480 // Setting X,Y scale ranges const 0 0.1 const 0 // Appending svg to a selected element const "svg" "width" "height" "viewBox" `0 40 ` ${width + } 80 ${height} "g" "transform" "translate(" "," ")" // Formatting the data ( ) function d // Scaling the range of the data in the domains ( ) function d return 0 ( ) function d return // Appending the rectangles for the bar chart ".bar" "rect" "x" ( ) function d return "width" "y" ( ) function d return "height" ( ) function d return "fill" "#ff6f3c" // Adding the x Axis "g" "transform" "translate(0," ")" // Adding the y Axis "g" Wrapping up As you can see, all these charts do not have difficult logic. It takes around 70 lines of code to implement it. That is how we can make complex data to be converted in easy visual representation format. Try it yourself! The source code can be found on . I recommend inspecting charts in the DOM to understand how D3 renders the elements. GitHub

Data Visualization for Dummies: 3 Simple Charts with <70 Lines of Code

30 Web Design Trends To Look For in 2021

Dive into the options of chart.js to create stunning charts. Interactive charts can provide a cool way to visualize your data.However most out of the box solutions are not as beautiful as they could be, with default options. I will show you how to customize your chart.js options to make some cool charts! ⚡ Quick Start What we will use: Vue.js vue-chart.js vue-cli We use to create a basic structure. So I hope you got it installed already. And we use as a wrapper for chart.js. vue-cli vue-chart.js vue init webpack awesome-charts Then we go into our project folder and install our dependencies. cd awesome-charts && yarn install And we add : vue-chartjs yarn add vue-chartjs chart.js Our first chart So, let’s create our first line chart. touch src/components/LineChart.js && subl . Now we need to import the Line BaseChart from and create our component. vue-chartjs In the function we need to call the method with our data and options. mount() renderChart() LineChart.js We pass in a basic chart.js data object with some sample data and in the option parameter, we pass So the chart will grow brased on our outer container. responsive: true. ☝ We can call the method because we extended the BaseChart, were this method and some props are defined renderChart() Mount & Test it Now we delete the Hello.vue component from our App.vue and import our chart. App.vue And after we run the dev script in our terminal, we should see our chart. yarn run dev 💄 Make me beautiful Okay, now it is time for some beautification 💅. There are a few cool tricks in chart.js. We can pass a color hex value to But we can also pass a rgba() value. So we can make our color transparent. And as chart.js is using html canvas to draw, we can utilize backgroundColor; createLinearGradient() This is where the fun starts. 🎢 But to use it we need the canvas object. But this is not a big deal, as holds a reference to it. We can access it over vue-chartjs this.$refs.canvas So in our LineChart.js we create two variables to store a gradient. Because we have to datasets. Then we create two gradients: this.gradient = this.$refs.canvas.getContext(‘2d’).createLinearGradient(0, 0, 0, 450) this.gradient2 = this.$refs.canvas.getContext(‘2d’).createLinearGradient(0, 0, 0, 450) There is another cool function we can use: addColorStop() We create three colorStops for each gradient. For 0%, 50% and 100%. this.gradient.addColorStop(0, ‘rgba(255, 0,0, 0.5)’)this.gradient.addColorStop(0.5, ‘rgba(255, 0, 0, 0.25)’);this.gradient.addColorStop(1, ‘rgba(255, 0, 0, 0)’); this.gradient2.addColorStop(0, ‘rgba(0, 231, 255, 0.9)’)this.gradient2.addColorStop(0.5, ‘rgba(0, 231, 255, 0.25)’);this.gradient2.addColorStop(1, ‘rgba(0, 231, 255, 0)’); Now we can pass to . And we have a very nice gradient. To get a nicer effect we also set the borderColor to the individual color with an alpha of 1. (or we use the hex value) And set the borderWidth to 1 and last but not least the pointColor. this.gradient backgroundColor borderColor: ‘#FC2525’,pointBackgroundColor: ‘white’,borderWidth: 1,pointBorderColor: ‘white’, Presentation Last step is to add some styling to the container in our App.vue 👏 Final Result Happy coding!

Creating stunning charts with Vue.js and Chart.js

Creación de gráficos impresionantes con Vue.js y Chart.js

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 💯👍

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

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 Methodology zkFL As shown in , our zkFL system works as follows: Fig. 1 Setup: N clients and 1 aggregator generate their private/public key pairs
and set up communication channels. Each client knows the public keys of
the other n − 1 clients, and this setup can be achieved by using a public key
infrastructure (PKI). Local Training, Encrypting, and Signing: During each round, the n clients train their models locally to compute the local model updates w1, w2, . . . , wn. Each client encrypts their update Enc(wi) = g wi · h si using Pedersen commitment, where g and h are public parameters and si is a random number generated by the client. The client signs the encrypted updates with their private key to generate a signature sigi The client then sends the tuple of local model update, the randomly generated number, encrypted local model update, and signature (wi , si , Enc(wi), sigi) to the aggregator. Global Aggregation and ZKP Generation: The aggregator aggregates the received local model updates w1, w2, . . . , wn to generate the aggregated global model update w = Pni= 1 wi. The aggregator also computes the aggregated value of the encrypted global model update Enc(w) = Qn i=1 Enc(wi) and signs it with its private key to generate the signature sig. The aggregator then leverages zk-SNARK to issue a proof π for the following statement and witness: where the corresponding circuit C(statement, witness) outputs 0 if and only if: Global Model Transmission and Proof Broadcast: The aggregator transfers the aggregated global model update w, its encryption Enc(w) and the proof π to the n clients. Verification: Upon receiving the proof π and the encrypted global model update Enc(w) from the aggregator, the clients verify if π is valid. When the verification is passed, the clients start their local training based on the aggregated global model update w. Blockchain-based zkFL To decrease the computation burden on clients, we incorporate blockchain technology into our zkFL system. In this approach, the verification of proofs generated by the aggregator is entrusted to blockchain miners. Illustrated in Figure 2, the blockchain-based zkFL operates as follows: Setup: N clients and 1 aggregator generate their private/public key pairs, which correspond to their on-chain addresses. Selection: For each round, n clients are selected from the N clients via
Verifiable Random Functions [24,3]. The n selected clients’ public keys are
broadcasted to the underlying P2P network of the blockchain, which will be
received and verified by the miners. Local Training, Encrypting, and Signing: The n selected clients train their models locally to compute the local model updates w1, w2, . . . , wn. Each client encrypts their update Enc(wi) = g wi ·hsi using Pedersen commitment, where g and h are public parameters and si is a random number generated by the client. The client signs the encrypted updates with their private key to generate a signature sigi. The client then sends the tuple of local model update, the randomly generated number, encrypted local model update, and signature (wi , si , Enc(wi), sigi) to the aggregator. Global Aggregation and ZKP Generation: The aggregator aggregates the received local model updates w1, w2, . . . , wn to generate the aggregated global model update w = Pn i=1 wi. The aggregator also computes the aggregated value of the encrypted global model update Enc(w) = Qn i=1 Enc(wi) and signs it with its private key to generate the signature sig. The aggregator then leverages zk-SNARK to issue a proof π for the following statement and witness: where the corresponding circuit C(statement, witness) outputs 0 if and only if: Global Model Transmission and Proof Broadcast: The aggregator transfers the aggregated global model update w and its encryption Enc(w) to the n clients, and broadcasts the proof π, and the encrypted global model update Enc(w) to the miners over the P2P network. On-Chain Verification: Upon receiving the proof π and the encrypted global model update Enc(w) from the aggregator, the miners verify π and append Enc(w) to the blockchain if π is valid. On-Chain Reading: When the next round starts, the newly selected n clients read the blockchain to check if Enc(w) is appended on-chain. When the check is valid, the clients start their local training based on the aggregated global model update w.

Zero Knowledge Proof based Gradient Aggregation for Federated Learning: Methodology

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 Related Work Zero-Knowledge Proofs. Zero-knowledge proofs (ZKPs) have emerged as a revolutionary cryptographic concept that allows one party (the prover) to demonstrate the truth of a statement to another party (the verifier) without revealing any information beyond the statement’s validity [12]. One of the most notable applications of ZKPs is in privacy-preserving authentication, where a user can prove to a aggregator that they know a secret without revealing the secret itself. ZKPs have also been applied in other areas, including blockchains [28,30], machine learning [22,31,9] and FL [6]. However, existing research, such as RoFL [6,21], has predominantly focused on using ZKPs to address malicious client behaviors or enhance the client privacy, while assuming the existence of a “honest-butcurious” (i.e., semi-honest) aggregator. In this work, we break away from this assumption and leverage ZKPs to ensure the honest aggregation of the centralized aggregator without requiring trust in the aggregator itself. Blockchain-based Federated Learning. Blockchain is a decentralized and immutable distributed ledger technology [15,10,4] that underpins cryptocurrencies such as Bitcoin [25] and Ethereum [33]. It provides a secure and transparent way to record and verify transactions across a network of nodes. Blockchain has been integrated with FL to tackle the security and privacy issues in existing FL [34,16,27,19,32]. Specifically, blockchain is used to store and manage the training model’s updates and the associated metadata securely and transparently. Instead of relying solely on a centralized aggregator to manage the model updates, the blockchain enables a decentralized and distributed consensus mechanism among the participating clients. However, existing blockchain-based FL designs [8] rely heavily on the computation of smart contracts (i.e., self-executing programs that run on a blockchain network and are triggered by blockchain events), which will cause expensive costs for FL networks with a large number of parameters. In our work, we address the scalability issue of blockchain-based FL by using zero-Knowledge proofs. Preliminaries In this section, we present the cryptographic building blocks for our zkFL system. Commitments. A commitment scheme enables an entity to conceal a value while committing to it, with the ability to disclose the value at a later time if desired. The commitment scheme typically comprises two rounds: the committing round and the revealing round. In the committing round, the client commits to specific values while ensuring their confidentiality from others. The client retains the option to reveal the committed value in the subsequent revealing round. A commitment scheme includes two algorithms: cm ← Commit(m, r) accepts a message m and a secret randomness r as inputs and returns the commitment cm. 0/1 ← Verify(m, r, cm) accepts a message m, a commitment cm and a decommitment value r as inputs, and returns 1 if the commitment is opened correctly and 0 otherwise. In this paper, we leverage Pedersen commitments [26,1] to compute the clients’ commitments/encryption on their local training model updates. Specifically, given the model update wi , a client will encrypt the update by computing Enc(wi) = g wi · h si , where g and h are public parameters and si is a random number generated by the client. Zero-Knowledge Proof Zero-knowledge proof [18,11,29] is a cryptographic primitive that allows a prover to convince the verifier about the correctness of some assertions without providing any meaningful information to the verifier. A zeroknowledge proof of some statement satisfies the following three properties: Completeness: If the statement st is true, an honest verifier will always be convinced by an honest prover. Soundness: For false statements, a prover cannot convince the verifier (even if the prover cheats and deviates from the protocol). Zero-knowledge: No verifier learns anything other than the fact that st is valid if it is true. In other words, knowing the statement, but not the secret, is enough to construct a scenario in which the prover knows the secret. A zero-knowledge Succinct Non-interactive ARgument of Knowledge (zkSNARK) is a “succinct” non-interactive zero-knowledge proof (NIZK) for arithmetic circuit satisfiability. The construction of zk-SNARK is based on a field F and an arithmetic circuit C. An arithmetic circuit satisfiability problem of a circuit C : F n × F h → F l is captured by the statement stC : {(x,wit) ∈ F n × F h : C(x,wit) = 0l}, with the language LC = {x ∈ F n | ∃ wit ∈ F h s.t. C(x,wit) = 0 l}. Apart from correctness, soundness, and zero-knowledge properties of zeroknowledge proof, a zk-SNARK requires two additional properties, i.e., succinctness and simulation extractability [12,2]. System and Threat Models In this section, we outline our system model, threat model, and system goals. System Model In the context of FL, clients represent individual devices, such as smartphones, tablets, or computers, each possessing its local dataset. These datasets remain secure and never leave the clients’ devices. Instead, the clients independently train their machine learning models on their local data and communicate only the model updates to the central aggregator. Clients: The aggregator acts as a central entity responsible for aggregating these model updates from multiple clients and computing a global model. This global model is then sent back to the clients, ensuring that each client benefits from the collective knowledge of the entire network while preserving data privacy and security. Aggregator: Threat Model We consider a malicious aggregator that can choose not to honestly aggregate the local model updates from clients. The malicious aggregator can deviate from the protocol by: Abandoning the updates generated from one or several honest clients. Creating fake model updates to replace the updates generated from honest clients Inserting fake model updates to the updates generated from honest clients. We would like to remark that the scope of this work centers around the malicious aggregator rather than the honest-but-curious one, with a specific emphasis on ensuring aggregation integrity. We also acknowledge the potential for the aggregator to carry out model inversion attacks on the clients, a topic we intend to delve into in a future study. System Goals The aggregator cannot abandon or replace the local model updates generated from honest clients, nor insert any fake model updates into the final aggregated model update. Otherwise, the clients will detect the malicious behaviors of the aggregator and halt the FL training process. Security: Only the participants (i.e., the aggregator and clients) in the FL system can know the aggregated model updates during each round. Privacy:

Zero Knowledge Proof based Gradient Aggregation for Federated Learning: Related Work & Preliminaries

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 Abstract Federated Learning (FL) is a machine learning paradigm, which enables multiple and decentralized clients to collaboratively train a model under the orchestration of a central aggregator. Traditional FL solutions rely on the trust assumption of the centralized aggregator, which forms cohorts of clients in a fair and honest manner. However, a malicious aggregator, in reality, could abandon and replace the client’s training models, or launch Sybil attacks to insert fake clients. Such malicious behaviors give the aggregator more power to control clients in the FL setting and determine the final training results. In this work, we introduce zkFL, which leverages zero-knowledge proofs (ZKPs) to tackle the issue of a malicious aggregator during the training model aggregation process. To guarantee the correct aggregation results, the aggregator needs to provide a proof per round. The proof can demonstrate to the clients that the aggregator executes the intended behavior faithfully. To further reduce the verification cost of clients, we employ a blockchain to handle the proof in a zero-knowledge way, where miners (i.e., the nodes validating and maintaining the blockchain data) can verify the proof without knowing the clients’ local and aggregated models. The theoretical analysis and empirical results show that zkFL can achieve better security and privacy than traditional FL, without modifying the underlying FL network structure or heavily compromising the training speed. Introduction Federated Learning (FL) is a privacy-preserving machine learning paradigm that allows multiple clients to collaboratively train a global model without sharing their raw data [23]. In FL, each participant (i.e., client) performs local training on its own private dataset and communicates only the model updates to the central server (i.e., aggregator). The aggregator aggregates the model updates and sends the updated global model back to the clients. This process repeats iteratively until the global model converges or a stopping criterion is fulfilled. During the cross-device FL process, participants need to place their trust in the aggregator to create cohorts of clients in a fair and unbiased manner. However, a potential vulnerability is that an actively malicious adversary with control over the aggregator could exploit this trust [17]. For instance, adversaries could carry out a Sybil attack [7] by simulating numerous fake client devices, and the adversary could also selectively favor previously compromised clients’ model updates from the pool of available participants. These attacks have the potential to enable the adversary to manipulate the final training results in FL, compromising the integrity of the learning process. Safeguarding against such threats is imperative to maintain the effectiveness and security of cross-device FL. In this work, we present zkFL (cf. Fig. 1), an innovative approach that integrates zero-knowledge proofs (ZKPs) into FL. Without changing the learning setup of the underlying FL method, this integration guarantees the integrity of aggregated data from the centralized aggregator. Zero-knowledge proofs (ZKPs) [12,28,6,22] are widely recognized cryptographic tools that enable secure and private computations while safeguarding the underlying data. In essence, ZKPs empower a prover to convince a verifier of a specific fact without revealing any information beyond that fact itself. Within the context of zkFL, ZKPs play a pivotal role in addressing the challenge posed by a potentially malicious aggregator during the model aggregation process. To achieve accurate aggregation results, the aggregator must provide a proof for each round, demonstrating to the clients that it has faithfully executed the intended behavior for aggregating the model updates. By verifying these proofs, the clients can ensure the aggregator’s actions are transparent and verifiable, instilling confidence that the aggregation process is conducted with utmost honesty. Furthermore, in order to minimize the verification burden on the clients, we propose a blockchain-based zkFL solution to handle the proof in a zeroknowledge manner. As shown in Fig. 2, in this approach, the blockchain acts as a decentralized and trustless platform, allowing miners, the nodes validating and maintaining the blockchain data [25,4], to verify the authenticity of the ZKP proof without compromising the confidentiality of the clients’ models. By incorporating blockchain technology into our zkFL system, we establish a robust and scalable framework for conducting zero-knowledge proof verification in a decentralized and transparent manner. This not only enhances the overall efficiency of the zkFL system but also reinforces the confidentiality of the participants’ data, making it a promising solution for secure and privacy-conscious cross-device FL. Our contributions can be summarized as follows: We present zkFL, an innovative ZKP-based FL system that can be integrated with existing FL methods. zkFL empowers clients to independently verify proofs generated by the centralized aggregator, thereby ensuring the accuracy and validity of model aggregation results. zkFL effectively addresses the threats posed by the malicious aggregators during the training model aggregation process, enhancing security and trust in the collaborative FL setting. We integrate zkFL with blockchain technology to minimize clients’ computation costs for verification. Leveraging the zero-knowledge property of ZKPs, 3 our blockchain-based zkFL significantly improves overall efficiency while preserving clients’ model privacy. We present rigorous theoretical analysis on the security, privacy, and efficiency of zkFL. We further evaluate these properties under benchmark FL setups. The results of these experiments demonstrate the practical feasibility and effectiveness of zkFL in real-world scenarios.

Zero Knowledge Proof based Gradient Aggregation for Federated Learning: Introduction

This article illustrates how to build, in less than 5 minutes, a simple with gradient descent. The goal is to predict a dependent variable (y) from an independent variable (X). linear regression model We want to predict salaries given years of experience. For that, we will explain a few concepts (Gradient descent, Linear model) and code 4 functions: : To predict a salary from years of experience. (We found the best coefficients, B0 and B1, thanks to the gradient descent). Predict function : It allows the visualization of the cost errors to each iteration. It uses mean squared error (the difference between the prediction and the real values). Cost function : Find the best coefficients B0 and B1. Gradient descent : Used to display scatter plots of values predicted from the model and real values with matplotlib. Print graph After that, we will train our model using the learning rate. Finally, we find the best coefficient and predict new values never seen by the model. Linear model In machine learning, the linear model is a regression model searching for the relationship between the independent variable (X) and the dependent variable. In this article, we dive into simple linear regression (with only one independent variable). The formula for simple linear regression is: y = B0 + B1x y is the variable we want to predict x is the independent variable (input variable) B0 is the term representing y when x = 0 B1 is the coefficient (weight) linked to x. When you build a simple linear regression model, the goal is to find the parameters B0 and B1. To find the best parameters, we use gradient descent. Imagine your model finds that the best parameters are B0 = 10 and B1 = 12. If you want to predict y (salary) based on new data (10 years of experience), you just need to calculate it. y (salary) = 10 + (12 * 10) = 130k With a simple calculation, your model succeeds in predicting a salary (130k) based on unknown data (10 years of experience). Gradient descent Gradient descent is one of the methods to train the model and find the best parameters/coefficient (B0 and B1). For that, it calculates the errors and adjusts the gradients according to the partial derivative. Below, I detail and explain the B0 and B1 calculations. exp = np.array([1, 2, 3, 4, 5])
salaries = np.array([30, 40, 50, 60, 70])

learning_rate = 0.1
B0 = 2
B1 = 2

pred = B0 + B1 * exp
     = 2 + (2 * [1, 2, 3, 4, 5])
     = 2 + (2 + 4 + 6 + 8 + 10)
     = [4 + 6 + 8 + 10 + 12]

errors = pred - salaries
       = [4 + 6 + 8 + 10 + 12] - [30, 40, 50, 60, 70]
       = [-26, -34, -42, -50, -58]

gradient_B0 = sum(errors) / len(exp)
            = sum([-26, -34, -42, -50, -58]) / 5
            = -42

gradient_B1 = sum(errors * exp) / len(exp)
            = sum([-26 * 1, -34 * 2, -42 * 3, -50 * 4, -58 * 5]) / 5
            = sum([-26, -68, -126, -200, -290]) / 5
            = -142

B0 = B0 - (gradient_B0 * learning_rate)
   = 2 - (-42 * 0.1)
   = 2 - (-4.2)
   = 6.2

B1 = B1 - (gradient_B1 * learning_rate)
   = 2 - (-142 * 0.1)
   = 2 - (-14.2)
   = 16.2 First, we define an arbitrary or random value for B0 and B1. Based on the formula B0 + B1 * exp, we calculate prediction. Afterward, we calculate errors. Errors are the prediction minus real values (salaries). We use those errors to find gradient_B0 and gradient_B1. Why do we need gradient_B0 and gradient_B1? In simple words, gradient descent tries to find the line-minimizing errors. For that, it updates B0 (Intercept) and B1 (Slope). B0 represents the value of y when x is 0. B1 represents the change in y for a unit change in x. For example, if y increases by 10 when x increases by 1, B1 would be 10. In each iteration, gradient descent will reduce the cost by adjusting the intercept and slope with new values. Creating functions Predict function First of all, we start with the predict function. def predict(exp, B0, B1):
  return B0 + B1 * exp To understand it, I will share the formula of simple linear regression and briefly explain the role of coefficients B0 and B1. linear regression formula: y = β0​ + β1 ​⋅ X+ϵ y is the variable we want to predict (salary) X is the independent variable (years of experience) B0 and B1 are the coefficients we adjust to find the lower cost. The most the cost is the better the predictions will be. Cost function The role of the cost function is to calculate the difference between prediction and real values. For this article’s purpose, I only print the cost for each iteration. According to your need, you can code your own cost function and use it to adjust the parameters of your model. I use mean squared error: MSE = (1/n) * Σ(yi — ŷi)² n is the number of samples yi is the real value ŷi is the predicted value I wrote an article in detail. explaining the MSE def mse_cost_function(error, predictions):
  return np.sum(error ** 2) / (2 * len(predictions)) Gradient descent We apply gradient descent using the learning rate. Its purpose is to adjust the model parameters during each iteration. It controls how quickly or slowly the algorithm converges to a minimum of the cost function. I fixed its value to 0.01. Be careful, if you have a learning rate too high, the gradient descent could never converge towards the minimum. def gradient_descent(exp, salaries, B0, B1, learning_rate, num_iterations):
    num_samples = len(exp)
    cost_history = []
    for _ in range(num_iterations):
        predictions = predict(exp, B0, B1)
        error = predictions - salaries
        gradient_B0 = np.sum(error) / num_samples
        gradient_B1 = np.sum(error * exp) / num_samples
        B0 -= learning_rate * gradient_B0
        B1 -= learning_rate * gradient_B1
        cost = mse_cost_function(error, predictions)
        cost_history.append(cost)
    return B0, B1, cost_history Scatter plot function We display the cost history we saved in the gradient descent. You can try several learning rates and a number of iteration variables to see the impact on the cost curve. Below I tried with num_iterations = 200 def print_graph(exp, salary):
    plt.scatter(exp, salary, label="Real values")
    plt.plot(exp, predict(exp, B0, B1), color='red', label="Linear Regression")
    plt.xlabel("Years of experience")
    plt.ylabel("Salary")
    plt.legend()
    plt.show() Training the model Importing the libraries and initializing variables. exp is an independent variable representing years of experience salaries is a dependent variable representing salary I set up arbitrary values for B0, B1, learning_rate, and num_iterations. num_iterations represents the number of iterations/steps the algorithm performs. import numpy as np
import matplotlib.pyplot as plt
exp = np.array([1, 2, 3, 4, 5])
salaries = np.array([30, 40, 50, 60, 70])
B0 = 2
B1 = 2
learning_rate = 0.01
num_iterations = 1000
B0, B1, cost_history = gradient_descent(exp, salaries, B0, B1, learning_rate, num_iterations)
print_graph(exp, salaries) Visualize Cost Evolution We simply use matplotlib to display a scatter plot of cost_history. It allows us to visualize cost by iteration, in the first iterations, the cost is high, while at the end, the cost tends to be 0. plt.plot(range(num_iterations), cost_history, marker='o')
plt.xlabel('Iteration')
plt.ylabel('Cost')
plt.title('Cost Evolution during Gradient Descent')
plt.axis([0, num_iterations, 0, max(cost_history)])
plt.show() Predict New value After finding the best coefficients, B0 and B1, we are now able to predict new values. For 30 years of experience, our model predicts a salary of 339.73k. new_prediction = predict(30, B0, B1)
print(new_prediction) Conclusion We saw the different steps to code a simple linear regression model. Explaining concepts such as Linear relationship, gradient descent, learning rate, and coefficient representing the intercept and slope. We implemented gradient descent with by calculating B0 et B1, Python and finally, printing the cost evolution with matplotlib. You can find the full source code on and . Kaggle Github Also published here.

How to Implement Gradient Descent with a Linear Regression Model

In the world of programming, seemingly straightforward tasks can unravel into complex challenges. Recently, we encountered one such challenge while attempting to transform a Figma design into code. The task at hand involved creating a radial dial with a linear gradient – a seemingly simple requirement that soon proved to be more intricate than expected. In this post, we’ll delve into the world of SVG gradients and explore the solution we devised to tackle the challenges that arose and argue why sometimes, being given complex engineering challenges like this can be highly rewarding. Thrown a curveball At first, it seemed simple. There must be a library we can use to create the dial and apply a linear gradient to it. How hard could it be? And after a quick search of investigating libraries such as and , we did find libraries capable of creating radial dials as well as generating linear gradients using SVG. However, the real complexity emerged when attempting to combine these two elements seamlessly. The obstacle lay in the nature of linear gradients defined within SVG. By default, linear gradients transition between colors along a straight line. When applied to the stroke of a circular path, the gradient’s direction remains linear, disregarding the curve of the circle. High Charts FusionCharts Consequently, if we were to apply a linear gradient to a complete circular dial created with a single curve, the gradient would follow a straight path rather than the desired radial path along the dial. That wouldn’t achieve the curved gradient that we were looking for – so it was back to the drawing board. Breaking up the problem Instead, to achieve the effect of a smoothly transitioning gradient encircling the radial dial, we realized we needed to break the dial into multiple sections and apply distinct gradients to each section. In our example, we divided the dial into four sections; each assigned its own linear gradient. By thoughtfully selecting the colors for the gradient stops, we were able to create a continuous gradient appearance around the dial. Here, we start to see how we can construct a radial dial in SVG. The “d” attribute defines a path to be drawn. In this case, it specifies the path for the first quarter of our radial dial. The ‘M’ stands for “Move To” and sets the initial point of the path at the coordinates (150,10). The ‘a’ command creates an elliptical arc. This arc command has several parameters. The first two parameters, ‘120 120’, set the x and y radius of the ellipse used to draw the arc. The ‘0 0 1’ defines the x-axis rotation (which is zero), large-arc-flag, and sweep-flag. The final ‘103.9230 60’ sets the end point of the path, which completes our arc. We then apply the gradient with the stroke attribute on the path. This process is repeated for each quarter of the dial. Each quarter gets its own path and its own gradient. This gives the effect of a single, smoothly transitioning gradient circling around the dial. Dynamic Gradient Filling To dynamically fill the gradient along the dial, we leveraged the stroke-dashoffset and stroke-dasharray properties of the SVG path. This technique is commonly employed when creating radial dials. CSS tricks has an in-depth write-up on the approach: . SVG line animation works By setting the stroke-dasharray equal to the length of the path, we established a pattern of dashes and gaps resembling a dotted line encircling the circle. The stroke-dashoffset property determined the starting point of the dash pattern, effectively animating the stroke’s movement. By animating the stroke-dashoffset from the start of the path to the length of the path, the dash appeared to “travel” around the circle. Embracing Complexity (Sometimes) While complex designs can translate into difficult technical challenges, they also serve as opportunities for programmers to hone their problem-solving skills. This is an integral part of what keeps programming interesting, at least for me. The complexities we face in programming often reflect the complexity of the designs we’re working from. Our Figma design, featuring a radial dial with a linear gradient, serves as a great example of how a visually appealing design element can introduce significant technical challenges. It’s easy as programmers to instinctively try and work with designers to come up with a compromise in terms of design spec. In fact, that’s often the right approach. But sometimes, if you want your designs to stand out from the crowd, you’ll need to instead push past your comfort zone and come up with creative ways of solving your problems. Another way to put this is while design complexities can translate into technical challenges, they also serve as opportunities for programmers to hone their most valuable skill, their ability to problem-solve. Also published . here

Solving a Curved Programming Challenge with SVG Gradients

Resolviendo un desafío de programación curva con gradientes SVG

Résoudre un défi de programmation courbe avec des dégradés SVG

एसवीजी ग्रेजुएट्स के साथ एक घुमावदार प्रोग्रामिंग चुनौती का समाधान

SVG グラデーションを使用して曲線プログラミングの課題を解決する

Resolvendo um desafio de programação curva com gradientes SVG

Giải quyết thách thức lập trình cong với SVG Gradients

使用 SVG 渐变解决曲线编程挑战

Have you ever wished you could bring your imagination to life with the help of AI-generated images? Well, now you can! In this blog post, I'll introduce you to an AI model that can generate mesmerizing images from your text prompts. This guide will walk you through using the Stable Diffusion Aesthetic Gradients model, ranked 409th on . We'll also see how we can use Replicate Codex to find similar models and decide which one we like. Let's begin. Replicate Codex About the Stable Diffusion Aesthetic Gradients Model This AI model, called Stable Diffusion Aesthetic Gradients, is created by and is designed to generate captivating images from your text prompts. You can find the model's details on its . The model offers a wide range of customization options to help you create the perfect image for your creative project. cjwbw detail page What are aesthetic gradient embeddings? Aesthetic gradient embeddings are a fascinating aspect of AI models that involve the use of textual inversion. But first, let's understand what an embedding is. An embedding is the outcome of textual inversion, which is a method used to define new keywords in a model without modifying it. This approach has gained popularity because it can introduce new styles or objects to a model using as few as 3-5 sample images. What is textual inversion? Textual inversion works in a unique way. Its most impressive feature is not the ability to add new styles or objects, as other fine-tuning methods can do that too, but the fact that it can achieve this without changing the model. The process involves defining a new keyword that's not in the model for the new object or style. This new keyword gets tokenized (represented by a number) like any other keywords in the prompt. Each token is then converted into a unique embedding vector used by the model for image generation. Textual inversion finds the embedding vector of the new keyword that best represents the new style or object, without modifying any part of the model. Essentially, it's like finding a way within the language model to describe the new concept. How can you use embeddings? Embeddings can be used for new objects, such as injecting a toy cat into an image. The new concept (toy cat) can be combined with other existing concepts (boat, backpack, etc.) in the model. Embeddings can also represent a new style, allowing the transfer of that style to different contexts. If you're looking for a repository of custom embeddings, Hugging Face hosts the Stable Diffusion Concept Library, which contains a large number of them. Understanding the Inputs and Outputs of the Stable Diffusion Aesthetic Gradients Model Before diving into the step-by-step guide, let's first understand the inputs and outputs of this model. Inputs (string): The text prompt to render. Default value: "a painting of a rvirus monster playing guita" prompt (integer): How many samples to produce for each given prompt. A.k.a. batch size. Allowed values: 1, 4. Default value: 1 n_samples (integer): Width of the output image. Scale down if run out of memory. Allowed values: 128, 256, 512, 768, 1024. Default value: 512 width (integer): Height of the output image. Scale down if run out of memory. Allowed values: 128, 256, 512, 768, 1024. Default value: 512 height (number): Unconditional guidance scale: eps = eps(x, empty) + scale * (eps(x, cond) - eps(x, empty)). Default value: 7.5 scale (integer): Number of ddim sampling steps. Default value: 50 ddim_steps (boolean): Set to true to use plms sampling. Default value: false plms (string): Aesthetic embedding file. Allowed values: gloomcore, flower_plant, sac_8plus, cloudcore, aivazovsky, glowwave, fantasy, laion_7plus. Default value: sac_8plus aesthetic_embedding (integer): Number of steps for the aesthetic personalization. Default value: 10 aesthetic_steps (integer): The seed (for reproducible sampling). seed Outputs The output of the model is an array of URI strings, each representing an image generated based on the input parameters provided. Now that we understand the inputs and outputs, let's move on to the step-by-step guide for using the model. A Step-by-Step Guide to Using the Stable Diffusion Aesthetic Gradients Model If you're not up for coding, you can interact directly with this model's "demo" on Replicate via their UI. You can use to interact directly with the interface and try it out! This is a nice way to play with the model's parameters and get some quick feedback and validation. If you do want to use coding, this guide will walk you through how to interact with the model's Replicate API. this link Step 1: Install the Node.js client First, install the Node.js client by running the following command: npm install replicate Step 2: Set up your API token Next, copy your API token and authenticate by setting it as an environment variable: export REPLICATE_API_TOKEN=[token] Step 3: Run the model Now, you can run the model with the following code: import Replicate from "replicate";

const replicate = new Replicate({
  auth: process.env.REPLICATE_API_TOKEN,
});

const output = await replicate.run(
  "cjwbw/stable-diffusion-aesthetic-gradients:e2589736f21fd0479499a6cd55002f75085f791c0780c987dc0925f8e2bcb070",
  {
    input: {
      prompt: "Roman city on top of a ridge, sci-fi illustration by Greg Rutkowski #sci-fi detailed vivid colors gothic concept illustration by James Gurney and Zdzislaw Beksiński vivid vivid colorsg concept illustration colorful interior
"
    }
  }
); You can also specify a webhook URL to be called when the prediction is complete. Take a look at the webhook docs for details on setting that up. For example: const prediction = await replicate.predictions.create({
  version: "e2589736f21fd0479499a6cd55002f75085f791c0780c987dc0925f8e2bcb070",
  input: {
    prompt: "a painting of a rvirus monster playing guita"
  },
  webhook: "https://example.com/your-webhook",
  webhook_events_filter: ["completed"]
}); To learn more, take a look at the Node.js library documentation. Taking it Further - Finding Other Text-to-Image Models with Replicate Codex Replicate Codex is a fantastic resource for discovering AI models that cater to various creative needs, including image generation, image-to-image conversion, and much more. It's a fully searchable, filterable, tagged database of all the models on Replicate, and also allows you to compare models and sort by price or explore by the creator. It's free, and it also has a digest email that will alert you when new models come out so you can try them. If you're interested in finding similar models to Stable Diffusion Aesthetic Gradients... Step 1: Visit Replicate Codex Head over to to begin your search for similar models. Replicate Codex Step 2: Use the Search Bar Use the search bar at the top of the page to search for models with specific keywords, such as "anime style" or "selfie." This will show you a list of models related to your search query. Step 3: Filter the Results On the left side of the search results page, you'll find several filters that can help you narrow down the list of models. You can filter and sort by models by type (Image-to-Image, Text-to-Image, etc.), cost, popularity, or even specific creators. By applying these filters, you can find the models that best suit your specific needs and preferences. For example, if you're looking for an that's the cheapest or most popular, you can search and then sort by the relevant metric. image restoration model Conclusion In this guide, we walked through the process of using the Stable Diffusion Aesthetic Gradients model to generate captivating images from text prompts. We also discussed how to leverage the search and filter features in Replicate Codex to find similar models and compare their outputs, allowing us to broaden our horizons in the world of AI-powered image generation. I hope this guide has inspired you to explore the creative possibilities of AI and bring your imagination to life. Don't forget to subscribe for more tutorials, updates on new and improved AI models, and a wealth of inspiration for your next creative project. Happy image enhancing and exploring the world of AI with , check out additional guides and resources at , and follow me on for more updates and insights. Replicate Codex Notes by Replicate Twitter Also published . here

Stable Diffusion Aesthetic Gradients: A Comprehensive Guide

In this article, I have shown you how to make Gradient Color Generator using JavaScript. Earlier I shared with you how to make many more types of random color generators. However, in this project, you can manually create the color of your choice. to learn how it works. Here's how to choose a color using HTML's color input. Watch its live demo This allows you to choose the color of your choice and combine it with different angles to create a Gradient Color. You can do the work of creating Gradient Color manually. But this project will help you to create the perfect color. You need to have an idea about basic HTML CSS and JavaScript to build it. Here I have given a complete step-by-step tutorial and necessary source code. First, I made a box, and there is a small display in that box. The colors can be seen in the display. Then, there is a box in which the color code can be found. I created two color input boxes with the help of HTML. A select box has been created to select the angle. HTML Code of Gradient Color Generator The following code is the HTML code required to create this Gradient Color Generator. Below I have shown all the codes broken down. But if you want all the code at once, you can take the help of this link to . download the source code Basic Structure The following HTML code helped to create the basic structure. <div class="random-color">

</div> Color Display Created a display using the code below.The Gradient Color can be seen in this display. 
<div class="display" id="gradient"></div> Color Code Box Now I have created a box in which the color codes can be seen. 
<div class="codess"></div> Color Input Now I have created the color input box. In HTML, we get many types of input. In which 'color' is a kind of input. 
<input type="color" class="color1" name="color1" value="#FFAAAA">
<input type="color" class="color2" name="color2" value="#734C8F"> HTML Select Box Now I have created a select box with different angles. As a result, you can select the angle of your choice and add two colors. 
<select name="toDirection">
  <option value="to right">to right</option>
  <option value="to left bottom">to left bottom</option>
  <option value="to left top">to left top</option>
  <option value="to bottom">to bottom</option>
  <option value="to top">to top</option>
  <option value="to right bottom">to right bottom</option>
  <option value="to right top">to right top</option>
  <option value="to left">to left</option>
</select> Gradient Color Generator's CSS Code We have used the HTML code above, but now is the time to design HTML with CSS code. I designed the web page using the following CSS code. html {
  height: 100%;
  -webkit-background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  background-size: cover;
  background-repeat:no-repeat;
}

body {
  color: #035aab;
  text-align: center;
} I have designed the box using the following CSS. Box width: 350px and height: 400px are used here. I didn't use any background color here, so I added box-shadow. .random-color{
  width: 350px;
  box-shadow: 0 0 20px rgba(0,139,253,0.25);
  margin: 50px auto;
  padding: 20px; 
  height: 400px;
} Now I have designed the display. Display and . Here a background Gradient color is used, which can be seen in normal condition. This color will change when you change the value of the input function. width: 350px height: 200px .display{
  width: 350px;
  height: 200px;
  border: 2px solid white;
  box-shadow: 0 0 20px rgba(1,1,1,0.35);
  background: linear-gradient(to right, #FFAAAA, #734C8F)
} Now the box is designed to see the color code. It will determine its own size based on the amount of content. .codess{
  padding: 5px;
  margin-top: 30px;
  margin-bottom: 30px;
  font-family: sans-serif;
  letter-spacing: 1px;
  box-shadow: 0 0 20px rgba(0,139,253,0.25);
} Now the space for color input has been designed. The width of those two input boxes: 70px, height: 40px and have been used to keep it along the left side. float: left .color1,.color2{
  width: 70px;
  height: 40px;
  float: left;
  margin: 10px;
  margin-top: 20px;
} Now I have done some basic design of the select box. Box and . width: 130px height: 35px select{
 float: right;
 margin-top: 25px;
 width: 130px;
 height: 35px;
} Activate the Color Generator using JavaScript Above, we have completed the basic design of the . But now, it is time to implement this color generator with the help of JavaScript. Gradient Color Generator First, a global constant of some IDs and class functions is determined. //Some classes and html functions need to determine a constant
var css = document.querySelector(".codess") // color code
var color1 = document.querySelector(".color1") // 1st color
var color2 = document.querySelector(".color2") // 2nd color
var bodys = document.getElementById("gradient") // color display
var linearDirection = document.getElementsByName("toDirection")[0]  //Select box Now, I have arranged for the color codes to be shown on the display. I have indicated here that the color that can be seen in the display can be seen in the form of CSS code in the code box. helped make this work. getPropertyValue () method interface returns a DOMString containing the value of a specified CSS property. GetPropertyValue Then I took the help of to show all the information in the box. textContent function currentSettings() {
    var CSSprop = window.getComputedStyle(bodys,null).getPropertyValue("background-image")
   // console.log(CSSprop)
    css.textContent = CSSprop
}

currentSettings() I have given instructions here in which format the color codes can be seen in this code box. The color codes can be seen in the box according to this format. With this, I have arranged to see the color in the display. In I have added all formats. Its color can be found on the display. That means it will do two things at once. "bodys.style.background" In this format, the values ​​of each of these elements are added. As a result, when you change the value of the input, the information in the code box will continue to change. function returnColor(){

  bodys.style.background =
    "linear-gradient("
    + linearDirection.value
    + ", "
    + color1.value
    + ","
    + color2.value
    + ")";

    currentSettings()

} Now I have connected all the input functions with the calculations above. helped. As a result, when you make any changes to the input box, all of the above systems will change. "ReturnColor" document.querySelector('select[name="toDirection"]').onchange=returnColor;
color1.addEventListener("input", returnColor)
color2.addEventListener("input", returnColor) Complete JavaScript Below, I have put together the complete JavaScript, which will help you to understand these codes better. //Some classes and html functions need to determine a constant
var css = document.querySelector(".codess") // color code
var color1 = document.querySelector(".color1") // 1st color
var color2 = document.querySelector(".color2") // 2nd color
var bodys = document.getElementById("gradient") // color display
var linearDirection = document.getElementsByName("toDirection")[0]  //Select box



function currentSettings() {
    var CSSprop = window.getComputedStyle(bodys,null).getPropertyValue("background-image")
   // console.log(CSSprop)
    css.textContent = CSSprop
}

currentSettings()


 function returnColor(){

  bodys.style.background =
    "linear-gradient("
    + linearDirection.value
    + ", "
    + color1.value
    + ","
    + color2.value
    + ")";

    currentSettings()

}


document.querySelector('select[name="toDirection"]').onchange=returnColor;
color1.addEventListener("input", returnColor)
color2.addEventListener("input", returnColor) I hope you understand JavaScript above. If there is any problem, then you can take the help of the video tutorial. If you like this tutorial, then you . Please comment on how you like it. You can download the if you want. must like the article complete source code

Making a Gradient Color Generator App Using JavaScript

This blog post is a small tutorial in which I show you how you can create a gradient border blog card using Tailwind CSS. I am assuming that you have some basic knowledge about Tailwind CSS and Next.js. For this project, I have chosen as a framework because using this one command you can initialize a next-app with . Next.js Tailwind CSS npx create-next-app -e with-tailwindcss my-project
cd my-project You may choose other frameworks like react.js, vue.js or you can simply do this in an HTML file also by using the . Tailwind CSS CDN Now open the project and open the index.js file inside the directory. Pages Now delete all the code inside the Home() function, so that it looks something like this. import Head from "next/head";

export default function Home() {
    
    return (
        <div>
         <Head>
            <title>Blog PostCard Tutorial</title>
            <link rel="./favicon.ico" />
         </Head>
       </div>

    );
} Now create a folder in the root directory and inside that folder create a file and write the following code shown below. components BlogPostCard.js const BlogPostCard = () => {
  return (
   <div className="">
      {/* Gradient background of same width & height  as Blog post card  */}
      <div className="">
        <div className="">
          <div className="">
            {/* PostImage */}

            <img src="/postImage.png" className="" />
            {/* Post title */}

            <h1 className="">
              This is first title.
            </h1>
            {/* Post Data/excerpt */}
            <p className=" ">
              Everything I Know About Style Guides, Design Systems, and
              Component Libraries
            </p>
          </div>
          {/* Author image with data */}
          <div className="">
            <span>
              <img
                src="/author.jpg"
                className=" "
              />
            </span>
            <p className="">
              16 Nov, 2021
            </p>
          </div>
        </div>
      </div>
    </div>
  );
};

export default BlogPostCard; As you can see I have left spaces for the image URL, you can keep the assets in the public folder and you can access them using . Now the basic HTML structure is ready and it's time to add tailwind CSS classes. So, here I am pasting all the CSS code at once, please take some time to make sense of it. /image.jpg const BlogPostCard = () => {
  return (
    <div className="relative flex w-1/4 h-[500px] mx-auto mt-10">
      {/* Gradient background of same width & height  as Blog post card  */}
      <div className=" rounded-xl w-full bg-gradient-to-r p-[5px] from-[#7928ca] to-[#ff0080]">
        <div className="flex flex-col justify-between h-full bg-black rounded-lg p-4">
          <div className="flex flex-col justify-center text-white">
            {/* PostImage */}

            <img src="/postImage.png" className="h-52 mb-5 rounded-lg" />
            {/* Post title */}

            <h1 className="text-3xl font-extrabold mb-4">
              This is first title.
            </h1>
            {/* Post Data/excerpt */}
            <p className="text-lg md:text-lg font-medium mb-6  ">
              Everything I Know About Style Guides, Design Systems, and
              Component Libraries
            </p>
          </div>
          {/* Author image with data */}
          <div className=" flex w-full justify-between mb-4">
            <span>
              <img
                src="/author.jpg"
                className="w-[75px] h-[80px] rounded-full"
              />
            </span>
            <p className="text-lg mr-5 font-semibold text-white flex items-center justify-center">
              16 Nov, 2021
            </p>
          </div>
        </div>
      </div>
    </div>
  );
};

export default BlogPostCard; After all this, add the in the file  and the component in the . import the BlogPostCard from components/BlogPostCard.js index.js <BlogPostCard /> Home() function import Head from "next/head";
import BlogPostCard from "../components/BlogPostCard";

export default function Home() {
  return (
    <div className="bg-black flex flex-col min-h-screen py-2">
      <Head>
        <title>Blog PostCard Tutorial</title>
        <link rel="./favicon.ico" />
      </Head>
      <h1 className="text-8xl font-bold text-indigo-500 mb-10 text-center">Blog PostCard Tutorial</h1>
      <div>

      <BlogPostCard />
      </div>
    </div>
  );
} After all this hard work, you should see an output like this: The trick for creating a gradient border is that you create two , one nested in another and they should be relative to each other, then you give the two same height and width, such that the two DIV's should be stacked on each other. DIV's DIV's <div>
  <div>
  
  </div>
<div> Now you provide the gradient background to the bottom  DIV and provide some padding to the upper div. <div className="rounded-xl w-52 h-64 mx-auto  mt-10 bg-gradient-to-r p-[6px] from-[#6EE7B7] via-[#3B82F6] to-[#9333EA]">
   <div className="flex flex-col justify-between h-full bg-white text-white rounded-lg p-4">
      
     </div>
</div> Then you will see, that the bottom DIV will look like a gradient border for the upper DIV. I hope you enjoyed building this project, and thank you for investing your time in reading this blog. If you enjoyed reading the post or building the project , don't hesitate to show your love and do visit (My personal blog website to read articles/posts related to , Tailwind CSS , . NextjsDev.com Next.js React.js First Published here

Stories, News & Mentions about GRADIENTAI

Gradientai’s Stories on HackerNoon