Gradient AI

gradientai

Authors:
(1) Gonzalo J. Aniano Porcile, LinkedIn;
(2) Jack Gindi, LinkedIn;
(3) Shivansh Mundra, LinkedIn;
(4) James R. Verbus, LinkedIn;
(5) Hany Farid, LinkedIn and University of California, Berkeley. Table of Links Abstract and Intro
Data sets
Model
Results
Discussion, Acknowledgements, and References 4. Results Our baseline training and evaluation performance is shown in Table 2. The evaluation is broken down based on whether the evaluation images contain a face or not (training images contained only faces) and whether the images were generated with the same (in-engine) or different (out-of-engine) synthesis engines as those used in training (see Section 2.6). In order to provide a direct comparison of the true positive rate[8] (TPR) for the training and evaluation, we adjust the final classification threshold to yield a false positive rate[9] (FPR) of 0.5%. With a fixed FPR of 0.5%, AI-generated faces are correctly classified in training and evaluation at a rate of 98%. Across different synthesis engines (StyleGAN 1,2,3, Stable Diffusion 1,2, and DALL-E 2) used for training, TPR was varied somewhat from a low of 93.3% for Stable Diffusion 1 to a high of 99.5% for StyleGAN 2, and 98.9% for StyleGAN1, 99.9% for StyleGAN3, 94.9% for Stable Diffusion 2, and 99.2% for DALL-E 2. For faces generated by synthesis engines not used in training (out-of-engine), TPR drops to 84.5% at the same FPR, showing good but not perfect out-of-domain generalization. Across the different synthesis engines not used in training, TPR varied widely with a low of 19.4% for Midjourney to a high of 99.5% for EG3D, and 95.4% for generated.photos. Our classifier generalizes well in some cases, and fails in others. This limitation, however, can likely be mitigated by incorporating these out-of-engine images into the initial training. In a particularly striking result, non-faces – generated by the same synthesis engines as used in training – are all incorrectly classified. This is most likely because some of our real images contain non-faces (see Section 2.1) while all of the AI-generated images contain faces. Since we are only interested in detecting fake faces used to create an account, we don’t see this as a major limitation. This result also suggests that our classifier has latched onto a specific property of an AI-generated face and not some low-level artifact from the underlying synthesis (e.g., a noise fingerprint [8]). In Section 4.1, we provide additional evidence to support this hypothesis. The above baseline results are based on training and evaluating images at a resolution of 512×512 pixels. Shown in Figure 3(a) (solid blue) is the TPR when the training images are down scaled to a lower resolution (256, 128, 64, and 32) and then up scaled back up to 512 for classification. With the same FPR of 0.5%, TPR for classifying an AI-generated face drops fairly quickly from a baseline of 98.0%. The true positive rate, however, improves significantly when the model is trained on images at a resolution of N × N (N = 32, 64, 128, or 256) and then evaluated against the same TPR seen in training, Figure 3(a) (dashed red). As before, the false positive rate is fixed at 0.5%. Here we see that TPR at a resolution of 128 × 128 remains relatively high (91.9%) and only degrades at the lowest resolution of 32×32 (44.1%). The ability to detect AI-generated faces at even relatively low resolutions suggests that our model has not latched onto a low-level artifact that would not survive this level of down-sampling. Shown in Figure 3(b) is the TPR of the classifier, trained on uncompressed PNG and JPEG images of varying quality, evaluated against images across a range of JPEG qualities (ranging from the highest quality of 100 to the lowest quality of 20). Here we see that TPR for identifying an AIgenerated face (FPR is 0.5%) degrades slowly with a TPR of 94.3% at quality 80 and a TPR of 88.0% at a quality of 60. Again, the ability to detect AI-generated faces in the presence of JPEG compression artifacts suggests that our model has not latched onto a low-level artifact. 4.1. Explainability As shown in Section 4, our classifier is highly capable of distinguishing AI faces generated from a range of different synthesis engines. This classifier, however, is limited to only faces, Table 2. That is, when presented with non-face images from the same synthesis engines as used in training, the classifier completely fails to classify them as AI-generated. We posit that our classifier may have learned a semanticlevel artifact. This claim is partly supported by the fact that our classifier remains highly accurate even at resolutions as low as 128×128 pixels, Figure 3(a), and remains reasonably accurate even in the face of fairly aggressive JPEG compression, Figure 3(b). Here we provide further evidence to support this claim that we have learned a structural- or semantic-level artifact. It is well established that while general-purpose object recognition in the human visual system is highly robust to object orientation, pose, and perspective distortion, face recognition and processing are less robust to even a simple inversion [27]. This effect is delightfully illustrated in the classic Margaret Thatcher illusion [31]. The faces in the top row of Figure 4 are inverted versions of those in the bottom row. In the version on the right, the eyes and mouth are inverted relative to the face. This grotesque feature cocktail is obvious in the upright face but not in the inverted face. We wondered if our classifier would struggle to classify vertically inverted faces. The same 10,000 validation images (Section 2.6) were inverted and re-classified. With the same fixed FPR of 0.5%, TPR dropped by 20 percentage points from 98.0% to 77.7%. By comparison, flipping the validation images about just the vertical axis (i.e., left-right flip) yields no change in the TPR of 98.0% with the same 0.5% FPR. This pair of results, combined with the robustness to resolution and compression quality, suggest that our model has not latched onto a low-level artifact, and may have instead discovered a structural or semantic property that distinguishes AI-generated faces from real faces. We further explore the nature of our classifier using the method of integrated gradients [28]. This method attributes the predictions made by a deep network to its input features. Because this method can be applied without any changes to the trained model, it allows us to compute the relevance of each input image pixel with respect to the model’s decision. Shown in Figure 5(a) is the unsigned magnitude of the normalized (into the range [0, 1]) integrated gradients averaged over 100 StyleGAN 2 images (because the StyleGANgenerated faces are all aligned, the averaged gradient is consistent with facial features across all images). Shown in Figure 5(b)-(e) are representative images and their normalized integrated gradients for an image generated by DALL-2, Midjourney, Stable Diffusion 1, and Stable Diffusion 2. In all cases, we see that the most relevant pixels, corresponding to larger gradients, are primarily focused around the facial region and other areas of skin. 4.2. Comparison Because it focused specifically on detecting GANgenerated faces, the work of [23] is most directly related to ours. In this work, the authors show that a low-dimensional linear model captures the common facial alignment of StyleGAN-generated faces. Evaluated against 3,000 StyleGAN faces, their model correctly classifies 99.5% of the GAN faces with 1% of real faces incorrectly classified as AI. By comparison, we achieve a similar TPR, but with a lower 0.5% FPR. Unlike our approach, however, which generalizes to other GAN faces like generated.photos, TPR for this earlier work drops to 86.0% (with the same 1% FPR). Furthermore, this earlier work fails to detect diffusion-based faces because these faces simply do not contain the same alignment artifact as StyleGAN faces. By comparison, our technique generalizes across GAN- and diffusion-generated faces and to synthesis engines not seen in training. We also evaluated a recent state-of-the-art model that exploits the presence of Fourier artifacts in AI-generated images [8]. On our evaluation dataset of real and in-engine AIgenerated faces this model correctly classifies only 23.8% of the AI-generated faces at the same FPR of 0.5%. This TPR is considerably lower than our model’s TPR of 98.0% and also lower than 90% TPR reported in [8]. We hypothesize that this discrepancy is due to the more diverse and challenging in-the-wild real images of our dataset. This paper is available on arxiv under CC 4.0 license. [8] True positive rate (TPR) is the fraction of AI-generated photos that are correctly classified. [9] False positive rate (FPR) is the fraction of real photos that are incorrectly classified. Authors: (1) Gonzalo J. Aniano Porcile, LinkedIn; (2) Jack Gindi, LinkedIn; (3) Shivansh Mundra, LinkedIn; (4) James R. Verbus, LinkedIn; (5) Hany Farid, LinkedIn and University of California, Berkeley. Authors: Authors: (1) Gonzalo J. Aniano Porcile, LinkedIn; (2) Jack Gindi, LinkedIn; (3) Shivansh Mundra, LinkedIn; (4) James R. Verbus, LinkedIn; (5) Hany Farid, LinkedIn and University of California, Berkeley. Table of Links Abstract and Intro Data sets Model Results Discussion, Acknowledgements, and References Abstract and Intro Abstract and Intro Data sets Data sets Model Model Results Results Discussion, Acknowledgements, and References Discussion, Acknowledgements, and References 4. Results Our baseline training and evaluation performance is shown in Table 2. The evaluation is broken down based on whether the evaluation images contain a face or not (training images contained only faces) and whether the images were generated with the same (in-engine) or different (out-of-engine) synthesis engines as those used in training (see Section 2.6). In order to provide a direct comparison of the true positive rate[8] (TPR) for the training and evaluation, we adjust the final classification threshold to yield a false positive rate[9] (FPR) of 0.5%. With a fixed FPR of 0.5%, AI-generated faces are correctly classified in training and evaluation at a rate of 98%. Across different synthesis engines (StyleGAN 1,2,3, Stable Diffusion 1,2, and DALL-E 2) used for training, TPR was varied somewhat from a low of 93.3% for Stable Diffusion 1 to a high of 99.5% for StyleGAN 2, and 98.9% for StyleGAN1, 99.9% for StyleGAN3, 94.9% for Stable Diffusion 2, and 99.2% for DALL-E 2. For faces generated by synthesis engines not used in training (out-of-engine), TPR drops to 84.5% at the same FPR, showing good but not perfect out-of-domain generalization. Across the different synthesis engines not used in training, TPR varied widely with a low of 19.4% for Midjourney to a high of 99.5% for EG3D, and 95.4% for generated.photos. Our classifier generalizes well in some cases, and fails in others. This limitation, however, can likely be mitigated by incorporating these out-of-engine images into the initial training. In a particularly striking result, non-faces – generated by the same synthesis engines as used in training – are all incorrectly classified. This is most likely because some of our real images contain non-faces (see Section 2.1) while all of the AI-generated images contain faces. Since we are only interested in detecting fake faces used to create an account, we don’t see this as a major limitation. This result also suggests that our classifier has latched onto a specific property of an AI-generated face and not some low-level artifact from the underlying synthesis (e.g., a noise fingerprint [8]). In Section 4.1, we provide additional evidence to support this hypothesis. The above baseline results are based on training and evaluating images at a resolution of 512×512 pixels. Shown in Figure 3(a) (solid blue) is the TPR when the training images are down scaled to a lower resolution (256, 128, 64, and 32) and then up scaled back up to 512 for classification. With the same FPR of 0.5%, TPR for classifying an AI-generated face drops fairly quickly from a baseline of 98.0%. The true positive rate, however, improves significantly when the model is trained on images at a resolution of N × N (N = 32, 64, 128, or 256) and then evaluated against the same TPR seen in training, Figure 3(a) (dashed red). As before, the false positive rate is fixed at 0.5%. Here we see that TPR at a resolution of 128 × 128 remains relatively high (91.9%) and only degrades at the lowest resolution of 32×32 (44.1%). The ability to detect AI-generated faces at even relatively low resolutions suggests that our model has not latched onto a low-level artifact that would not survive this level of down-sampling. Shown in Figure 3(b) is the TPR of the classifier, trained on uncompressed PNG and JPEG images of varying quality, evaluated against images across a range of JPEG qualities (ranging from the highest quality of 100 to the lowest quality of 20). Here we see that TPR for identifying an AIgenerated face (FPR is 0.5%) degrades slowly with a TPR of 94.3% at quality 80 and a TPR of 88.0% at a quality of 60. Again, the ability to detect AI-generated faces in the presence of JPEG compression artifacts suggests that our model has not latched onto a low-level artifact. 4.1. Explainability As shown in Section 4, our classifier is highly capable of distinguishing AI faces generated from a range of different synthesis engines. This classifier, however, is limited to only faces, Table 2. That is, when presented with non-face images from the same synthesis engines as used in training, the classifier completely fails to classify them as AI-generated. We posit that our classifier may have learned a semanticlevel artifact. This claim is partly supported by the fact that our classifier remains highly accurate even at resolutions as low as 128×128 pixels, Figure 3(a), and remains reasonably accurate even in the face of fairly aggressive JPEG compression, Figure 3(b). Here we provide further evidence to support this claim that we have learned a structural- or semantic-level artifact. It is well established that while general-purpose object recognition in the human visual system is highly robust to object orientation, pose, and perspective distortion, face recognition and processing are less robust to even a simple inversion [27]. This effect is delightfully illustrated in the classic Margaret Thatcher illusion [31]. The faces in the top row of Figure 4 are inverted versions of those in the bottom row. In the version on the right, the eyes and mouth are inverted relative to the face. This grotesque feature cocktail is obvious in the upright face but not in the inverted face. We wondered if our classifier would struggle to classify vertically inverted faces. The same 10,000 validation images (Section 2.6) were inverted and re-classified. With the same fixed FPR of 0.5%, TPR dropped by 20 percentage points from 98.0% to 77.7%. By comparison, flipping the validation images about just the vertical axis (i.e., left-right flip) yields no change in the TPR of 98.0% with the same 0.5% FPR. This pair of results, combined with the robustness to resolution and compression quality, suggest that our model has not latched onto a low-level artifact, and may have instead discovered a structural or semantic property that distinguishes AI-generated faces from real faces. We further explore the nature of our classifier using the method of integrated gradients [28]. This method attributes the predictions made by a deep network to its input features. Because this method can be applied without any changes to the trained model, it allows us to compute the relevance of each input image pixel with respect to the model’s decision. Shown in Figure 5(a) is the unsigned magnitude of the normalized (into the range [0, 1]) integrated gradients averaged over 100 StyleGAN 2 images (because the StyleGANgenerated faces are all aligned, the averaged gradient is consistent with facial features across all images). Shown in Figure 5(b)-(e) are representative images and their normalized integrated gradients for an image generated by DALL-2, Midjourney, Stable Diffusion 1, and Stable Diffusion 2. In all cases, we see that the most relevant pixels, corresponding to larger gradients, are primarily focused around the facial region and other areas of skin. 4.2. Comparison Because it focused specifically on detecting GANgenerated faces, the work of [23] is most directly related to ours. In this work, the authors show that a low-dimensional linear model captures the common facial alignment of StyleGAN-generated faces. Evaluated against 3,000 StyleGAN faces, their model correctly classifies 99.5% of the GAN faces with 1% of real faces incorrectly classified as AI. By comparison, we achieve a similar TPR, but with a lower 0.5% FPR. Unlike our approach, however, which generalizes to other GAN faces like generated.photos, TPR for this earlier work drops to 86.0% (with the same 1% FPR). Furthermore, this earlier work fails to detect diffusion-based faces because these faces simply do not contain the same alignment artifact as StyleGAN faces. By comparison, our technique generalizes across GAN- and diffusion-generated faces and to synthesis engines not seen in training. We also evaluated a recent state-of-the-art model that exploits the presence of Fourier artifacts in AI-generated images [8]. On our evaluation dataset of real and in-engine AIgenerated faces this model correctly classifies only 23.8% of the AI-generated faces at the same FPR of 0.5%. This TPR is considerably lower than our model’s TPR of 98.0% and also lower than 90% TPR reported in [8]. We hypothesize that this discrepancy is due to the more diverse and challenging in-the-wild real images of our dataset. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv [8] True positive rate (TPR) is the fraction of AI-generated photos that are correctly classified. [9] False positive rate (FPR) is the fraction of real photos that are incorrectly classified.

Finding AI-Generated Faces in the Wild: Results

বন্য এ এআই-উত্পন্ন মুখগুলি সন্ধান করা: ফলাফল

KI-generierte Gesichter in freier Wildbahn finden: Ergebnisse

Encontrar rostros generados por IA en la naturaleza: resultados

Trouver des visages générés par l'IA dans la nature : résultats

जंगल में एआई-जनरेटेड चेहरे खोजना: परिणाम

AI が生成した顔の実例の発見: 結果

야생에서 AI가 생성한 얼굴 찾기: 결과

Encontrando rostos gerados por IA na natureza: resultados

Поиск лиц, созданных искусственным интеллектом, в дикой природе: результаты

Vahşi Doğada Yapay Zekanın Oluşturduğu Yüzleri Bulma: Sonuçlar

Tìm kiếm khuôn mặt do AI tạo ra trong tự nhiên: Kết quả

在野外寻找人工智能生成的面孔：结果

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

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


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


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

Extending Stochastic Gradient Optimization with ADAM

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

Exploring the Gradient of a Scalar in Dark Matter Velocity Analysis

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

Stories, News & Mentions about GRADIENTAI

Gradientai’s Stories on HackerNoon