<?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 Rohan Jha on Medium]]></title>
        <description><![CDATA[Stories by Rohan Jha on Medium]]></description>
        <link>https://medium.com/@rohanjhanepal?source=rss-6dc7aefb0cc4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Uf0e2SGp-4K_qi-k2zOnRA.jpeg</url>
            <title>Stories by Rohan Jha on Medium</title>
            <link>https://medium.com/@rohanjhanepal?source=rss-6dc7aefb0cc4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 19:04:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rohanjhanepal/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[Building a Small Language Model on Avengers Script using N-Grams for Text Prediction]]></title>
            <link>https://medium.com/@rohanjhanepal/building-a-small-language-model-on-avengers-script-using-n-grams-for-text-prediction-7487e6231296?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/7487e6231296</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[nlp]]></category>
            <category><![CDATA[naturallanguageprocessing]]></category>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Thu, 03 Apr 2025 01:27:08 GMT</pubDate>
            <atom:updated>2025-04-03T01:27:08.727Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OhL2RIEoVjblbZY6y8kJ4g.jpeg" /></figure><p>Have you ever wondered how search engines, chat applications, or autocomplete features predict the next word while you type? These systems use language models to determine the most likely next word based on previous words in a sentence. One of the simplest yet effective approaches for this is the <strong>N-Gram Language Model</strong>.</p><p>In this article, we will build an N-Gram model from scratch, covering the underlying theory, mathematical formulation, and implementation in Python. We’ll also demonstrate its effectiveness using real-world text data from the <em>Avengers</em> movie script.</p><h3>Understanding N-Grams</h3><p>An <strong>N-Gram</strong> is a contiguous sequence of <em>n</em> words from a given text. Based on the number of words, we classify them as:</p><ul><li><strong>Unigram (n=1):</strong> [“Hello”], [“world”]</li><li><strong>Bigram (n=2):</strong> [“Hello world”]</li><li><strong>Trigram (n=3):</strong> [“Hello world again”]</li><li><strong>N-Gram (n=k):</strong> A sequence of <em>k</em> words.</li></ul><p>The key idea behind n-gram models is to estimate the probability of a word occurring given the previous <em>n-1</em> words, so how likely is the word “world” to occur given the previous word “Hello”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/204/1*Q2Epxop94JO0Am96xbnJXw.png" /></figure><p>Using <strong>the Markov Assumption</strong>, we simplify this by only considering the last <em>n-1</em> words:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/425/1*UFo3aGhCIiQszF3asH2e_g.png" /></figure><p>This frequency-based estimation is often improved using <strong>Laplace Smoothing</strong>, which avoids zero probabilities for unseen words:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/475/1*MSz2STeb28eGOzfV08abOQ.png" /></figure><p>where |V| is the vocabulary size.</p><h3>Implementing an N-Gram Model in Python</h3><p>Let’s walk through the Python implementation of an N-Gram-based text prediction system.</p><h3>Step 1: Counting N-Grams</h3><p>We begin by constructing a function to count occurrences of n-grams in a given text dataset.</p><pre>import math<br>import random<br>import numpy as np<br>import pandas as pd<br><br>def count_n_grams(data, n, start_token=&#39;&lt;s&gt;&#39;, end_token=&#39;&lt;e&gt;&#39;):<br>    &quot;&quot;&quot;<br>    Counts all n-grams in the given dataset.<br>    &quot;&quot;&quot;<br>    n_grams = {}<br>    padded_data = [[start_token] * n + sentence + [end_token] for sentence in data]<br>    <br>    for sentence in padded_data:<br>        for i in range(len(sentence) - n + 1):<br>            n_gram = tuple(sentence[i:i + n])<br>            n_grams[n_gram] = n_grams.get(n_gram, 0) + 1<br>    <br>    return n_grams</pre><h3>Step 2: Estimating Probabilities</h3><p>Once we have the n-gram counts, we compute probabilities using Laplace smoothing</p><pre>def estimate_probability(word, previous_n_gram, n_gram_counts, n_plus1_gram_counts, vocabulary_size):<br>    &quot;&quot;&quot;<br>    Estimates the probability of a word given a previous n-gram using Laplace smoothing.<br>    &quot;&quot;&quot;<br>    previous_n_gram = tuple(previous_n_gram)<br>    n_plus1_gram = previous_n_gram + (word,)<br>    <br>    n_plus1_count = n_plus1_gram_counts.get(n_plus1_gram, 0)<br>    n_gram_count = n_gram_counts.get(previous_n_gram, 0)<br>    <br>    return (n_plus1_count + 1) / (n_gram_count + vocabulary_size)</pre><h3>Step 3: Predicting the Next Word</h3><p>Now, let’s create a function that suggests the most likely next word based on the computed probabilities.</p><pre>def suggest_a_word(previous_tokens, n_gram_counts, n_plus1_gram_counts, vocabulary):<br>    &quot;&quot;&quot;<br>    Suggests the most likely next word based on n-gram probabilities.<br>    &quot;&quot;&quot;<br>    n = len(list(n_gram_counts.keys())[0])<br>    previous_n_gram = tuple(previous_tokens[-n:])<br>    <br>    probabilities = {<br>        word: estimate_probability(word, previous_n_gram, n_gram_counts, n_plus1_gram_counts, len(vocabulary))<br>        for word in vocabulary<br>    }<br>    <br>    return max(probabilities.items(), key=lambda x: x[1])</pre><h3>Testing with Avengers Movie Script</h3><p>Let’s apply our model to a dataset containing lines from <em>The Avengers</em> script.</p><pre>sentences = [[&#39;i&#39;, &#39;have&#39;, &#39;an&#39;, &#39;army&#39;],<br>             [&#39;we&#39;, &#39;have&#39;, &#39;a&#39;, &#39;hulk&#39;],<br>             [&#39;i&#39;, &#39;am&#39;, &#39;iron&#39;, &#39;man&#39;],<br>             [&#39;you&#39;, &#39;should&#39;, &#39;have&#39;, &#39;gone&#39;, &#39;for&#39;, &#39;the&#39;, &#39;head&#39;]]<br><br>unique_words = list(set(sum(sentences, []))) + [&#39;&lt;s&gt;&#39;, &#39;&lt;e&gt;&#39;, &#39;&lt;unk&gt;&#39;]<br><br>unigram_counts = count_n_grams(sentences, 1)<br>bigram_counts = count_n_grams(sentences, 2)<br>trigram_counts = count_n_grams(sentences, 3)<br><br>previous_tokens = [&#39;i&#39;, &#39;have&#39;]<br>suggestion, probability = suggest_a_word(previous_tokens, unigram_counts, bigram_counts, unique_words)<br><br>print(f&quot;The previous words are &#39;{&#39; &#39;.join(previous_tokens)}&#39;,\n\tand the suggested word is &#39;{suggestion}&#39; with a probability of {probability:.4f}&quot;)</pre><p>Output:</p><pre>The previous words are &#39;i have&#39;,<br>    and the suggested word is &#39;an&#39; with a probability of 0.3333</pre><h3>Conclusion</h3><p>N-Gram language models provide a simple yet powerful way to predict text sequences. While they work well for small-scale applications, they struggle with:</p><ol><li><strong>Data sparsity</strong> — Some n-grams may not appear in the training data.</li><li><strong>Fixed context size</strong> — They only consider <em>n-1</em> previous words, ignoring long-term dependencies.</li><li><strong>Scalability</strong> — Large n-grams require extensive memory and computation.</li></ol><p>For more advanced text prediction, modern approaches like <strong>Recurrent Neural Networks (RNNs)</strong> and <strong>Transformer-based models (e.g., GPT, BERT)</strong> are preferred</p><p>For the code, visit: <a href="https://github.com/rohanjhanepal/n-gram-text-prediction">https://github.com/rohanjhanepal/n-gram-text-prediction</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7487e6231296" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[KNN - All The Math Behind It]]></title>
            <link>https://medium.com/@rohanjhanepal/knn-all-the-math-behind-it-58323fd77db6?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/58323fd77db6</guid>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Wed, 11 Dec 2024 00:48:04 GMT</pubDate>
            <atom:updated>2024-12-11T00:48:04.872Z</atom:updated>
            <content:encoded><![CDATA[<h3>KNN- All The Maths Behind It</h3><p>Imagine standing in a street, trying to decide which restaurant to pick. You look at a nearby restaurant and notice a restaurant with similar food you find pleasing. You instinctively pick that one. That’s how KNN works — by ‘<strong>looking around</strong>’ and choosing the nearest neighbors.</p><p>This article explores the mathematics behind K-Nearest Neighbors (KNN), one of the simplest yet most effective algorithms in machine learning.</p><p>KNN is a <strong>supervised </strong>machine learning algorithm used for <strong>classification and regression </strong>by relying on the idea of finding ‘K’ closest data points (neighbors) to make predictions.</p><p>KNN <strong>uses distance measures </strong>such as Manhattan, Euclidean, Minkowski <a href="https://www.sciencedirect.com/topics/computer-science/minkowski-distance">[2]</a>, Cosine, etc to calculate closeness with other data points.</p><p>Below is the <strong>P-Norm </strong>(Minkowski) distance, which is a generalized form to represent the distances.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*pjwspCrSGlVrlWzyaQLpsw.png" /><figcaption>P-Norm distance (source: [1])</figcaption></figure><p>When P=1; dist(x,z) is equivalent to Manhattan distance</p><p>When P=2; dist(x,z) is equivalent to Euclidean distance</p><p>Now that we know about distances, let&#39;s look at how this fits in place with the KNN algorithm.</p><h4>Step-by-Step Explanation of KNN</h4><ol><li><strong>Compute </strong>the <strong>distance </strong>between the query point and all training points.</li><li><strong>Sort </strong>the distances.</li><li><strong>Select </strong>the <strong>K </strong>nearest neighbors; the value of K is a hyper-parameter and it determines the number of nearest neighbors to consider while aggregating the outputs.</li><li>Aggregate the outputs:</li></ol><ul><li><strong>Classification</strong>: Majority voting, i.e. which class does the majority of K nearest neighbors correspond to.</li><li><strong>Regression</strong>: Averaging the values, i.e averaging the values corresponding to K nearest neighbors.</li></ul><h3>By Visual Example</h3><p>Imagine a 2d plane as above where data points are spread out into 3 groups (classes) as in the figure below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/438/1*RXJh6fTUZYcMIe1Qkj85Eg.png" /><figcaption>Points on a 2d Plane</figcaption></figure><p>Let&#39;s introduce a point that we need to figure out whether it lies in group 1,2 or 3.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/496/1*AKR71vw_mUcD3VTDrcezDA.png" /><figcaption>Introduce a new unknown point</figcaption></figure><p>Lets set K=3 and find 3 nearest point in the proximity. We do this by calculating the distance of the new point with every point and sorting to get points corresponding to the nearest K=3.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/433/1*1RtElP6EayDB9h7eJFEMow.png" /></figure><p>We note that among the 3 points in the nearest proximity, 2 of them are red and one blue.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/428/1*siS4sXSNGRDA1xtqnG2o_w.png" /></figure><p>Thus by aggregation (majority voting), we conclude that our new point falls in the Red group.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/429/1*dum6Z7m3BJyA2OKqRNyV9Q.png" /></figure><p>That&#39;s all there is to KNN. Pretty simple right?</p><p>It has some limitations though.</p><h4>Challenges and Limitations</h4><ul><li>Sensitivity to the choice of K’s value; The hyper-parameter K has a notable effect on the accuracy of the model; when low K, the variance is high(Overfit), and for high K the bias is high (Underfit). So correct K needs to be picked for optimal performance.</li><li>Computational inefficiency for large datasets as distance to every point needs calculation.</li><li>Curse of dimensionality.</li></ul><h4><strong>References:</strong></h4><ol><li><a href="https://www.cs.cornell.edu/courses/cs4780/2017sp/lectures/lecturenote02_kNN.html">https://www.cs.cornell.edu/courses/cs4780/2017sp/lectures/lecturenote02_kNN.html</a></li><li><a href="https://www.sciencedirect.com/topics/computer-science/minkowski-distance">https://www.sciencedirect.com/topics/computer-science/minkowski-distance</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58323fd77db6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[If You Don’t Know These 2 Concepts, You Don’t Know Python]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">Python&#x2019;s simplicity and readability make it an accessible language for beginners, but its true power emerges when you delve into advanced&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@rohanjhanepal/if-you-dont-know-these-2-concepts-you-don-t-know-python-2c4e14730b74?source=rss-6dc7aefb0cc4------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@rohanjhanepal/if-you-dont-know-these-2-concepts-you-don-t-know-python-2c4e14730b74?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/2c4e14730b74</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[python3]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Mon, 02 Sep 2024 08:11:55 GMT</pubDate>
            <atom:updated>2024-09-02T08:11:55.886Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How to Outsmart AI: The Fun Trick Behind the Fast Gradient Sign Method (FGSM)]]></title>
            <link>https://python.plainenglish.io/how-to-outsmart-ai-the-fun-trick-behind-the-fast-gradient-sign-method-fgsm-66002e29e582?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/66002e29e582</guid>
            <category><![CDATA[software]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Mon, 05 Aug 2024 11:39:36 GMT</pubDate>
            <atom:updated>2024-08-06T01:17:26.489Z</atom:updated>
            <content:encoded><![CDATA[<p>Imagine a world where AI has taken over. The only way to beat AI is to fool it. Make it believe humans don&#39;t even exist, such that, whenever it sees a human, it misclassifies it as a pizza.</p><p>Welcome to the thrilling and sometimes hilarious world of adversarial attacks! Today, we’ll dive into one of the coolest tricks in the book: the Fast Gradient Sign Method (FGSM).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RaVqG3QKKbNkqRpMOBKCOQ.png" /><figcaption>AI robots</figcaption></figure><h3>The AI Mastermind</h3><p>In our futuristic world, AI systems are the masterminds. They control everything from traffic lights to kitchen appliances. These AI systems are super smart, but like any genius, they have weaknesses. Enter the hero of our story: FGSM.</p><h3>The Art of Deception</h3><p>FGSM is like a magician’s power trick of hand but for AI. It’s all about creating tiny, imperceptible changes to an image that trick the AI into seeing something completely different. Imagine showing a picture of a cat to an AI, but it confidently tells you it’s a dog. That’s FGSM at work!</p><h3>How Does It Work?</h3><p>Picture this: you have an image of a cat. FGSM comes along and <strong>tweaks just a few pixels</strong>. These changes are <strong>so small that a human eye wouldn’t notice them. </strong>But for the AI, these tweaks are like a neon sign pointing to a different answer.</p><p>Here’s a <strong>fun analogy</strong>: think of AI as a super-smart student who’s great at math. You give them a simple equation to solve. Now, imagine you whisper some misleading hints in their ear while they work. Suddenly, they write down the wrong answer! FGSM is that whisper, nudging the AI towards a mistake.</p><h3>The Technical Magic</h3><p>Without getting too deep into the technical details, FGSM works by using the AI’s own training data against it. It calculates the gradient of the loss function (think of it as the AI’s measure of how wrong it is) with respect to the input image. Then, it adjusts the image in a direction that maximizes the loss, essentially fooling the AI.</p><p>x′=x + ϵ⋅sign(∇x​J(θ,x,y))</p><p>where:</p><ul><li>x′ is the adversarial example.</li><li>x is the original input image.</li><li>ϵ is a small scalar value that controls the perturbation magnitude.</li><li>sign(⋅) is the element-wise sign function.</li><li>∇xJ(θ,x,y) is the gradient of the loss function <em>J</em> with respect to the input x.</li><li>θ represents the model parameters.</li><li>y is the true label of the input image.</li></ul><p>WOh! Wohhh wohhh, math again? No worries that&#39;s simple, to put it in simple terms: FGSM is like a hacker who uses the AI’s own playbook to beat it at its own game.</p><h3>Why It Matters</h3><p>You might be wondering, “Why should I care about fooling AI?” Well, understanding FGSM and adversarial attacks is crucial for making AI systems more robust and secure. By learning how to trick AI, researchers can build stronger defences against these tricks. Because in future, AI hackers will be as common as wifi password hackers these days.</p><h3>The Fun Part</h3><p>To truly appreciate FGSM, try it out for yourself!</p><p>We will be changing a labrador image to misclassify it as a saluki</p><pre>import tensorflow as tf<br>import matplotlib as mpl<br>import matplotlib.pyplot as plt<br><br>pretrained_model = tf.keras.applications.MobileNetV2(include_top=True,<br>                                                     weights=&#39;imagenet&#39;)<br>pretrained_model.trainable = False<br><br># ImageNet labels<br>decode_predictions = tf.keras.applications.mobilenet_v2.decode_predictions<br># just a preprocessor for our images<br>def preprocess(image):<br>    image = tf.cast(image, tf.float32)<br>    image = tf.image.resize(image, (224, 224))<br>    image = tf.keras.applications.mobilenet_v2.preprocess_input(image)<br>    image = image[None, ...]<br>    return image<br><br># get prediction labels<br>def get_imagenet_label(probs):<br>    return decode_predictions(probs, top=5)[0]<br><br>#Lets load a labrador dog image<br>image_path = tf.keras.utils.get_file(&#39;YellowLabradorLooking_new.jpg&#39;, &#39;https://storage.googleapis.com/download.tensorflow.org/example_images/YellowLabradorLooking_new.jpg&#39;)<br>image_raw = tf.io.read_file(image_path)<br>image = tf.image.decode_image(image_raw)<br><br>image = preprocess(image)<br>image_probs = pretrained_model.predict(image)<br><br># lets look at our labrador<br>top5 = get_imagenet_label(image_probs)<br>tick_names = [x[1] for x in top5]<br>print(tick_names)<br>probs = [x[2] for x in top5]<br>plt.figure(figsize=(9, 3))<br>plt.subplot(121)<br>plt.imshow(image[0] * 0.5 + 0.5)<br>plt.title(&#39;image&#39;)<br>ax = plt.gca()<br>ax.axis(&#39;off&#39;)<br><br>plt.subplot(122)<br>tick_names = [x[1] for x in reversed(top5)]<br>probs = [x[2] for x in reversed(top5)]<br>plt.barh(tick_names, probs)<br>plt.yticks(rotation=25)<br>ax = plt.gca()<br>ax.spines[&#39;top&#39;].set_visible(False)<br>ax.spines[&#39;right&#39;].set_visible(False)<br>ax.spines[&#39;left&#39;].set_visible(False)<br>plt.tight_layout()<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1006/1*8rTcUqV3h74VCEGEL7zhNg.png" /></figure><pre># Lets actually create a adversarial image generator (THE FOOLER)<br>loss_object = tf.keras.losses.CategoricalCrossentropy()<br>def create_adversarial_pattern(input_image, input_label):<br>    with tf.GradientTape() as tape:<br>        tape.watch(input_image)<br>        prediction = pretrained_model(input_image)<br>        loss = loss_object(input_label, prediction)<br>        <br>    gradient = tape.gradient(loss, input_image)<br>    signed_grad = tf.sign(gradient)<br>    return signed_grad<br><br>def perform_attack(image,perturbations,eps=0.01):<br>    adv_x = image + eps * perturbations<br>    adv_x = tf.clip_by_value(adv_x, -1, 1)<br>    fooled = display_images(adv_x, image)<br>    return fooled<br><br># just for displaying<br>def display_images(perturbated_image, original_image):<br>    top5 = get_imagenet_label(pretrained_model.predict(perturbated_image))<br>    top5_original = get_imagenet_label(pretrained_model.predict(original_image))<br>    <br>    plt.figure(figsize=(9, 3))<br>    <br>    plt.subplot(121)<br>    plt.imshow(original_image[0]*0.5+0.5)<br>    plt.title(f&quot;Original Image prediction = {top5_original[0][1]}&quot;)<br>    plt.gca().axis(&#39;off&#39;)<br><br>    plt.subplot(122)<br>    plt.imshow(perturbated_image[0]*0.5+0.5)<br>    plt.title(f&quot;Perturbated Image prediction = {top5[0][1]}&quot;)<br>    plt.gca().axis(&#39;off&#39;)<br>    <br>    plt.tight_layout()<br>    plt.show()<br>    <br>    # Checking if AI was fooled or not<br>    if top5_original[0][1] != top5[0][1]:<br>        return True<br>    return False<br><br><br># Lets us ATTACKKKKKK<br>image = tf.image.decode_image(image_raw)<br>image = preprocess(image)<br>image_probs = pretrained_model.predict(image)<br>    <br>label = tf.one_hot(int(image_index), image_probs.shape[-1])<br>label = tf.reshape(label, (1, image_probs.shape[-1]))<br>    <br>perturbations = create_adversarial_pattern(image, label)<br>    <br>fooled = perform_attack(image,perturbations,0.01)<br>print(fooled)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/986/1*IYF5b2BvJkK3_CFCVF8OJQ.png" /></figure><p>Saluki? our labrador is now Saluki !!!! Wohlahhh</p><h3>Conclusion</h3><p>In our AI-dominated world, understanding adversarial attacks like FGSM is not just a cool party trick but a step towards creating safer and more reliable AI systems. So next time you see an AI confidently misclassifying a human as a pizza, remember: it’s all part of the fascinating game of outsmarting the smart.</p><h4><strong><em>References:</em></strong></h4><ol><li><a href="https://www.tensorflow.org/tutorials/generative/adversarial_fgsm"><em>https://www.tensorflow.org/tutorials/generative/adversarial_fgsm</em></a></li><li><a href="https://arxiv.org/abs/1412.6572"><em>https://arxiv.org/abs/1412.6572</em></a></li></ol><h3>In Plain English 🚀</h3><p><em>Thank you for being a part of the </em><a href="https://plainenglish.io/"><strong><em>In Plain English</em></strong></a><em> community! Before you go:</em></p><ul><li>Be sure to <strong>clap</strong> and <strong>follow</strong> the writer ️👏<strong>️️</strong></li><li>Follow us: <a href="https://twitter.com/inPlainEngHQ"><strong>X</strong></a> | <a href="https://www.linkedin.com/company/inplainenglish/"><strong>LinkedIn</strong></a> | <a href="https://www.youtube.com/channel/UCtipWUghju290NWcn8jhyAw"><strong>YouTube</strong></a> | <a href="https://discord.gg/in-plain-english-709094664682340443"><strong>Discord</strong></a> | <a href="https://newsletter.plainenglish.io/"><strong>Newsletter</strong></a></li><li>Visit our other platforms: <a href="https://cofeed.app/"><strong>CoFeed</strong></a> | <a href="https://differ.blog/"><strong>Differ</strong></a></li><li>More content at <a href="https://plainenglish.io/"><strong>PlainEnglish.io</strong></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66002e29e582" width="1" height="1" alt=""><hr><p><a href="https://python.plainenglish.io/how-to-outsmart-ai-the-fun-trick-behind-the-fast-gradient-sign-method-fgsm-66002e29e582">How to Outsmart AI: The Fun Trick Behind the Fast Gradient Sign Method (FGSM)</a> was originally published in <a href="https://python.plainenglish.io/">Python in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[If You Don’t do this today, AI Will Take Over the World!]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@rohanjhanepal/if-you-dont-do-this-today-ai-will-take-over-the-world-86e94d534221?source=rss-6dc7aefb0cc4------2"><img src="https://cdn-images-1.medium.com/max/1152/1*_YofKEh0OIAPB-65TWeRmA.png" width="1152"></a></p><p class="medium-feed-snippet">AI has taken the world by storm with technological advancement in the last decade. With the evolution of transformer models such as&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@rohanjhanepal/if-you-dont-do-this-today-ai-will-take-over-the-world-86e94d534221?source=rss-6dc7aefb0cc4------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@rohanjhanepal/if-you-dont-do-this-today-ai-will-take-over-the-world-86e94d534221?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/86e94d534221</guid>
            <category><![CDATA[human-aligned-ai]]></category>
            <category><![CDATA[microsoft-attack]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Sun, 21 Jul 2024 07:57:20 GMT</pubDate>
            <atom:updated>2024-07-21T07:57:20.064Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Roadmap to become ML / MLOps/Data Engineer]]></title>
            <link>https://medium.com/@rohanjhanepal/roadmap-to-become-ml-mlops-data-engineer-cbe9ab11be0e?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/cbe9ab11be0e</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[roadmaps]]></category>
            <category><![CDATA[mlops]]></category>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Wed, 06 Mar 2024 11:01:35 GMT</pubDate>
            <atom:updated>2024-03-06T11:01:35.407Z</atom:updated>
            <content:encoded><![CDATA[<p>MLOps, short for Machine Learning Operations, refers to the practice of combining Machine Learning (ML) and DevOps to standardize and streamline the end-to-end ML lifecycle. Data Engineering is primarily concerned with the provisioning, management, and scalability of data infrastructure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*JUvWui2v0lnzv2mep3AYrg.png" /></figure><h3>1. Basics</h3><ul><li>Databases (Relational and Non-Relational)</li><li>Basics of distributed systems</li><li>Python</li><li>Basics of Linear algebra</li><li>Basics of Calculus</li><li>Basics of Statistics</li></ul><h3>2. Basics of ML / Data Engineering</h3><ul><li>Concept of Supervised, Unsupervised and Reinforcement Learning</li><li>Model evaluation metrics</li><li>ETL processes and workflow</li><li>Data warehousing, data lakes</li><li>Distributed computing</li><li>Weights &amp; Biases</li></ul><h3>3. Basics of Devops</h3><ul><li><strong>Continuous Integration (CI)</strong> adds data and models for testing and validating to the testing and validating code and components.</li><li><strong>Continuous Delivery (CD)</strong> challenges with the delivery of an ML training pipeline that installs another ML model prediction service automatically.</li><li><strong>Continuous Training (CT)</strong> is a property unique to machine learning systems that automatically retrain ML models for re-deployment.</li><li><strong>Continuous Monitoring (CM)</strong> concerns the monitoring of production data and model performance measures that are tied to business metrics.</li></ul><h3>4. ML and Deep Learning Concepts</h3><ul><li><strong>Ml algorithms</strong></li><li>Linear and logistic regression models</li><li>Decision Tree</li><li>Naive Bayes</li><li>K-Nearest Neighbors</li><li>Market Basket analysis</li><li>Support Vector machines</li><li>Random Forest</li><li>Gradient Boosting</li><li>Word2Vec</li><li><strong>Deep Learning</strong></li><li>Basics of Neural networks</li><li>Optimization methods such as Gradient Descent</li><li>Convolutional Neural networks</li><li>Recurrent neural networks</li><li>LSTM and Transformers</li><li>Generative models such as Generative Adversarial Neural Networks</li></ul><h3>5. Tools</h3><ul><li><strong>Libraries</strong></li><li>Numpy</li><li>Matplotlib</li><li>Pandas</li><li>Sklearn</li><li>Tensorflow / Keras / Pytorch (<em>optional</em>)</li><li>Dask</li><li>AWS Sagemaker / Google Colab</li><li>Hadoop</li></ul><h3>6. Data Management:</h3><ul><li><strong>Data Pipelines &amp; Orchestration</strong>:</li><li>Apache Airflow,</li><li>Luigi</li><li><strong>Data Storage (</strong><em>No need if already gone through in basics section</em><strong>)</strong>:</li><li>Relational Databases,</li><li>NoSQL databases,</li><li>Data Lakes (e.g., Hadoop, Spark)</li><li><strong>Data Versioning</strong>:</li><li>DVC</li><li>Delta Lake</li><li>Data Streaming</li><li>Apache Kafka</li><li>Spark</li><li>Querying</li><li>ELK</li><li>SQL</li><li>Data Visualization</li><li>QuickSight</li><li>BI tools</li></ul><h3>7. Model Development &amp; Validation:</h3><ul><li><strong>Version Control</strong>:</li><li>Git,</li><li>MLflow</li><li><strong>Experiment Tracking</strong>:</li><li>MLflow, <br>Weights &amp; Biases,</li><li>TensorBoard</li><li><strong>Model Testing</strong>:</li><li>Automated testing for models and data pipelines</li></ul><h3>8. Model Training &amp; Tuning:</h3><ul><li><strong>Pipeline Orchestration</strong>:</li><li>Kubeflow Pipelines, TFX</li><li><strong>Distributed Processing &amp; Training</strong>:</li><li>Apache Spark for data processing,</li><li>Horovod for ML</li><li><strong>Hyperparameter Optimization</strong>:</li><li>Optuna,</li><li>Ray Tune</li></ul><h3>9. Continuous Integration &amp; Deployment:</h3><ul><li><strong>CI/CD for Data Pipelines</strong>:</li><li>Automated testing, validation, and deployment of ETL jobs</li><li><strong>CI/CD for ML</strong>:</li><li>Automated model retraining, validation, and deployment</li></ul><h3>10. Monitoring and Maintenance:</h3><ul><li><strong>Data Monitoring</strong>:</li><li>Data quality checks,</li><li>anomaly detection</li><li><strong>Model Monitoring</strong>:</li><li>Performance tracking</li><li>drift detection</li><li><strong>Logging &amp; Observability (</strong><em>pick one</em><strong>)</strong>:</li><li>ELK stack</li><li>Grafana</li><li>Prometheus</li></ul><h3>11. Governance &amp; Compliance:</h3><ul><li><strong>Data Governance</strong>:</li><li>Metadata management, data cataloging</li><li><strong>ML Model Governance</strong>:</li><li>Model interpretability, audit trails</li><li><strong>Security &amp; Privacy</strong>:</li><li>Data access controls, data encryption, differential privacy</li></ul><h3>12. Scalability &amp; Optimization:</h3><ul><li><strong>Data Pipeline Optimization</strong>:</li><li>Streamlining ETL processes,</li><li>real-time data processing (e.g., Kafka)</li><li><strong>Model Optimization</strong>:</li><li>Quantization,</li><li>pruning,</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cbe9ab11be0e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Instrumenting Django Application using AWS X-RAY]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@rohanjhanepal/instrumenting-django-application-using-aws-x-ray-fbb89dd1a1b7?source=rss-6dc7aefb0cc4------2"><img src="https://cdn-images-1.medium.com/max/600/1*-heNtXkhrudGPPWLWIfpwA.png" width="600"></a></p><p class="medium-feed-snippet">Trace Map for django</p><p class="medium-feed-link"><a href="https://medium.com/@rohanjhanepal/instrumenting-django-application-using-aws-x-ray-fbb89dd1a1b7?source=rss-6dc7aefb0cc4------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@rohanjhanepal/instrumenting-django-application-using-aws-x-ray-fbb89dd1a1b7?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/fbb89dd1a1b7</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[opentelemetry]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[aws-x-ray]]></category>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Wed, 06 Mar 2024 10:51:25 GMT</pubDate>
            <atom:updated>2024-07-14T21:22:06.355Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Unveiling the Magic behind LLMs: How Does a Large Language Model Work ? ]]></title>
            <link>https://medium.com/@rohanjhanepal/unveiling-the-magic-behind-llms-how-does-a-large-language-model-work-9d7d6c1399c5?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d7d6c1399c5</guid>
            <category><![CDATA[gpt]]></category>
            <category><![CDATA[gemini]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[large-language-models]]></category>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Sat, 13 Jan 2024 10:20:19 GMT</pubDate>
            <atom:updated>2024-01-13T11:01:13.034Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unveiling the Magic behind LLMs: How Does a Large Language Model Work ? 🤔</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e4yW3MK4QTtyr9N_RrqtPg.png" /><figcaption>LLM illustration</figcaption></figure><p>Large Language Models (LLMs) have take the world with a storm and the reason are obvious. If somebody told me 10 years ago that we would have our very own Jarvis (from Iron man) at palm of our hands in next 10 years, my response would have been, “It might take much longer than that and this tech is pure fiction and magic”, and in fact the technology responsible for LLMs still seems to be not less than a wild magic trick. But it’s simply science, math and a lot of data.</p><h3><strong>But what is a LLM?</strong></h3><p>A Large Language Model (LLM) refers to a type of artificial intelligence model that is specifically designed for natural language processing tasks that are characterized by their ability to understand and generate human-like text at a large scale.</p><p>One of the notable features of LLMs is their capacity to handle vast amounts of data and parameters, allowing them to capture intricate patterns and relationships within language.</p><p>For Instance: Open AI’s Chat-GPT 4 is a large language model and so is Google’s Bard</p><h3>How does it work? 🤔</h3><h4>The Foundation: Neural Networks 🧠</h4><p>At the core of Large Language Models lies the neural network architecture. Inspired by the human brain, these artificial neural networks consist of interconnected nodes, or neurons, organized in layers. Each layer processes information and passes it along, contributing to the model’s ability to understand and generate language.</p><h4>Training with Massive Datasets 👟</h4><p>The magic begins with data — colossal amounts of it. LLMs, like OpenAI’s Chat-GPT 4 and Google’s Bard, are trained on diverse and extensive datasets that encompass a wide range of linguistic patterns, contexts, and nuances. The model learns from this vast sea of information, identifying associations, syntax, and semantic meanings.</p><h4><strong>Embedding and Representation 📈</strong></h4><p>To make sense of language, the model converts words into numerical vectors through a process called embedding. These numerical representations capture the semantic relationships between words. Imagine it as the model assigning coordinates to words in a high-dimensional space, enabling it to understand the context and meaning of each word.</p><h4><strong>Attention Mechanism ⚠️</strong></h4><p>One key innovation in recent LLMs is the attention mechanism. Inspired by human attention, this mechanism allows the model to focus on specific parts of the input text while generating an output. It helps the model consider relevant context, improving its ability to generate coherent and contextually appropriate responses.</p><h4><strong>Fine-Tuning and Optimization 🔧</strong></h4><p>The initial training is just the beginning. LLMs undergo fine-tuning to adapt to specific tasks or domains. This involves exposing the model to more targeted datasets, refining its performance for specialized applications. The optimization process ensures the model’s adaptability to various language tasks, from translation to question-answering.</p><h4>Decoding and Generation 🔍</h4><p>When it comes to generating text, LLMs employ a decoding process. Given an <strong>input </strong>prompt, the model uses its learned knowledge to <strong>predict </strong>the next sequence of words, crafting coherent and contextually relevant responses. This generation process is where the magic unfolds, as the model seamlessly weaves together words, creating human-like text.</p><h3>Ethical considerations and challenges 🧗🏼</h3><p>Although LLMs presents amazing capabilities, there are concerns associated with their use. Concerns about biased outputs, misinformation amplification, and the environmental impact of training large models are pressing issues that demand attention in the development and deployment of these systems.</p><p>It is to be noted that this is just a high level overview of how LLMs work. Behind the scene it’s all magic 😄, nah just kidding, mostly it’s math and data. If you got some insight from the blog, leave some claps 👏 for me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d7d6c1399c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Harnessing JIRA Boards in Python for Enhanced Project Management]]></title>
            <link>https://medium.com/@rohanjhanepal/harnessing-jira-boards-in-python-for-enhanced-project-management-10385a804b32?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/10385a804b32</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[jira]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[project-management]]></category>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Mon, 18 Dec 2023 04:30:17 GMT</pubDate>
            <atom:updated>2023-12-18T04:30:17.321Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e1rdqormqAikPq95AsVeZA.png" /><figcaption>Python With Jira Illustration</figcaption></figure><p>In today’s fast-paced software development world, efficient project management is key to delivering successful products. Atlassian’s JIRA is a powerful tool used by teams for tracking tasks, and bugs, and managing agile software development projects. But did you know that you can harness the capabilities of JIRA directly from your Python applications? This integration opens up a myriad of possibilities, from automating tasks to generating reports and more.</p><p>This comprehensive guide delves into the specifics of accessing JIRA boards using Python. Whether you’re a developer, a project manager, or just someone keen on automating their workflow, you’ll find valuable insights in this exploration. We’ll cover everything from setting up your environment and authenticating your Python application with JIRA, to performing various operations on JIRA boards. We aim to equip you with the knowledge and tools you need to seamlessly integrate JIRA’s robust project management features into your Python-based tools and workflows.</p><h3>1. Setting up Jira board</h3><p>a. Make a free account at <a href="https://www.atlassian.com/">Collaboration software for software, IT and business teams</a></p><p>b. Setup a new project if not already by Projects → Create Project → Kabana , let’s name the project jira-test , you will get key as JT .</p><p>c. You will see the following board, configure it if you want, I will go ahead with the default.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*muf5e6io1p9KFyqefCEh0w.png" /><figcaption>Jira board</figcaption></figure><p>d. <strong>For the API Tokens</strong>, Click on your profile logo on the top-right corner → Manage Account → Security → Create and manage API tokens → Create API token , then give a Label, copy the token and store it securely for now.</p><p>e. Create an issue in your board JT and place in <strong>To Do </strong>for now.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1017/1*Vi_8IfAAmPGb9BN3QDY0oA.png" /></figure><p>f. Note issue id, for this it is, <strong>JT-1 </strong>.</p><p>g. Few parameters you need to know:</p><p>api_key that you got earlier in step 1.d.</p><p>user_name is the email you used to sign up, for example: test@gmail.com</p><p>issue_id is JT-1 for above case, which is is id of ticket</p><p>YOUR_JIRA_INSTANCE can be seen at url bar when you are on your board, in image below myinstance is youe Jira instance</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/1*IgyIN_cInpoSwa_BIHm18w.png" /></figure><p>h. For each of Jira board’s status we need their unique transaction id; for which, we can do curl as:</p><p>curl -u &lt;user_name&gt;:&lt;api_key&gt; -X GET &quot;https://&lt;YOUR_JIRA_INSTANCE&gt;.atlassian.net/rest/api/3/issue/&lt;issue_id&gt;/transitions&quot;</p><p>You can beautify the response json using json beautifiers found online.</p><p>For every transition, note id , for example, &quot;transitions&quot;:[{&quot;id&quot;:&quot;11&quot;,&quot;name&quot;:&quot;To Do&quot; ..... , note this id and name for all statuses or transitions.</p><h3>2. Accessing Jira using python</h3><p>a. We need to import a few packages</p><pre>import json<br>import requests<br>from requests.auth import HTTPBasicAuth #to authenticate with jirap</pre><p>b . Store your Jira’s instance , board ID and API token into a variable. (Note: for actual production, always store these parameters securely in the environment file, and not in the code) .</p><p>For BOARD, make a dictionary and store name and id as below, name and id will be from step<strong> 1.h </strong>, JIRA_INSTANCE from <strong>1.g</strong>, and api_key from <strong>1.d</strong> .</p><pre>JIRA_INSTANCE = &quot;&lt;your_instance&gt;.atlassian.net&quot;<br><br>#change name and id accordingly<br>BOARD = { <br>        &quot;&lt;key&gt;&quot;: &lt;id&gt;, <br>        &quot;&lt;key&gt;&quot;: &lt;id&gt;, <br>        &quot;todo&quot;: 11, #this is example<br>}<br><br>api_token = &quot;&lt;your_api_token&gt;&quot;<br><br>user = &#39;&lt;your_username&gt;&#39; #from step 1.g<br><br>headers = {<br>    &#39;Content-Type&#39;: &#39;application/json&#39;,<br>}</pre><p>c. Authenticate with Jira’s API</p><pre>auth = HTTPBasicAuth(user, api_token)</pre><p>d. See <strong>details </strong>of a <strong>Jira issue</strong>, we need the issue id that we noted as JT-1 in step 1.f</p><pre>issue_key = &#39;JT-1&#39; #from step 1.f<br>api_url= f&#39;https://{JIRA_INSTANCE}/rest/api/3/issue/{issue_key}&#39;<br>response = requests.get(api_url, auth=auth, headers=headers)<br>if response.status_code == 200:<br>  issue_details = response.json()<br>  print(issue_details)<br>  issue_key = issue_details[&#39;key&#39;]<br>  summary = issue_details[&#39;fields&#39;][&#39;summary&#39;]<br>  description = issue_details[&#39;fields&#39;][&#39;description&#39;]<br>  print(description) #prints description of the issue</pre><p>e. Move issue from one status to another:</p><pre>issue_key = &#39;JT-1&#39; #from step 1.f<br>api_url = f&#39;https://{JIRA_INSTANCE}/rest/api/3/issue/{issue_key}/transitions&#39;<br>headers = {&#39;Accept&#39;: &#39;application/json&#39;,<br>               &#39;Content-Type&#39;: &#39;application/json&#39;}<br>transition_data = {<br>        &#39;transition&#39;: {&#39;id&#39;: BOARD[&#39;key for the id of status you want to transion&#39;]}<br>}<br>response = requests.post(api_url, data=json.dumps(transition_data), headers=headers, auth=auth)<br>    <br>if response.status_code == 204:<br>  print(f&#39;Status changed successfully for issue {issue_key}&#39;)<br>else:<br>  print(f&#39;Failed to change status. Status code: {response.status_code}, Response: {response.text}&#39;)</pre><p>f. Add a comment on the issue:</p><pre>issue_key = &#39;JT-1&#39; #from step 1.f<br>message = &quot;this is a message from python&quot;<br>api_url = f&#39;https://{JIRA_INSTANCE}/rest/api/3/issue/{issue_key}/comment&#39;<br><br>headers = {&#39;Accept&#39;: &#39;application/json&#39;,<br>               &#39;Content-Type&#39;: &#39;application/json&#39;}<br><br>payload = json.dumps(<br>        {<br>            &#39;body&#39;: {<br>               &#39;content&#39;: [<br>                    {<br>                        &#39;content&#39;: [{&#39;text&#39;: f&quot;Server: &quot;, &#39;type&#39;: &#39;text&#39;, &#39;marks&#39;: [{&#39;type&#39;: &#39;strong&#39;}]},<br>                                    {&#39;text&#39;: message, &#39;type&#39;: &#39;text&#39;}],<br>                        &#39;type&#39;: &#39;paragraph&#39;,<br>                    }<br>                ],<br>                &#39;type&#39;: &#39;doc&#39;,<br>                &#39;version&#39;: 1,<br>            }<br>        }<br>    )<br><br>response = requests.request(<br>        &#39;POST&#39;, api_url, data=payload, headers=headers, auth=auth<br>    )</pre><h3>3. Conclusion</h3><p>As we wrap up this insightful journey into integrating Python with JIRA, it’s clear that the synergy between these powerful tools can significantly enhance project management and workflow automation. By leveraging Python’s versatility and JIRA’s robust tracking capabilities, we can create more efficient, automated, and streamlined processes. As you venture forward, keep experimenting with different aspects of the JIRA API, and Python’s vast libraries and frameworks. The more you explore, the more you’ll uncover the potential to make your and your team’s life easier and your projects more successful.</p><p><strong>Please do leave some claps 👏👏, if the article was helpful to you.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10385a804b32" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Asynchronous Tasks with Django, Celery and SQS]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@rohanjhanepal/asynchronous-tasks-with-django-celery-and-sqs-9fc0b0c8c26?source=rss-6dc7aefb0cc4------2"><img src="https://cdn-images-1.medium.com/max/2600/1*Mr7f04uGfPtDYXar2-hHaQ.png" width="6912"></a></p><p class="medium-feed-snippet">Celery Django and SQS</p><p class="medium-feed-link"><a href="https://medium.com/@rohanjhanepal/asynchronous-tasks-with-django-celery-and-sqs-9fc0b0c8c26?source=rss-6dc7aefb0cc4------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@rohanjhanepal/asynchronous-tasks-with-django-celery-and-sqs-9fc0b0c8c26?source=rss-6dc7aefb0cc4------2</link>
            <guid isPermaLink="false">https://medium.com/p/9fc0b0c8c26</guid>
            <category><![CDATA[aws-sqs]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[celery]]></category>
            <dc:creator><![CDATA[Rohan Jha]]></dc:creator>
            <pubDate>Mon, 25 Sep 2023 13:16:30 GMT</pubDate>
            <atom:updated>2024-07-14T21:22:28.765Z</atom:updated>
        </item>
    </channel>
</rss>