<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Rishabh Anand on Medium]]></title>
        <description><![CDATA[Stories by Rishabh Anand on Medium]]></description>
        <link>https://medium.com/@mail.rishabh.anand?source=rss-50c04ecf0ec5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Rt1ADJ-lHIKAyQK0aBdaMw.jpeg</url>
            <title>Stories by Rishabh Anand on Medium</title>
            <link>https://medium.com/@mail.rishabh.anand?source=rss-50c04ecf0ec5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 18:47:48 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mail.rishabh.anand/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[An Illustrated Guide to Graph Neural Networks]]></title>
            <link>https://medium.com/dair-ai/an-illustrated-guide-to-graph-neural-networks-d5564a551783?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/d5564a551783</guid>
            <category><![CDATA[graph-neural-networks]]></category>
            <category><![CDATA[graph-deep-learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[science]]></category>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Mon, 30 Mar 2020 10:46:31 GMT</pubDate>
            <atom:updated>2020-03-30T10:46:31.780Z</atom:updated>
            <content:encoded><![CDATA[<h4>A breakdown of the inner workings of GNNs…</h4><p><strong><em>TLDR;</em></strong><em> Here, I cover the basic intuitions and mechanisms of Graph Neural Networks. Using colourful diagrams, I try to condense the essential steps needed to learn over structured graph data.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/888/1*vKOYk9FQrC6JXfBzyWaYKA.png" /><figcaption><strong>Nickelback</strong> approves of Graph Deep Learning 😎</figcaption></figure><p><em>Graph Deep Learning (GDL) </em>is an up-and-coming area of study. It’s super useful when learning over and analysing graph data. Here, I’ll cover the basics of a simple <em>Graph Neural Network</em> (GNN) and the intuition behind its inner workings. Don’t worry, there are tons of colourful diagrams for you to visualise what’s happening!</p><h4>❓ Graph, who?</h4><p>A graph is a data structure comprising of nodes (vertices) and edges connected together to represent information with no definite beginning or end. All the nodes occupy an arbitrary position in space, usually clustered according to similar features when plotted in <em>2D </em>(or even <em>nD</em>) space.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/1*MnES0hKfXEcNlhusqaftAA.png" /><figcaption>This is a graph: a bunch of interconnected nodes that represent entities.</figcaption></figure><p>The black arrows on the edges represent the kind of relationship between the nodes. It shows whether a relationship is mutual or one-sided. The two different kinds of graphs are <strong><em>directed</em></strong> (connection direction matters between nodes) and <strong><em>undirected</em></strong> (connection order doesn’t matter). Directed graphs can be unidirectional or bidirectional in nature.</p><p>A graph can represent many things — social media networks, molecules, etc. Nodes can be thought of as users/products/atoms while the edges represent connections (following/usually-purchased-with/bonds). A social media graph may look like this with nodes as users and edges as connections:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/0*S6sohp4yKv3-G2FF.png" /><figcaption>Nodes represent users while edges represent the connection/relationship between two entities. Social media graphs are usually a whole lot more enormous and complex!</figcaption></figure><h4>📑 What you need to know</h4><p>Here, I’ll be mentioning some concepts right off the bat. I’ll be talking about <em>recurrent units</em>, <em>embedding vector representations</em>, and <em>feed-forward neural networks</em>. It’s nice to know a fair bit of graph theory (as in, what a graph is and what it looks like) as well.</p><p>There may be terms you are unfamiliar with. Fret not! For all the confusing jargon, I’ve linked the best explanation I can find covering the basics of the said concept. That way, you can read further into the concepts while also understanding the role they play in Graph Neural Networks.</p><h4><strong>🚪 Enter Graph Neural Networks</strong></h4><p>Each node has a set of features defining it. In the case of social network graphs, this could be age, gender, country of residence, political leaning, and so on. Each edge may connect nodes together that have similar features. It shows some kind of interaction or relationship between them.</p><p>Suppose we have an arbitrary graph <strong><em>G</em></strong> with the following vertices and edges:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/1*YUHvwJvfTLWyqiqCYw2ToA.png" /><figcaption>It’s the same graph from above.</figcaption></figure><p>For simplicity’s sake, let’s assume that the feature vector is a one-hot-encoding of the current node’s index. Likewise, the label (or class) could be the colour of the node (green, red, and yellow as shown above). It’d look something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*Ru3CizrB14hvpZQ7ZtgIag.png" /><figcaption>The order they are in doesn’t really matter.</figcaption></figure><p><strong><em>Note:</em></strong><em> In reality, try not to use one-hot-encodings because the order of the nodes may be messy. Rather, use features that uniquely identify the node (</em><strong><em>eg:</em></strong><em> age, gender, political leaning, etc. for Social Media or numerical chemical properties for molecular studies).</em></p><p>Now that we have our one-hot-encodings (or embeddings) of the nodes, let’s alter the graph by bringing in neural networks into the mix. All the nodes are converted into recurrent units (or <em>any</em> neural network architecture, actually; I’m using recurrent units here) and all the edges house simple feed-forward neural networks. It looks something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*YUkgTeyGVzc5d8CuvcBeqA.png" /><figcaption>The envelopes are simply the one-hot-encoded (embedding) vectors for each node (recurrent unit, now).</figcaption></figure><h4>📮 Message Passing</h4><p>Once the conversion of nodes and edges are completed, the graph performs Message Passing between the nodes. This process is also called <a href="https://youtu.be/NbxSzyTnLTQ?t=1106">Neighbourhood Aggregation</a> because it involves pushing messages (aka, the embeddings) from surrounding nodes around a given reference node, through the directed edges.</p><p><strong><em>Note:</em></strong><em> Sometimes, you can use a different neural network for different types of edges; one for unidirectional and another for bidirectional. That way, you can still capture the spatial relationships between nodes.</em></p><p>In terms of GNNs, for a single reference node, the neighbouring nodes pass their messages (embeddings) through the edge neural networks into the recurrent unit on the reference node. The new embedding of the reference recurrent unit is updated by applying said recurrent function on the current embedding and a summation of the edge neural network outputs of the neighbouring node embeddings. Let’s zoom into the top red node and visualise the process:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*ax6_pw2sXNa7fWjHiRT95Q.png" /><figcaption>The violet square is a simple feed-forward NN applied on the embeddings (white envelopes) from the neighbouring nodes. The recurrent function (red triangle) applied to the current embedding (white envelope) and summation of edge neural network outputs (black envelopes) to obtain the new embedding (white envelope prime).</figcaption></figure><p>This process is performed, in parallel, on all nodes in the network as embeddings in layer <strong><em>L+1</em></strong> depend on embeddings in layer <strong><em>L</em></strong>. Which is why, in practice, we don’t need to ‘move’ from one node to another to carry out Message Passing.</p><p><strong><em>Note:</em></strong><em> The sum over the edge neural network outputs (black envelopes in the diagram) is invariant of the order of the outputs.</em></p><h4>🤔 What do I do with the final vector representations?</h4><p>Once you perform the Neighbourhood Aggregation/Message Passing procedure a few times, you obtain a completely new set of embeddings for each nodal recurrent unit.</p><p>Through the timesteps/rounds of Message Passing, the nodes know more about their <em>own</em> information (features) and that of neighbouring nodes. This creates an even more accurate representation of the entire graph.</p><p>For further processing in higher layers of a pipeline, or simply to represent the graph, you can take all the embeddings and sum them up together to get vector <strong><em>H</em></strong> that represents the whole graph.</p><p>Using <strong><em>H </em></strong>is better than using an <a href="https://www.khanacademy.org/computing/computer-science/algorithms/graph-representation/a/representing-graphs">adjacency matrix</a> because these matrices don’t represent the features or unique aspects of the graph despite any graph contortion — simply the edge connections between nodes (which isn’t really important based on some contexts).</p><p>To summarise this step, we sum together the final vector representations of all nodal recurrent units (order-invariant, of course) use this resulting vector as inputs to other pipelines or to simply represent the graph. This step looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*Rz0VPVDtmrdYFWwxy14ZCQ.png" /><figcaption>Here’s the final graph with the fully updated node embedding vectors after <strong>n</strong> repetitions of Message Passing. You can take the representations of all the nodes and sum them together to get <strong>H</strong>.</figcaption></figure><h4>📝 Graph Neural Networks, a summary</h4><p>GNNs are fairly simple to use. In fact, implementing them involved four steps.</p><ol><li>Given a graph, we first convert the nodes to recurrent units and the edges to feed-forward neural networks.</li><li>Then we perform Neighbourhood Aggregation (Message Passing, if that sounds better) for all nodes <strong><em>n</em></strong> number of times.</li><li>Then we sum over the embedding vectors of all nodes to get graph representation <strong><em>H</em></strong>.</li><li>Feel free to pass <strong><em>H</em></strong> into higher layers or use it to represent the graph’s unique properties!</li></ol><h4>🙇🏻‍♂️ Why Graph Neural Networks?</h4><p>Now that we know how Graph Neural Networks work, why would we want to apply/use them?</p><p>In the case of social media graphs, GNNs are great at content recommendation. When a user follows other users with a similar taste in political leaning (for example), GNNs can be used for node classification to predict if a certain piece of content on the site can be sent to the news feed of said user.</p><p>When suggesting “who to follow”, systems can take into account the industry of the user and provide potential connections — edge classification.</p><h4>🔩 In a nutshell</h4><p>Here, we covered the basics of Graph Neural Networks with a bunch of visualisations. Graph DL is really interesting and I urge you to try coding up your own implementation of it. There are tons of graph construction libraries like the <a href="https://www.dgl.ai/"><em>Deep Graph Library</em></a> or <a href="https://github.com/rusty1s/pytorch_geometric"><em>PyTorch Geometric</em></a>.</p><p>If you are interested in having a <em>mathematical breakdown</em> of Graph NNs with <em>code snippets</em> explaining the concepts in this article, drop the suggestions in the comment section or shoot me a message (profiles listed below).</p><p>There are also great resources to learn about GDL algorithms and different ways to capture lots of sequential and spatial aspects from graph representations. Do explore beyond this article and implement it using your tools of choice.</p><p>Until then, I’ll see you in the next one!</p><p>Original article by <a href="https://medium.com/u/50c04ecf0ec5">Rishabh Anand</a></p><h4>❤️ Love talking tech?</h4><p>You’re in luck! I love talking about Artificial Intelligence, Data Science, and the progress of science and technology in general. If you want to chat, you can catch me procrastinating on <a href="https://twitter.com/rishabh16_">Twitter</a> and <a href="https://www.linkedin.com/in/rishabhanand16/">LinkedIn</a>.</p><h4>📞 A call to action…of sorts</h4><p>Your feedback and constant support mean a lot and encourage me to continue writing high-quality content for both your learning and mine! While you’re waiting for my reply (which is usually very quick 🙌🏻), do check out my other trending articles:</p><ul><li><a href="https://towardsdatascience.com/quantum-computing-with-colorful-diagrams-8f7861cfb6da">Crash Course in Quantum Computing Using Very Colorful Diagrams</a></li><li><a href="https://medium.com/analytics-vidhya/tpu-training-made-easy-with-colab-3b73b920878f">Training Your Models on Cloud TPUs on Google Colab in 4 Easy Steps</a></li><li><a href="https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0">A Comprehensive Guide to Genetic Algorithms (and how to code them)</a></li><li><a href="https://hackernoon.com/catgan-cat-face-generation-using-gans-f44663586d6b">CatGAN: cat face generation using GANs</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d5564a551783" width="1" height="1" alt=""><hr><p><a href="https://medium.com/dair-ai/an-illustrated-guide-to-graph-neural-networks-d5564a551783">An Illustrated Guide to Graph Neural Networks</a> was originally published in <a href="https://medium.com/dair-ai">DAIR.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Writing Fancy READMEs: A Guide]]></title>
            <link>https://medium.com/socollab/writing-fancy-readmes-a-guide-9778c3590050?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/9778c3590050</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Sun, 01 Dec 2019 20:43:08 GMT</pubDate>
            <atom:updated>2022-02-13T07:16:44.651Z</atom:updated>
            <content:encoded><![CDATA[<h4>Getting users to fall in love with your open-source project</h4><p>In this mini-article, I’ll be covering the basics of writing a decent README for all the open-source beginners out there. The process is fairly simple and requires effort on your part.</p><p>There are several components to a README that are necessary for ensuring your project has a positive outreach. I’ll be covering each component by likening it to the README I made for gpt2-client, a project I made that has over 13K downloads in less than 2 months.</p><p>READMEs are powerful. Very powerful. Knowing how to craft one might just make your project much more <em>likable</em>.</p><h4>The banner (aka, the flex piece)</h4><p>A minimal cover picture or logo can be used at the header. Here, I decided to use a code snippet with only 5 lines of code to show how easy it is to get started generating text with gpt2-client.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B3YPXViRkxg2BlQA4hv1mg.png" /><figcaption>I tried to make mine as fancy and inviting as possible. The key to success in open-source is selling the product well and bringing in new users frequently.</figcaption></figure><p>Badges (the colourful buttons at the top) are equally important. They show quality, trust, and competency. Use badges that matter: number of installs, version history, license, and if it’s a language-based project (in my case, Python), then add in a button for it’s specific online register (for me, PyPi).</p><p>Having an attractive banner goes a long way in showing users that this project is official and it serves a purpose that’s beneficial to them.</p><p><strong><em>Note:</em></strong><em> If you want a similar-looking code snippet banner, check out</em><strong><em> </em></strong><a href="https://carbon.now.sh/"><strong><em>Carbon</em></strong></a><em>.</em></p><h4>What is it?</h4><p>Here, you want your user to know what problem you’re solving and how exactly you are solving it. Keep it as simple as possible. Give some background on what has happened and motivated you to create your side-project. Ideally, keep it to 2–3 brief paragraphs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KYKu-AUw_HWiRuBZud1M9g.png" /><figcaption>Add any warnings if possible.</figcaption></figure><h4>Installation Instructions</h4><p>Users <em>do not</em> want to know a story when it comes to this section. Just give them that single line they should enter in their terminal/command prompt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M5yf-RUEHQweGz0o0Jz-NA.png" /><figcaption>You can add notes at the end if there are any specifications to meet before installation.</figcaption></figure><p>If your project is web-based, simply add a link that users can visit to download the final product.</p><h4>Getting Started</h4><p>Try breaking down your product into all the small features and write about them in point form. Each point corresponds to a different feature along with a small code snippet with coherent comments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aVlKVTZEcoDe65wy9MTrTA.png" /></figure><h4>Contribution Information and Licenses</h4><p>Here, you can ask the community to contribute to the project with new features, improved documentation, and sometimes, even donations. Again, you don’t need to spend too much time on these sections.</p><p>An important thing to note is choosing the right license. Read <a href="https://opensource.org/licenses">this</a> guide before choosing one for your next hack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CcRI2rBhXKAoELjNDBKKfw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UDmXlXvwFUBl-u8sPuoGVQ.png" /><figcaption>Choose your license wisely</figcaption></figure><h4>That’s about it</h4><p>Writing a good README shouldn’t be that difficult. Users are attracted to beauty and aesthetics. Hopefully, this article helps you in writing your winning README for your next open-source side-project.</p><p>Until then, I’ll see you in the next one.</p><p>Guide by <a href="https://medium.com/u/50c04ecf0ec5">Rishabh Anand</a></p><h4>Love talking tech?</h4><p>You’re in luck! If you want to chat about the cutting-edge, find me procrastinating on <a href="https://twitter.com/rishabh16_">Twitter</a> and <a href="https://www.linkedin.com/in/rishabhanand16/">LinkedIn</a>.</p><p>Check out my other articles on technology, Machine Learning, and reviews of up-and-coming software innovations:</p><ul><li><a href="https://towardsdatascience.com/quantum-computing-with-colorful-diagrams-8f7861cfb6da">Crash Course in Quantum Computing Using Very Colorful Diagrams</a></li><li><a href="https://medium.com/analytics-vidhya/tpu-training-made-easy-with-colab-3b73b920878f">Training Your Models on Cloud TPUs on Google Colab in 4 Easy Steps</a></li><li><a href="https://hackernoon.com/catgan-cat-face-generation-using-gans-f44663586d6b?source=post_page-----8f7861cfb6da----------------------">CatGAN: cat face generation using GANs</a></li><li><a href="https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0">A Comprehensive Guide to Genetic Algorithms (and how to code them)</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9778c3590050" width="1" height="1" alt=""><hr><p><a href="https://medium.com/socollab/writing-fancy-readmes-a-guide-9778c3590050">Writing Fancy READMEs: A Guide</a> was originally published in <a href="https://medium.com/socollab">SoCollab</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Training Your Models on Cloud TPUs on Google Colab in 4 Easy Steps]]></title>
            <link>https://medium.com/analytics-vidhya/tpu-training-made-easy-with-colab-3b73b920878f?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b73b920878f</guid>
            <category><![CDATA[tensorflow]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[tensor-processing-unit]]></category>
            <category><![CDATA[parallel-processing]]></category>
            <category><![CDATA[distributed-computing]]></category>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Mon, 22 Jul 2019 15:20:12 GMT</pubDate>
            <atom:updated>2019-09-05T04:00:20.676Z</atom:updated>
            <content:encoded><![CDATA[<h3>Training Your Models on Cloud TPUs in 4 Easy Steps on Google Colab</h3><h4>I trained an Neural Machine Translation(NMT) model on a TPU and now feel like a Wizard…</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2hZsom9OR2luUM1nGnOQQg.png" /></figure><p>You have a plain old TensorFlow model that’s too computationally expensive to train on your standard-issue work laptop. I get it. I’ve been there too, and if I’m being honest, seeing my laptop crash twice in a row after trying to train a model on it is painful to watch.</p><p>In this article, I’ll be breaking down the steps on how to train any model on a TPU in the cloud using Google Colab. After this, you’ll never want to touch your clunky CPU ever again, believe me.</p><p><strong><em>TL;DR:</em></strong><em> This article shows you how easy it is to train any TensorFlow model on a TPU with very few changes to your code.</em></p><h4>What’s a TPU?</h4><p>The Tensor Processing Unit (TPU) is an accelerator — custom-made by Google Brain hardware engineers — that specializes in training deep and computationally expensive ML models.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VJYpM4RHoJIO0ZoMR9zn1Q.png" /><figcaption>This is what a TPU looks like. It has 4 humongous heat sinks that sit on top of a board with some insanely advanced and powerful circuitry.</figcaption></figure><p>Let’s put things into perspective just to give you an idea of how awesome and powerful a TPU is. A standard MacBook Pro Intel CPU can perform a few operations per clock cycle. A standard off-the-shelf GPU can perform tens of thousands of operations per cycle. A state-of-the-art TPU can perform hundreds of thousands of operations per cycle (sometimes up to 128K OPS).</p><p>To understand the scale, imagine using these devices to print a book. A CPU can print character-by-character. A GPU can print a few words at a time. A TPU? Well, it can print a whole page at a time. That’s some amazing speed and power that we now have at our disposal; shoutout to Google for giving everyone access to high-performance hardware.</p><p><em>If you’re interested in the inner workings of a TPU and what makes it so amazing, go check out the Google Cloud blog article where they discuss everything from hardware to software </em><a href="https://cloud.google.com/blog/products/gcp/an-in-depth-look-at-googles-first-tensor-processing-unit-tpu"><em>here</em></a><em>. You can find information regarding mechanisms, hardware specs, benefits, limits, constraints, and much more to help you with your projects!</em></p><h4>Preprocessing MNIST</h4><p>For the sake of this tutorial, I’ll be running through a quick and easy MNIST model. Do note that this model can be whatever you want it to be. To better help you visualize what’s going on, I’ve chosen good old MNIST (again, a dataset of your choosing).</p><p>Let’s first begin by extracting and preprocessing our dataset. This shouldn’t be much of a problem:</p><pre>import tensorflow as tf<br>from tensorflow.keras.datasets import mnist<br>from tensorflow.keras.utils import to_categorical</pre><pre># This can be any dataset<br>(x_train, y_train), (x_test, y_test) = mnist.load_data()<br>x_train = x_train.reshape([x_train.shape[0], 784])<br>x_test = x_test.reshape([x_test.shape[0], 784])<br>x_train = x_train / 255<br>x_test = x_test / 255</pre><pre>y_train = to_categorical(y_train, 10)<br>y_test = to_categorical(y_test, 10)</pre><pre>print (x_train.shape, y_train.shape)<br>print (x_test.shape, y_test.shape)</pre><pre># &gt;&gt; (60000, 784), (60000, 10)<br># &gt;&gt; (10000, 784), (10000, 10)</pre><p>I’ve tried to make this tutorial as comprehensive as possible so that you can train your models at unfathomable speeds and feel like you’re on top of the world. There are 4 steps we will be taking to train our model on a TPU:</p><ol><li>Connect to an available TPU instance</li><li>Initialize a distributed training strategy</li><li>Build our model under the said strategy</li><li>Train the model and feel like a <em>Wizard</em></li></ol><p>Let’s dive right into it!</p><p><strong><em>Note: </em></strong><em>Feel free to preprocess your datasets using </em>tf.data<em> or convert them into </em>TFRecords <em>if that catches your fancy</em>. <em>These steps are not necessary but may be useful in handling out-of-memory instances in the case that you are working with very large datasets.</em></p><h4>Connecting to a TPU</h4><p>When I was messing around with TPUs on Colab, connecting to one was the most tedious. It took quite a few hours of searching online and looking through tutorials, but I was finally able to get it done.</p><p>We first need to connect our Colab notebook running locally to the TPU runtime. To change runtime, simply click the Runtime tab in the navigation bar. A dropdown menu will be displayed from which you can select the Change runtime type option. A popup window will show up where you can select the TPU option from the dropdown selector.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RX7jY-e5kML4UlQsKj4Xrg.png" /><figcaption>The popup window will look something like this. Switch the runtime from CPU to TPU.</figcaption></figure><p>To connect to a TPU instance, we need to create a TPUClusterResolver that takes in the available device and provisions one for us:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dd8887496cd456e6dc9139187b5c4cee/href">https://medium.com/media/dd8887496cd456e6dc9139187b5c4cee/href</a></iframe><p>This should connect our current Colab session to an available TPU instance. Let’s move on to initializing the strategy and finally invoking the TPU.</p><p><strong><em>Note:</em></strong><em> If you are experiencing difficulties in connecting to a TPU instance even after several attempts and re-runs, you can change the runtime type to</em> GPU <em>instead. The code still compiles and runs efficiently.</em></p><h4>Initializing a Distributed Training Strategy</h4><p>Now that we’ve changed the runtime and have acquired a list of available TPUs, we need to invoke the TPU by creating a distributed training strategy — a wrapper around the model that makes it compatible with multi-core training.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d9188fe39555fadcc3c09a4880e842d0/href">https://medium.com/media/d9188fe39555fadcc3c09a4880e842d0/href</a></iframe><p>The resolver gives us access to the TPU such that we can finally build a parallelly-distributed pipeline on it. This is a necessary step because a TPU is a distributed training processor and is not single-core like a traditional CPU. With this strategy method, jumping on board a TPU is very simple! It should give you a list of available instances:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/890/1*kDrZo5Za6od6nz78N5wHoA.png" /><figcaption>We have 8 devices at our disposal</figcaption></figure><h4>Building our model under the distributed training strategy</h4><p>With a training strategy now at hand, we can proceed to build our model using that strategy as such:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/824ec9b0789ab8be78c45bfac60516de/href">https://medium.com/media/824ec9b0789ab8be78c45bfac60516de/href</a></iframe><p>This looks like a lot of jargon, but all it does is take a regulartf.keras model (that is typically run on a CPU) and places it on the TPU and automatically distributes it across all the available TPU cores.</p><h4>Training our model</h4><p>This is the exciting part of the process. We can finally train our model on a Cloud TPU for free. With so much power in our hands, let’s make good use of it and train on MNIST (I know…very anti-climatic).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b74c748d2aba871f214e370b19ba5a25/href">https://medium.com/media/b74c748d2aba871f214e370b19ba5a25/href</a></iframe><p>Ensure that the number of instances is perfectly divisible by the steps_per_epoch parameter so that all the instances are used during<br>training. For example, we have 60000 instances in our training set. 60000 <br>is divisible by 50 so that means all our instances are fed into the model without any <em>leftovers</em>. If you hit run, it should start training on a TPU instance after a short while:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pWA1XiQMdZzs2mx6OUjuOw.png" /><figcaption>Here’s the TPU training cycle for the Neural Machine Translation model I built on Colab.</figcaption></figure><h4>A final round-up</h4><p>With that, training should commence soon. Colab will boot up a TPU and upload the model architecture on it. You should soon see the classic Keras progress bar style layout in the terminal output. Congrats! You’ve successfully just used a TPU.</p><p>Retrospectively, I always thought training models on TPUs were a thing only ML Wizards — those with years of experience and skill — could handle. TPU training was always that one huge thing out of my grasp simply because of the hype around it (making it seem very difficult to use). Never in my wildest dreams did I think it’d be as simple as adding less than 10 lines of code to my preexisting models.</p><p>After reading this article, I want you to know that anyone can train on accelerated hardware regardless of experience. This is just one of many steps undertaken by Google AI to democratize Machine Learning and Artificial Intelligence amongst the masses.</p><h4>Some observations about TPU training</h4><p>The Neural Machine Translation model I had written (for the TensorFlow Docs) took me less than a minute to train on a TPU. I was astonished because the same model took more than 4 hours to train on a CPU (which probably explains why my laptop crashed and ran out of memory twice).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*0BuX1_tYwUZEqzBp72Uq4Q.png" /><figcaption>My NMT model trained superbly on a TPU! The metrics show that the training was smooth and I didn’t encounter any speedbumps along the way.</figcaption></figure><p>My model hit a very high accuracy — higher than what I achieved training on a CPU. With performance and speed, the Cloud TPU is second to none when it comes to quality training!</p><p><strong><em>Note: </em></strong><em>You can find my code </em><a href="https://colab.research.google.com/drive/1o0nSHlhW2i6mrbeU-lUajw8fpSo1dbMr"><em>here</em></a><em>. Have fun!</em></p><h4>In a nutshell</h4><p>Google always comes bearing gifts when it launches new Machine Learning toys that we can tinker and play around with. The TPU processor is certainly a boon to the ML community as it plays a major role in the democratization of AI — it gives everyone a chance to use accelerated hardware regardless of demographic. With TPUs, research and experimentation are hitting all-time highs and people are now engaging in Machine Learning like never before!</p><p>I hope this article has helped you train your models in a much more efficient and elegant manner. If you have any questions about the use of TPUs or want to chat in general about Tech and ML, feel free drop them down below in the comments or catch me on <a href="https://twitter.com/rishabh16_">Twitter</a> or <a href="https://www.linkedin.com/in/rishabhanand16/">LinkedIn</a>. I usually reply within a day.</p><p>Until then, I’ll catch you in the next one!</p><p>Article by <a href="https://medium.com/u/50c04ecf0ec5">Rishabh Anand</a></p><h4>A call to action…of sorts</h4><p>Interested in reading about the latest-and-greatest technologies and getting your hands dirty with the recent happenings in Machine Learning, Data Science, and Technology? Do catch my other articles or give me a follow! Your feedback and constant support mean a lot and encourage me to continue writing high-quality content for your learning!</p><ul><li><a href="https://towardsdatascience.com/quantum-computing-with-colorful-diagrams-8f7861cfb6da">Crash Course in Quantum Computing Using Very Colorful Diagrams</a></li><li><a href="https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0">A Comprehensive Guide to Genetic Algorithms (and how to code them)</a></li><li><a href="https://hackernoon.com/catgan-cat-face-generation-using-gans-f44663586d6b?source=---------8------------------">CatGAN: cat face generation using GANs - By</a></li><li><a href="https://towardsdatascience.com/making-a-replier-and-follow-bot-for-twitter-using-node-js-23e0ba8e4e4f">Making a Replier and Follow Bot for Twitter using Node.js</a></li><li><a href="https://hackernoon.com/introducing-tensorflow-js-3f31d70f5904?source=---------9------------------">Introducing TensorFlow.js 🎉 - By</a></li><li><a href="https://towardsdatascience.com/tensorflow-or-tensorno-c9c6c6c2f992">TensorFlow or TensorNo?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b73b920878f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/analytics-vidhya/tpu-training-made-easy-with-colab-3b73b920878f">Training Your Models on Cloud TPUs on Google Colab in 4 Easy Steps</a> was originally published in <a href="https://medium.com/analytics-vidhya">Analytics Vidhya</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Your Own Quantum Circuits in Python]]></title>
            <link>https://medium.com/data-science/building-your-own-quantum-circuits-in-python-e9031b548fa7?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/e9031b548fa7</guid>
            <category><![CDATA[quantum-computing]]></category>
            <category><![CDATA[qiskit]]></category>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Tue, 14 May 2019 13:34:34 GMT</pubDate>
            <atom:updated>2019-05-15T01:42:16.000Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building Your Own Quantum Circuits in Python (With Colorful Diagrams)</h3><h4>An intuitive guide filled with code and colorful diagrams…</h4><p><em>For a crash course on Quantum Computing, do check out the previous </em><a href="https://towardsdatascience.com/quantum-computing-with-colorful-diagrams-8f7861cfb6da"><em>article</em></a><em>.</em></p><p><strong><em>TLDR: </em></strong><em>Here, I talk about </em><strong><em>Qiskit</em></strong><em>, an open-source Python module for building quantum circuits and simulating operations on Qubits. We’ll look through sample code and then move on to an in-depth explanation of what the code does with very intuitive, colorful diagrams!</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/994/1*lD7ZfSJV4Q7NOCvPWrRpyA.png" /></figure><p>In my previous article, I mentioned that models can be built to simulate processes of interest in the universe. In order to build these models, we make use of quantum circuits, for which we need a module to manipulate and run quantum programs on quantum devices.</p><p>In this article, we’ll look at <a href="https://qiskit.org/">Qiskit</a> — a Python module that makes quantum prototyping a stress-free task owing to its simple and easily-readable syntax. Qiskit was developed by IBM Research to make it easier for anyone to interface with a Quantum Computer.</p><h4>A fresher on Quantum Circuit construction</h4><p>In my previous article, I spoke about the Hadamard, Controlled-NOT and the Pauli-X Gates. The Hadamard Gate takes in a single Qubit and outputs a bit with an equal probability of becoming a 1 or 0.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/905/1*szTbDNy8UBXfVdDCIfjneA.png" /><figcaption>The Hadamard Gate computes a Qubit with an equal probability of becoming a 1 or 0 when measured.</figcaption></figure><p>The Controlled-NOT (CNOT) Gate takes in 2 Qubits and flips a Qubit from one state of <em>ket 0</em> to <em>ket 1</em> only if the control Qubit is <em>ket 1</em>. Otherwise, it leaves it unchanged.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-J_A0O0XDK1R0yCjuYW_9w.png" /><figcaption>The CNOT Gate flips a Qubit only if the control Qubit is <strong><em>ket 1</em></strong></figcaption></figure><p>Now that we have recapped what the gates do, we can finally go on to defining our own circuit and simulating it to get the final state of the Qubits and bits!</p><p><strong><em>Note: </em></strong><em>the Pauli X and Y Gates are not covered in this tutorial.</em></p><h4>Building our own Quantum Circuits</h4><p>Building your own Quantum Circuits is easy because of Qiskit’s great documentation and resources. Before moving on to something complex, let’s run through the basics of building a circuit from scratch. Here, we’ll decompose the circuit code into digestible parts. Let’s begin!</p><p>Before writing Quantum Circuits, we need to install Qiskit. To do so, you can simply install the package via <strong><em>pip</em></strong>:</p><pre><strong>$</strong> pip install qiskit</pre><p>To test out your installation, open up the Python console and type in import qiskit as qk. If it runs without any errors, you’re good to go!</p><p><strong><em>Note:</em></strong><em> If you run into any problems, the Qiskit GitHub </em><a href="https://github.com/Qiskit/qiskit/issues"><em>Issues</em></a><em> page has the solutions to most beginner problems. However, if you still have any burning questions, feel free to drop a comment down below or contact me via </em><a href="https://twitter.com/rishabh16_"><em>Twitter</em></a><em> or </em><a href="https://www.linkedin.com/in/rishabhanand16/"><em>LinkedIn</em></a><em>.</em></p><p>Now that we have Qiskit configured, let’s work some Qubits and Bits. To instantiate Qubits and Bits in Qiskit, we can use the QuantumRegister and ClassicalRegister objects to create them. Here, we create 2 of each type:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f04eb310663d89d0957157e5bcba15e/href">https://medium.com/media/1f04eb310663d89d0957157e5bcba15e/href</a></iframe><p>The registers hold a record of the Qubits and Bits that are being used by our circuit. Having the Qubits and Bits in our hands, let’s construct our circuit:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ecd3f741223901ed66b85be66d84a069/href">https://medium.com/media/ecd3f741223901ed66b85be66d84a069/href</a></iframe><p>Let’s add some gates into our circuit to manipulate and work with our Qubits and Bits and finally measure the final Qubits:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/00ff9de458a31b87d9191e01845d3f98/href">https://medium.com/media/00ff9de458a31b87d9191e01845d3f98/href</a></iframe><p>Let’s visualize our circuit so we have a rough idea of the transformations applied to our Qubits:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2f53237f7b804c03f7f721f9a4920464/href">https://medium.com/media/2f53237f7b804c03f7f721f9a4920464/href</a></iframe><p>If we print this circuit to console, we can see a circuit diagram printed for convenience purposes (Thanks IBM!). It should look something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*czU5fry9WQb41gCYjXThPw.png" /><figcaption>The terminal output should look something like the diagram on the left. The image on the right is a visualization of how the circuit is supposed to be constructed.</figcaption></figure><p>Congrats! You have just built a Quantum Circuit. Now that we have that in place, let’s simulate the circuit and run it using a simulator. Qiskit provides components that have various simulator backends that manipulate the Qubits in different ways. The components are Aer, Ignis, Terra, and Aqua.</p><p>To simulate the circuit, let’s use Aer’s QasmSimulator that aims to mimic a real Quantum Device. To use Aer’s simulator, we can simply create a simulation job and collect the results at the end. The Qasm Simulator runs the circuit for 1024 times (by default).</p><p>‘Qasm Simulator’ sounds like something out of a video game. Don’t worry if it sounds intimidating. All it does is create a classical simulation on your local machine to mimic what would happen in an actual quantum machine. Invariably, it is a <strong><em>pseudo-simulation</em></strong>, as the Qiskit documentation calls it.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7326d498f99f3a914a6f2e3698231a8e/href">https://medium.com/media/7326d498f99f3a914a6f2e3698231a8e/href</a></iframe><p>In the end, we can see that there is a 0.481 (492/1024) probability that the circuit outputs ‘00’ as the bitstring while there is a 0.519 (532/1024) probability that the output bitstring is ‘11’.</p><p>This way, by simulating our circuits, we can convert this bitstring into their decimal or hexadecimal counterparts and see the values they give out.</p><h4>Asking the real questions</h4><p>After doing all this, you may ask, what’s the point of all this? We have some idea on how to build circuits and what the individual components do. How do they go together? How do they all fit in? Those are valid questions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/466/1*qCOc_3dCQXuqFaL7Ax0azw.png" /></figure><p>Quantum Computing deals with probabilities ie. the chance of an event occurring. For this, we assume that the event is completely random. Quantum Circuits enable us to take Qubits, put them into superpositions, measure them and get the final outcome.</p><p>To illustrate one such application of complete randomness without bias, let’s build a random number generator! This way, we can see the power of Superposition and how the final result is a completely random number without any one-sidedness.</p><p>Additionally, instead of running it on a local simulation that is classical in nature (cannot reflect the sheer awesomeness of a quantum computer), let’s hook up our circuit and run it on the actual IBM Quantum Computers located nearest to you!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/618/1*ZaxtKI9JH3GI_yg2ubndKg.png" /><figcaption>A simplified diagram of the processes involved in building a quantum circuit, running it on a Quantum Computer and getting back the simulated results</figcaption></figure><p>Before we perform any Quantum magic, we need to connect to the IBM Quantum Computer nearest to your region. To do so, visit the IBM Q <a href="https://quantumexperience.ng.bluemix.net/qx/login">website</a> and login or create an account if you’re new.</p><p>When logged in, click the profile icon located at the top right-hand corner. Go to the <strong><em>My Account</em></strong> page and go to the <strong><em>Advanced</em></strong> tab. There, you’ll see an area for your API Token. If you don’t have one go ahead and generate one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/599/1*2WejfaeOoMrRPERoJB9Y3Q.png" /><figcaption>You should see a token inside. If not, click Regenerate to generate one. I’ve blocked mine for security reasons.</figcaption></figure><p>We can finally start writing a client-side circuit that interfaces with the IBM Q Machine closest to you, shown on the panel to the left.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nyHDY8im0jmCyjwrwNJCQA.png" /><figcaption>The available machines closest to where I am</figcaption></figure><p>For this tutorial, I’ll be using the <strong><em>ibmqx4</em></strong> system which can hold and manipulate a maximum of 4 Qubits. You might see other available machines on your dashboard depending on your location so don’t worry if you don’t see mine. Choose the one you like (pick the coolest sounding one 😎).</p><p>Next up, let’s connect to the quantum computer using the following lines of code:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cf64ef40ffcbaad9eca470fd36836743/href">https://medium.com/media/cf64ef40ffcbaad9eca470fd36836743/href</a></iframe><p>Before we build a circuit, let’s create a record of Qubits and Classical Bits for our random number generator that generates numbers between 0 and 7 (n=3).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e223715c389169310502c4ab6119911a/href">https://medium.com/media/e223715c389169310502c4ab6119911a/href</a></iframe><p>Now, we need to construct a circuit that returns a Superposition of a Qubit and collapses it to a bitstring that represents an integer between 0 and 2^n — 1. To do that, we can apply the Hadamard Gate on the 3 Qubits to put them all in a Superposition with a 50–50 chance of being a 1 or 0.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/af405b69c6824b46f23e7c556fce5190/href">https://medium.com/media/af405b69c6824b46f23e7c556fce5190/href</a></iframe><p>If we visualize this circuit, it’ll look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BGL19_A6FhIbN578fuN7hw.png" /><figcaption>The Quantum Circuit we’re sending up to the IBM Q Quantum Computer</figcaption></figure><p>Now, it’s time for the exciting part. Let’s instantiate the Quantum Backend that’s going to run our circuit. Remember you used the Qasm Simulator up above? In the same way, my <strong><em>ibmqx4</em></strong> machine is the simulator here (here, it’s the real deal!). Let’s connect our backend simulator:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a13eb783eefe0ec62de48e6b3ff6a82c/href">https://medium.com/media/a13eb783eefe0ec62de48e6b3ff6a82c/href</a></iframe><p><em>Shots</em> here refers to the number of times the circuit is being run. Here we only want 1 randomly generated number, so we set it to 1.</p><p><strong><em>Note: </em></strong><em>You can play around with the number and set it to something like 1000 to see a histogram of the generated numbers over the 1000 runs.</em></p><p>Next up is the main event function the runs a job on the <strong><em>ibmqx4</em></strong> Quantum Computer and returns a completely random number between 0 and 7:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/431e1a2027582472e7f12cee299a5e89/href">https://medium.com/media/431e1a2027582472e7f12cee299a5e89/href</a></iframe><p>Now, it’s the moment of truth. Let’s run the complete circuit on our Quantum Computer allocated to us:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6906554d70bcc10e0a20f16550b364df/href">https://medium.com/media/6906554d70bcc10e0a20f16550b364df/href</a></iframe><p>The code here will take a few minutes to run and took 3 credits from my account (you’re given 15, to begin with). When I ran the circuit, the final output was <strong>6</strong>.</p><p>With that, congrats for coming this far! You’ve just built a Quantum Circuit. Let’s revisit the steps to successfully run a quantum program:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/1*fxx8el2vMh1hPhJYAtbReA.png" /><figcaption>The typical process of building a Quantum Circuit and running it on a Quantum backend.</figcaption></figure><p><strong><em>Note:</em></strong><em> The full code for the Quantum Random Number Generator can be found </em><a href="https://gist.github.com/rish-16/6f34b7481abbe4257216cdd032cbe78b"><em>here</em></a><em>.</em></p><h4>Wrapping up</h4><p>You’ve just built a Quantum Circuit! That’s awesome! You are taking one step forward on your journey to becoming an expert. By thinking of simple processes that require manipulation of bits and converting the problem into one that can be solved by a Quantum Computer, it’s good practice to getting a firm grasp over the concepts.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FtCV2LrPPYfqCY%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2Frobert-downey-jr-thumbs-up-no-problem-tCV2LrPPYfqCY&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FtCV2LrPPYfqCY%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="482" frameborder="0" scrolling="no"><a href="https://medium.com/media/04f48079fedd1c9baa348488665cb2a9/href">https://medium.com/media/04f48079fedd1c9baa348488665cb2a9/href</a></iframe><h4>In a nutshell</h4><p>Learning about the principles behind Quantum Computing was surely very demanding! There’s so much theory floating around that having a grounded understanding of what’s going on is very important.</p><p>Learning about Qiskit was really fun and the documentation and resources provided by IBM Research went a long way in helping me understand what’s going on. Of all the quantum processors including Google Cirq and QuTiP, Qiskit was the most enjoyable to learn and implement circuits with.</p><p>Quantum Computing is gaining pace at a promising rate. Researchers are making progress in democratizing the usage of Quantum Computers to perform tasks and tackle problems that were once considered impossible to solve.</p><p>However, Quantum Computing theory has not reached a stage where it is fully accessible to everyone. It may be due to the clunkiness of Quantum Computers, the colossal facilities and the enormous amount of resources that are needed to keep the field active.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/463/1*vb-2lUcCe3l3xBVoS-CJbw.png" /></figure><p>Notwithstanding this, hopefully, this article has given some insight into what’s going on in the field and has sparked some interest in you! If you have any questions or want to talk about anything, you can catch me blatantly procrastinating on <a href="https://twitter.com/rishabh16_">Twitter</a> or <a href="https://www.linkedin.com/in/rishabhanand16/">LinkedIn</a>.</p><p>My next article will probably be focussed on the mathematics behind Quantum Computing and how the different gates and logic manipulate the Qubits. We’ll be doing a rundown of the quantum algorithms and how they go about doing what they do!</p><p>Till then I’ll see you in the next one!</p><p>Original article by <a href="https://medium.com/u/50c04ecf0ec5">Rishabh Anand</a></p><h4>Related articles</h4><p>Do check out my other articles on technology and Machine Learning, and reviews of up-and-coming software innovations.</p><ul><li><a href="https://towardsdatascience.com/quantum-computing-with-colorful-diagrams-8f7861cfb6da">Crash Course in Quantum Computing Using Very Colorful Diagrams</a></li><li><a href="https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0">A Comprehensive Guide to Genetic Algorithms (and how to code them)</a></li><li><a href="https://hackernoon.com/catgan-cat-face-generation-using-gans-f44663586d6b">CatGAN: cat face generation using GANs</a></li><li><a href="https://hackernoon.com/introducing-tensorflow-js-3f31d70f5904">Introducing TensorFlow.js 🎉</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9031b548fa7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/data-science/building-your-own-quantum-circuits-in-python-e9031b548fa7">Building Your Own Quantum Circuits in Python</a> was originally published in <a href="https://medium.com/data-science">TDS Archive</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Crash Course in Quantum Computing Using Very Colorful Diagrams]]></title>
            <link>https://medium.com/data-science/quantum-computing-with-colorful-diagrams-8f7861cfb6da?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f7861cfb6da</guid>
            <category><![CDATA[logic-gates]]></category>
            <category><![CDATA[quantum-circuits]]></category>
            <category><![CDATA[quantum-physics]]></category>
            <category><![CDATA[quantum-computing]]></category>
            <category><![CDATA[shrodingers-cat]]></category>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Sat, 16 Mar 2019 12:54:08 GMT</pubDate>
            <atom:updated>2019-11-23T03:19:41.877Z</atom:updated>
            <content:encoded><![CDATA[<h4>Almost everything you need to know about Quantum Computing explained using very intuitive drawings…</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/515/1*XfZiWglaT6Gv1tM7KY1zLQ.png" /><figcaption>Have a quantum cat</figcaption></figure><p>Quantum Computing is a relatively new, up-and-coming field that smashes the concepts of Quantum Physics, or the study or very small things, and Computer Science.</p><p>In this article, I’ll introduce you to the concepts that drive this young, growing field with intuitive analogies and as always, colorful sketches and drawings.</p><p><strong><em>Note:</em></strong><em> I won’t be covering the math and vector notations in this article for simplicity purposes. If interested in reading such an article, drop a comment below or feel free to contact me via </em><a href="https://twitter.com/rishabh16_"><em>Twitter</em></a><em>!</em></p><h4>Information representation in classical Computer Science</h4><p>Classical CS involves the flow and manipulation of bits (<strong>b</strong>inary dig<strong>its</strong>) — the basic units of information in a computer. It can hold the value of either 1 or 0, not both at the same time.</p><p>The 1 or 0 usually correspond to the charge of an atom on the hardware, which represents the true/false or on/off states in a computer.</p><p>The change of these charges results in the flipping of bits from 1 to 0 or vice versa, allowing information to flow from one location in the memory to another.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/765/1*ioP6i-VCIPFnNh5LzL7hfg.png" /><figcaption>Traditional bits are just charges on computer hardware that store information depending on their charge.</figcaption></figure><h4>Representing information in Quantum Computing</h4><p>In a traditional computer, information is represented using traditional bits that can only possess a value of 1 or 0 and not both at the same time. In Quantum computers, we represent information using Qubits (quantum bits).</p><p>We can represent Qubits using the <strong><em>bra-ket</em></strong> notations: |0⟩ or |1⟩, pronounced ‘ket 0’ and ‘ket 1’ respectively.</p><p>Well, in Quantum Computing, the Qubit can have the values of both 1 and 0 simultaneously because of a process called <strong><em>Superposition</em></strong>.</p><h4>The curious case of Superposition</h4><p>Superposition refers to a phenomenon where a particle or entity can exist in two states at the same time. It can exist as two things or exist in two different positions. For instance, let’s look at the Schrodinger’s Cat paradox.</p><p>If you lock a cat inside a soundproof, inescapable bunker with some explosive material that may likely explode, the cat is in a Superposition of both <strong><em>dead</em></strong> and <strong><em>alive</em></strong> because you don’t know if the material really blew up or not (probably because the bunker is soundproof).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AT1yrhNgbQJXDZZXXeF1tg.jpeg" /><figcaption>There is a 50–50 chance of the explosive material either blowing up and killing the cat or staying as is. This is taken from the Minute Physics video on Quantum Superposition</figcaption></figure><p>The cat is technically both dead and alive so long as you don’t open the bunker and check.</p><p>However, a quirky situation arises when an observer actually checks the state of an object in Superposition. In this case, reality collapses to one single outcome and it cannot exist in multiple states at the same time anymore. Similarly, if you can’t hold it in anymore and open the bunker, you may see that the cat is dead.</p><blockquote>Guess what? Your curiosity killed the cat…</blockquote><p>Or, the cat could still be alive when you check. When an observer (you, in this case) observes an object that was initially in Superposition, they will only see one of n-number of outcomes unfold in front of their eyes. As mentioned before, reality collapses to one of the outcomes.</p><h4>How is this related to Quantum Computing?</h4><p>A Qubit can exist in a Superposition, carrying the value of both 1 and 0 at the same time. This opens up a whole new world of possibilities for solving complex problems that require lots of computational power.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/831/1*jA5nMVXf6jyPB2jYIk_PTQ.png" /><figcaption>Qubits can exist in 2 possible states until observed (which causes reality to collapse to one of the states)</figcaption></figure><h4>Traditional Logic Gates</h4><p>In order to manipulate fundamental bits, they must be transformed by logic gates that either flips bits to another value or let them remain as they are. Some famous examples of logic gates include AND, OR, NOT, XOR and NAND.</p><p>They take pairs of bit values and transform them to either a 1 or 0 depending on the functionality of the gate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/765/1*s2K-z3-6pqmAJpL3DgSkpA.png" /><figcaption>An example of a NAND gate that takes in pairs of similar bits and returns the flipped bit</figcaption></figure><h4>Quantum Logic Gates</h4><p>To transform Qubits, we pass them through Quantum Logic Gates (or Quantum Gates) that maps the existing state of a Qubit to another state based on the functionality of the gate.</p><p>This may sound vague, but Quantum Gates are practically classical logic gates that act on Qubits instead of traditional bits. Quantum Gates can invariably perform all the actions that standard classical logic gates can.</p><p>Let’s look at a few examples of Quantum Gates:</p><h4>Hadamard Gate</h4><p>Perhaps the most common, the Hadamard Gate takes in a single Qubit as input and outputs a Qubit that has a 50–50 chance of either being a 1 or a 0.</p><p>In simple mathematical terms, there is an equal probability of the Qubit collapsing to a 1 or 0. This in itself is a Superposition where the output Qubit has two possible states until we <em>observe </em>it or use it in further calculations.</p><p>The Hadamard Gate is represented by an ‘H’ in a box and can be added to a circuit multiple times to output a bit that has an equal chance of being a 1 or 0.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/276/1*pJeSr5Bq3l9iWjr9aBEGLQ.png" /><figcaption>The Hadamard Gate</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/1*0k-iNWbQ6ukncspQPQs6LA.png" /><figcaption>There’s a 50–50 chance of the Qubit collapsing to either a 1 or 0</figcaption></figure><h4>Pauli-X Gates</h4><p>Named after Wolfgang Pauli (awesome name by the way), the Pauli-X Gate takes in a single Qubit. It is essentially the equivalent to the <strong>NOT</strong> Gate which negates the bits and flips them. It performs a bit flip on the Qubits. It maps/changes a |0⟩ to |1⟩ and |1⟩ to |0⟩.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/276/1*wuAhw9YrabqnVUDDFw76LQ.png" /><figcaption>The Quantum equivalent of the NOT Gate — The Pauli Gate</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/835/1*a-pTQe5sNE382JTO3qrbYA.png" /><figcaption>The Pauli-X Gate performs a bit flip and negates the Qubits</figcaption></figure><h4>Controlled-NOT Gate</h4><p>The Controlled NOT gate is also called the CNOT Gate. This takes in 2 Qubits and only flips the second Qubit from a |0⟩ to |1⟩ and |1⟩ to |0⟩ if the first Qubit is |1⟩. Otherwise, it leaves it unchanged.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/276/1*B9ts-AC1pNFStdeQWd0cUA.png" /><figcaption>The CNOT or Controlled-NOT Gate</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gUepE9MnxaJq7_G4EqEDCQ.png" /><figcaption>The CNOT gate only flips the second Qubit if the first Qubit is |1⟩</figcaption></figure><h4>Measurement</h4><p>Measurement is a special type of operations done on Qubits at the end of a circuit to get the final values of the Qubits after the operations have been conducted.</p><p>Compared to the gates above, Measurement is irreversible and hence, is not a Quantum Gate. I mentioned earlier that when an observer looks at something that was initially in a Superposition, reality collapses to one of the outcomes.</p><p>Similarly, the Measurement function is the observer and takes the collapsed Qubits’ values and puts them together as the final output bits that are either 1 or 0 strictly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/276/1*u_KjpvpvRztY-QP5tQJOTw.png" /><figcaption>The Measurement function is represented as this symbol in a Quantum Circuit</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/614/1*9NGWnZMKJMnEX_Vo4_4_Uw.png" /><figcaption>The Measurement function takes in a Qubit and observes it to collapse its state to either 1 or 0.</figcaption></figure><h4>Representing Quantum models</h4><p>Models are what physicists use to simulate and observe what happens when you poke the universe in a certain way. They help a great deal when it comes to visualization.</p><p>Similarly, Quantum models represent situations that deal with numerous Quantum phenomenon (such as Superposition, for instance).</p><blockquote>How do we represent a mathematical quantum model on a computer?</blockquote><p>We do so by using Quantum Circuits. Circuits represent computational processes in which Qubits are passed through Quantum Logic Gates that transform Qubits from one state to another depending on their type/functionality.</p><p>To build a Quantum Circuit, we need a combination of Quantum Logic Gates and Qubits through time to get the desired outcome. To visualize what a Quantum Circuit looks like, take a look at the figure below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*b3YkFqeZNTMzNx6hw3WC9g.png" /></figure><p>The figure shows three Qubits, all with states |0⟩ or <strong><em>ket 0</em></strong>. The <strong>H </strong>in the boxes represent Quantum Logic Gates (H is the Hadamard gate).</p><p>In this figure, we can see the Qubits going through a Hadamard Gate each. The second and third Qubits go through another Hadamard Gate each.</p><p>By putting together these Quantum Gates and Qubits in a Circuit, you can visualize the flow of information through the Circuit.</p><h4>In a nutshell</h4><p>In this article, I tried to summarise the seemingly-difficult theory behind Quantum Computing. Quantum Computing is an up-and-coming field that has a very small community. I’ll be covering the math and vector notations in upcoming articles on Quantum Computing.</p><p>If you want me to cover anything else, drop a comment below or reach out to me on <a href="http://twitter.com/rishabh16_">Twitter</a> or <a href="https://www.linkedin.com/in/rishabhanand16/">LinkedIn</a>. Soon, I’ll be taking you through making your own Quantum Circuit in simple Python (Yes. I said Python).</p><p>If there are any mistakes I’ve made, please do let me know (I’m learning too!).</p><p>Until then, see you in the next one!</p><h4>Related articles</h4><p>Do check out my other articles on technology and Machine Learning, and reviews of up-and-coming software innovations.</p><ul><li><a href="https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0">A Comprehensive Guide to Genetic Algorithms (and how to code them)</a></li><li><a href="https://hackernoon.com/catgan-cat-face-generation-using-gans-f44663586d6b">CatGAN: cat face generation using GANs</a></li><li><a href="https://hackernoon.com/introducing-tensorflow-js-3f31d70f5904">Introducing TensorFlow.js 🎉</a></li><li><a href="https://medium.com/sigmoid/rl-markov-chains-dbf2f37e8b69">A Brief Introduction to Markov Chains</a></li></ul><p>Original article by <a href="https://medium.com/u/50c04ecf0ec5">Rishabh Anand</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f7861cfb6da" width="1" height="1" alt=""><hr><p><a href="https://medium.com/data-science/quantum-computing-with-colorful-diagrams-8f7861cfb6da">Crash Course in Quantum Computing Using Very Colorful Diagrams</a> was originally published in <a href="https://medium.com/data-science">TDS Archive</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Brief Introduction to Markov Chains]]></title>
            <link>https://medium.com/sigmoid/rl-markov-chains-dbf2f37e8b69?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/dbf2f37e8b69</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[reinforcement-learning]]></category>
            <category><![CDATA[markov-chains]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Wed, 27 Feb 2019 11:03:11 GMT</pubDate>
            <atom:updated>2019-02-27T11:03:11.351Z</atom:updated>
            <content:encoded><![CDATA[<h4>A general guide on what makes the Markov Decision Process tick</h4><p><strong><em>tldr;</em></strong><em> This is part of a series of reference articles teaching the concepts that drive Reinforcement Learning. We’ll be starting off simple, incrementally moving on to more complex concepts further down the road.</em></p><p>A Markov Chain is a stochastic (always changing) model that is used to predict/estimate/guess the outcome of an event given only the previous state and its action. The state refers to the current ‘slice’ of the environment. It’s the particular condition that an agent is contained in at a specific time step.</p><p>For example, in Sonic the Hedgehog, a state refers to the current pixel intensity values that represent the game screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/477/1*GnFKk6JZqv3Uv51u_9BaSg.png" /><figcaption>The state refers to the current pixel values that make up this particular game screen at time 0:05 seconds</figcaption></figure><p>It can be represented by a matrix of values pertaining to the pixel values. When used in a Reinforcement Learning algorithm, it can be represented as something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/477/1*0yHoBrTMH1neWFwpu-EshA.png" /><figcaption>The different color RGB channels that form the current state</figcaption></figure><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2F5008b6-2%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2F5008b6-2%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/c12b608fccfefbccf9e6f493ef5cb71f/href">https://medium.com/media/c12b608fccfefbccf9e6f493ef5cb71f/href</a></iframe><h4>The Markov Chain</h4><p>The Markov Chain is a model used to describe a sequence of consecutive events where the probability or chance of an event depends only on the event before it.</p><p>If a sequence of events exhibits the Markov Property of the reliance on the previous state, then the sequence is called ‘Markovian’ in nature.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/477/1*bnAjR8ulmRmdMiPZTcSt0Q.png" /><figcaption>An example of a Markov Chain with numbers for visualization purposes</figcaption></figure><p>The figure above shows two states, A and E. The probability of an event occurring depends on the current state. A movement from A to E or vice versa depends on whether the ‘character’ was previously on A or E.</p><p>If the previous state or location was A, then the probability of going to E is 0.4 while the probability of staying on A is 0.6 (fundamentally A to A).</p><p>The probability of going from E to A is 0.7 while the probability of staying on E is 0.3 (E to E).</p><p>Hopefully, this can help you visualize the process of moving from state to state depending on the current state. If we were to write this mathematically, it is simply the probability of an event happening in the future time step, <strong>S<em>t+1</em></strong>, <strong><em>s’</em></strong>, given the current state <strong>S<em>t</em></strong>, <strong><em>s</em></strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*MttGDZm6XvBMDbJsrDzSIA.png" /></figure><h4>The advent of Markov Chains</h4><p>For some problems in Reinforcement Learning, the actions performed in a particular state is directly related to the previous state, the actions performed in that state and the rewards that the agent receives upon performing said actions.</p><p>This Markovian property of a problem greatly benefits us as it makes the agent really versatile while being really lightweight compared to deep neural networks with heavy parameters.</p><p>Furthermore, Markov Chains are used in a process called Markov Reward Process where the agent (whose objective is to maximize the rewards earned in the task) in the current task is rewarded based on its performance in the current time step.</p><h3>In a nutshell</h3><p>Markov Chains are really useful in Reinforcement Learning as it has enabled us to achieve and even exceed human performance in many areas and problems from teaching robots how to handle objects with care to beating difficult Atari games that were previously never beaten by statistical Machine Learning.</p><p>Over the next few articles, we’ll go through the various forms and applications of the Markov Property and how useful it is when dealing with certain problems.</p><p>For the next article, I am planning to write a small dictionary of all the terminology used in the field of Reinforcement Learning as a reference piece. If you have any suggestions for RL articles or questions in general, feel free to drop in a comment below.</p><p>With that, I’ll see you in the next one.</p><p>Original article by <a href="https://medium.com/u/50c04ecf0ec5">Rishabh Anand</a></p><h4>Related articles</h4><p>Check out my other articles on technology and Machine Learning, and reviews of up-and-coming software innovations.</p><ul><li><a href="https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0">A Comprehensive Guide to Genetic Algorithms (and how to code them)</a></li><li><a href="https://hackernoon.com/introducing-tensorflow-js-3f31d70f5904">Introducing TensorFlow.js 🎉</a></li><li><a href="https://hackernoon.com/catgan-cat-face-generation-using-gans-f44663586d6b">CatGAN: cat face generation using GANs</a></li><li><a href="https://towardsdatascience.com/tensorflow-or-tensorno-c9c6c6c2f992">TensorFlow or TensorNo?</a></li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2F5008b6-2%3Fas_embed%3Dtrue&amp;dntp=1&amp;url=https%3A%2F%2Fupscri.be%2F5008b6-2%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/c12b608fccfefbccf9e6f493ef5cb71f/href">https://medium.com/media/c12b608fccfefbccf9e6f493ef5cb71f/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dbf2f37e8b69" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sigmoid/rl-markov-chains-dbf2f37e8b69">A Brief Introduction to Markov Chains</a> was originally published in <a href="https://medium.com/sigmoid">Sigmoid</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Transition, Tenacity, and Ten Thousand Dollars…]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/swlh/tenacity-teamwork-and-ten-thousand-dollars-c2eb19190e87?source=rss-50c04ecf0ec5------2"><img src="https://cdn-images-1.medium.com/max/1600/1*a1TffJJR3SsnEMovTov2nw@2x.jpeg" width="1600"></a></p><p class="medium-feed-snippet">I set a path for myself, tried to stay on it, met a future Co-founder, and eventually ended up with $10K in my hands&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/swlh/tenacity-teamwork-and-ten-thousand-dollars-c2eb19190e87?source=rss-50c04ecf0ec5------2">Continue reading on The Startup »</a></p></div>]]></description>
            <link>https://medium.com/swlh/tenacity-teamwork-and-ten-thousand-dollars-c2eb19190e87?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2eb19190e87</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[mlblocks]]></category>
            <category><![CDATA[ideasinc]]></category>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Mon, 05 Nov 2018 02:13:48 GMT</pubDate>
            <atom:updated>2019-11-14T02:41:37.626Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[A Comprehensive Guide to Genetic Algorithms (and how to code them)]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0?source=rss-50c04ecf0ec5------2"><img src="https://cdn-images-1.medium.com/max/900/1*Bylye2rZ5HHI0xcz9qeZUA.jpeg" width="900"></a></p><p class="medium-feed-snippet">On the Origin of Genetic Algorithms</p><p class="medium-feed-link"><a href="https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0?source=rss-50c04ecf0ec5------2">Continue reading on Sigmoid »</a></p></div>]]></description>
            <link>https://medium.com/sigmoid/https-medium-com-rishabh-anand-on-the-origin-of-genetic-algorithms-fc927d2e11e0?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc927d2e11e0</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[genetic-algorithm]]></category>
            <category><![CDATA[natural-selection]]></category>
            <category><![CDATA[reinforcement-learning]]></category>
            <category><![CDATA[evolution]]></category>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Tue, 28 Aug 2018 01:12:26 GMT</pubDate>
            <atom:updated>2018-08-28T01:19:41.489Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[CatGAN: cat face generation using GANs]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/hackernoon/catgan-cat-face-generation-using-gans-f44663586d6b?source=rss-50c04ecf0ec5------2"><img src="https://cdn-images-1.medium.com/max/1202/1*l2vt87HeMJOhZq1vjehxtA.png" width="1202"></a></p><p class="medium-feed-snippet">Detailed review of GANs and how to waste your time with them&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/hackernoon/catgan-cat-face-generation-using-gans-f44663586d6b?source=rss-50c04ecf0ec5------2">Continue reading on HackerNoon.com »</a></p></div>]]></description>
            <link>https://medium.com/hackernoon/catgan-cat-face-generation-using-gans-f44663586d6b?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/f44663586d6b</guid>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Tue, 22 May 2018 16:01:01 GMT</pubDate>
            <atom:updated>2019-05-23T07:36:32.603Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Introducing TensorFlow.js ]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/hackernoon/introducing-tensorflow-js-3f31d70f5904?source=rss-50c04ecf0ec5------2"><img src="https://cdn-images-1.medium.com/max/1400/1*F-1fq9TNjDnAYPAXnZP4Ww.png" width="1400"></a></p><p class="medium-feed-snippet">Running ML models on the browser became so much more easier!</p><p class="medium-feed-link"><a href="https://medium.com/hackernoon/introducing-tensorflow-js-3f31d70f5904?source=rss-50c04ecf0ec5------2">Continue reading on HackerNoon.com »</a></p></div>]]></description>
            <link>https://medium.com/hackernoon/introducing-tensorflow-js-3f31d70f5904?source=rss-50c04ecf0ec5------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f31d70f5904</guid>
            <category><![CDATA[webgl]]></category>
            <category><![CDATA[javascript-library]]></category>
            <category><![CDATA[tensorflow]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Rishabh Anand]]></dc:creator>
            <pubDate>Sun, 08 Apr 2018 05:51:16 GMT</pubDate>
            <atom:updated>2019-05-23T07:37:01.482Z</atom:updated>
        </item>
    </channel>
</rss>