<?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 Kunal Mitra on Medium]]></title>
        <description><![CDATA[Stories by Kunal Mitra on Medium]]></description>
        <link>https://medium.com/@kunalmitra00?source=rss-33acb38aa5b5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*eaCMLsl_6rSH_iXB.jpg</url>
            <title>Stories by Kunal Mitra on Medium</title>
            <link>https://medium.com/@kunalmitra00?source=rss-33acb38aa5b5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 20:30:45 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kunalmitra00/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 chatbot during my Internship @Deutsche Telekom]]></title>
            <link>https://blog.dtdl.in/building-chatbot-during-my-internship-deutsche-telekom-4fd9c6b538?source=rss-33acb38aa5b5------2</link>
            <guid isPermaLink="false">https://medium.com/p/4fd9c6b538</guid>
            <dc:creator><![CDATA[Kunal Mitra]]></dc:creator>
            <pubDate>Tue, 14 Jul 2020 12:17:13 GMT</pubDate>
            <atom:updated>2020-07-14T12:17:13.215Z</atom:updated>
            <content:encoded><![CDATA[<p>The major problem that we worked on during this internship was to build a model for developing a chatbot for customer care service that can identify the intent of the customer query,i.e, what the user wants with his/her query. For example, a user may ask “<strong><em>What is the bill for this month for my internet use?</em></strong>”, the intent of this query would be something like <strong>“Bill amount”</strong> and another could be “<strong><em>What are the new offers for recharge?</em></strong>”, the intent of this query would be something to present as <strong>“New Offers”</strong>. So, our task was to classify these intents of the customer query and then we could act accordingly for generating a response.</p><p>I would like to take you through the details of how we broke our whole problem into small pieces so that this whole task does not feel daunting and how we focussed on one thing at a time to make this whole process less challenging and feasible.</p><h4><strong>Data Collection and Cleaning</strong></h4><p>Without data, there is no Machine Learning. So, as all ML/DL projects, we first mainly focus on collecting adequate amounts of labelled data which would be useful for our use-case to work upon. It was not an easy task due to the existence of many types of chatbots, for instance, a chatbot for messaging as used by companies like Hike etc. to make random general conversations with people. These chatbots require a different task totally, they are not based on intent classification, rather they are based on learning how to produce sentences as a reply.</p><p>Also, another challenge in finding suitable data was that customer care companies do not open-source their data to be available on the internet for free because it has some private details of the customers.</p><p>So, after more than 4 days of surfing over google for an appropriate dataset, we were able to find some useful datasets from the following sources:</p><ol><li><a href="https://www.kaggle.com/hassanamin/atis-airlinetravelinformationsystem">https://www.kaggle.com/hassanamin/atis-airlinetravelinformationsystem</a></li><li><a href="https://github.com/clinc/oos-eval">https://github.com/clinc/oos-eva</a></li><li><a href="https://www.kaggle.com/stefanlarson/outofscope-intent-classification-dataset">https://www.kaggle.com/stefanlarson/outofscope-intent-classification-dataset</a></li></ol><p>We then chose the second dataset in this list which consisted around 25000 queries with 150 different intent classes and an out of scope intent that signified that it was something totally different. It was a big enough dataset and suited our needs perfectly.</p><p>After we had our dataset, we cleaned it to make it suitable for our use. The cleaning process included deleting the queries which had no labels or labels which were not in those 150 classes due to some typing error or some other error when the data set was created and then it included:</p><ul><li>removing stop words using <strong>nltk.corpus</strong> library</li><li>lemmatization using <strong>nltk.WordNetLemmatizer </strong>library</li><li>removing non-word characters( eg. $,#,% etc) using <strong>RegEx</strong> module</li><li>creating a vocabulary out of them with a particular index for each word</li><li>The dataset was then divided into a training(20000 queries) and test set(5000 queries).</li></ul><h4><strong>Building Deep Learning Models</strong></h4><p>It was time to move onward to building the classification models and train them on the training dataset. But first we required some pre processing of the data because machine learning requires real numbers rather than strings.</p><p>So, we used word embeddings and tried training our own embeddings as well as use pre-trained <strong>Glove vectors</strong>( <a href="https://nlp.stanford.edu/projects/glove/">https://nlp.stanford.edu/projects/glove/</a> ) in different models to compare them. We built various models with some changes in architecture and tuned the hyper-parameters for every model with the main part of every model being the <strong>Long-short-term-memory (LSTM) </strong>layer. <strong>Tensorflow</strong> and <strong>Keras</strong> were used to build and train the models.</p><p>This iterative process of gradually improving test accuracy can be explained by this graph given below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/387/1*xVzZ52S6mixt8ExxFvtwSQ.png" /><figcaption><strong>The process of improving models day by day</strong></figcaption></figure><h4><strong>Analyzing the Results and Deciding the Best Model</strong></h4><p>We compared the accuracy results on the test set for every model and found that some architectures work better than others for our use-case. The best model gave us an amazing 94% accuracy on the test set.</p><blockquote><strong>INSIGHTS FROM THE RESULTS</strong></blockquote><blockquote><em>Pre-trained embeddings always gave better results. It was due to the fact that they had been trained on millions of sentences, so they had the power to generalize over the test set. Our training dataset was too small to learn highly powerful embeddings.</em></blockquote><blockquote><em>Bidirectional LSTM layers always worked better than unidirectional ones because they have the benefit of generating the results from the forward context as well as backward context.</em></blockquote><p><strong>ARCHITECTURE OF THE BEST MODEL</strong></p><p>After two weeks of training different models and evaluating their performances, we had a model ready which gave excellent results. It used pre-trained <strong>Elmo Embeddings</strong> with <strong>Bidirectional LSTM</strong> layers with <strong>Dropout regularization</strong> and finally giving a softmax output. This model prevented overfitting to a very high extent and was able to generalize really well over the test set.</p><p>Elmo Embeddings can be loaded with one line of code, thanks to <strong>TF-hub</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/496/1*D94dt1X-7mdEpO2BphD79Q.png" /><figcaption><strong>Code to load elmo embeddings from tensorflow-hub</strong></figcaption></figure><p>And with Keras, we can easily make deep learning models.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*2fbBbznrfrv7vag7jNFgGQ.png" /><figcaption><strong>Code for the best model that we used</strong></figcaption></figure><p>Training time : ~ <strong>30 mins</strong> per epoch on CPU (around 1 min on GPU)<br>Epochs iterated : <strong>15<br></strong>Training set accuracy achieved : <strong>98%<br></strong>Test set accuracy achieved:<strong> 94%</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/386/1*EuKipFvrpyybESdfCP-npQ.png" /><figcaption><strong>Training &amp; Validation Accuracy vs Epochs/time</strong></figcaption></figure><h4><strong>Deployment of the model as a REST API</strong></h4><p>We collected data, cleaned it, preprocessed it for use and trained and saved a good enough model for our use. But there was still one problem. It could only be used on our own PC running the python file in console or jupyter notebooks. So, the question that was there in front of us was how could we make it available for use by general users on the internet. So, one easy and quickly available solution was to make a REST API which used our saved and trained model which would take a query as an input and give us the intent. This included pipelines for both preprocessing the query and producing the intent. So, now any developer building a chatbot without knowing anything about ML would be able to just use our REST API through HTTP requests for getting the intent of the query and act accordingly to generate response.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*6vVq3KgPJMOUMpfxqyOMDA.png" /><figcaption><strong>Formats and the structure of requests to the HTTP server</strong></figcaption></figure><h4><strong>Further Study to make it suitable for Production in real-life</strong></h4><p>Nowadays, most of the data analyzing and data oriented tasks use <strong>Lambda Architecture</strong> which combines the batch processing and stream processing tasks to maintain good results on the running application in real time for the user. <strong>Apache Spark</strong> has been widely favoured for this purpose since it quite efficiently makes use of distributed programming and has supported libraries for the stream processing softwares available in the market. As our model was totally based on Tensorflow and Keras, I looked for the ways to integrate Tensorflow for use in such an architecture and after heavy research on the topic, I found various insights on how to use Tensorflow over a distributed environment and how to perform streaming tasks with it. The details can be found on this article posted by me on the medium platform. <a href="https://medium.com/@kunalmitra00/lambda-architecture-with-spark-and-how-it-can-be-used-with-tensorflow-for-deep-learning-models-81f3b92b4856">https://medium.com/@kunalmitra00/lambda-architecture-with-spark-and-how-it-can-be-used-with-tensorflow-for-deep-learning-models-81f3b92b4856</a><br>Basically why we need such a thing in production is because when put to use, our model is bound to make mistakes as the time goes by because not all people will ask the same query in the same way or some new intents that we haven’t considered initially were discovered which we would like to integrate into our model, so we’ll need to monitor the use of our model and we will then focus on improving it as much as we can.</p><h4><strong>Summarizing my experience</strong></h4><p>By the end of the internship, we were able to create a robust classifier which, given a query, provides you with the intent of that query so that you could generate accurate responses to the user without any human interference and thus, reducing the need for human resources saving the cost of the company in that area and also making the customer service available 24/7 to the users. By creating a REST API, we made it easy for developers with non-ML background to create apps which could use it directly in one line of code and then integrate this in the web application to build a chatbot.</p><p>Further improvements and innovations can be implemented to extend this project into a more robust, more accurate or a more diverse model. We can implement a Named Entity Recognition task on the queries to recognize particular entities that the user asks for. For eg, if a user asks, “How can i get the information about the new offers?”, the model would identify intent as ‘giving information’ and the named entity will be ‘new offers’. Also, we can use the BERT and related transformer models to achieve more accuracy as they are the best presently but one major downside with them is that all these models need a huge amount of memory and also, heavy GPUs for training.</p><p>In the end, I would just like to thank Deutsche Telekom for such an amazing opportunity and for always supporting me and making me feel like a part of the team even though it was a remote internship. I would also like to thank the HR and the Leadership team for being always there to help me out in any problem and always pushing to bring out the best in me. It was an experience which made me learn how everything actually works outside in the real world and I will cherish this throughout my life.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4fd9c6b538" width="1" height="1" alt=""><hr><p><a href="https://blog.dtdl.in/building-chatbot-during-my-internship-deutsche-telekom-4fd9c6b538">Building chatbot during my Internship @Deutsche Telekom</a> was originally published in <a href="https://blog.dtdl.in/">Deutsche Telekom Digital Labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lambda Architecture with Spark and How it can be used with Tensorflow for Deep Learning Models]]></title>
            <link>https://medium.com/@kunalmitra00/lambda-architecture-with-spark-and-how-it-can-be-used-with-tensorflow-for-deep-learning-models-81f3b92b4856?source=rss-33acb38aa5b5------2</link>
            <guid isPermaLink="false">https://medium.com/p/81f3b92b4856</guid>
            <dc:creator><![CDATA[Kunal Mitra]]></dc:creator>
            <pubDate>Sat, 30 May 2020 08:46:44 GMT</pubDate>
            <atom:updated>2020-05-30T08:46:44.177Z</atom:updated>
            <content:encoded><![CDATA[<p>With new developments in technology in the world of data and uprising of Internet of Things, and growth of computation power, there came the availability of large amounts of data to make use of to improve the world. However it came with many problems like how to store such huge amounts of data. The problem of storing this ‘Big Data’ was solved by using Cloud Storage and Distributed File Systems. Another problem which came with data coming at great rates was that the results computed using this data were prone to latency, i.e computation of data took time and so, before the results were updated, more data had already came in changing these results now. This caused very high latency in the results and data. So, to solve this problem, emerged the idea of Lambda Architecture. It helps to bring this latency down by huge extent and many modern companies use this idea to manage the data coming from their websites and apps.</p><p>In this article, I would give a brief description about Lamda Architecture, what is it, how it works, why should we use it and some challenges that it still faces. Then I would tell about the tools available in the market to help build such an architecture. I would also throw some light on the use of Spark and Tensorflow in developing such an architecture. Tensorflow was not compatible for use in production some time back but recent developments in Tensorflow has made it possible for complex deep learning models to be deployed in such architectures. We need deep learning models because they provide state of the art accuracy in the fields of NLP and Computer Vision and complex machine learning tasks. Although use of tensorflow for such tasks is very uncommon right now but recent developments can prove to be of huge importance in future.</p><h3><strong>What is Lambda Architecture?</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*Bhvv5TnzS0UCL_GzB9ErYw.jpeg" /></figure><p>Lambda architecture is a way of processing massive quantities of data (i.e. “Big Data”) that provides access to batch-processing and stream-processing methods with a hybrid approach. Lambda architecture is used to solve the problem of computing arbitrary functions. The lambda architecture itself is composed of 3 layers:</p><ul><li><strong>BATCH LAYER</strong><br>New data comes continuously, as a feed to the data system. It gets fed to the batch layer and the speed layer simultaneously. It looks at all the data at once and eventually corrects the data in the stream layer. Here we can find lots of ETL and a traditional data warehouse. This layer is built using a predefined schedule, usually once or twice a day. The batch layer has two very important functions:<br>- To manage the master dataset<br>- To pre-compute the batch views</li><li><strong>SPEED LAYER/STREAMING LAYER/REAL-TIME LAYER<br> </strong>This layer handles the data that are not already delivered in the batch view due to the latency of the batch layer. In addition, it only deals with recent data in order to provide a complete view of the data to the user by creating real-time views.</li><li><strong>SERVING LAYER</strong><br> The outputs from the batch layer in the form of batch views and those coming from the speed layer in the form of near real-time views get forwarded to the serving. This layer indexes the batch views so that they can be queried in low-latency on an ad-hoc basis.<br> In simple words, this is the layer responsible to show the outputs to user queries. It contains results coming from both the layers and then use them to compute the required result.</li></ul><h3><strong>A simple example for understanding</strong></h3><p>Lets say, we are keeping the track of shares of a user. We take up batch processing of all the data available every 12 hours and real time streaming happens on the data every 1 hour.<br>Lets say, at time t0 , the last batch processing has been finished and the user has 5000 shares of a company. We maintain 1 batch view, 2 real time view.<br>Initially now, batch table(BT) stores 5000, Real time table 1(RT1) stores 0, Real time table 2(RT2) stores 5000(correct up to date value).<br>Now in the next 1 hour, the user sells 1000 shares. So, now<br>- BT stores 5000<br>- RT1 stores -1000 (delta between t0 and t0+1)<br>- RT2 stores 4000 (RT2+RT1, the actual amount of shares now)<br>Now we make RT1 0 again and keep doing the same process again. Now RT1 will store delta between t0+1 and t0+2.<br>And finally after 12 hours, the batch processing takes place on the whole data.</p><h3><strong>ADVANTAGES OF LAMBDA ARCHITECTURE</strong></h3><ul><li>Tolerance to human errors</li><li>· Tolerance to hardware crashes</li><li>· Scalability and quick response time</li><li>· React in real-time to changing business/market scenarios</li></ul><h3><strong>CHALLENGES TO LAMBDA ARCHITECTURE</strong></h3><ul><li>Lambda architectures can be highly complex. Administrators must typically maintain two separate code bases for batch and streaming layers, which can make debugging difficult.</li><li>Most of the times, the operations in real time and batch processing are quite similar. So, the same operations on same set of data occur multiple times.</li></ul><h3><strong>PREREQUISITE SOFTWARES</strong></h3><ul><li><strong>Apache Kafka</strong> : Apache Kafka is a distributed data store optimized for ingesting and processing streaming data in real-time. Streaming data is data that is continuously generated by thousands of data sources, which typically send the data records in simultaneously. A streaming platform needs to handle this constant influx of data, and process the data sequentially and incrementally.<br> Kafka provides three main functions to its users:<br>- Publish and subscribe to streams of records<br>- Effectively store streams of records in the order in which records were <br> generated<br>- Process streams of records in real time</li><li><strong>Apache Spark </strong>: <a href="https://spark.apache.org/">Apache Spark</a> is a data processing framework that can quickly perform processing tasks on very large data sets, and can also distribute data processing tasks across multiple computers, either on its own or in tandem with other distributed computing tools. These two qualities are key to the worlds of big data and machine learning, which require the marshalling of massive computing power to crunch through large data stores. Spark also takes some of the programming burdens of these tasks off the shoulders of developers with an easy-to-use API that abstracts away much of the grunt work of distributed computing and big data processing.</li><li><strong>Spark Streaming </strong>: Spark Streaming is an extension of the core Spark API that enables scalable, high-throughput, fault-tolerant stream processing of live data streams. Data can be ingested from many sources like Kafka, Flume, Kinesis, or TCP sockets, and can be processed using complex algorithms expressed with high-level functions like map, reduce, join and window. Finally, processed data can be pushed out to filesystems, databases, and live dashboards. In fact, you can apply Spark’s <a href="https://spark.apache.org/docs/latest/ml-guide.html">machine learning</a> and <a href="https://spark.apache.org/docs/latest/graphx-programming-guide.html">graph processing</a> algorithms on data streams.</li><li><strong>Tensorflow </strong>: TensorFlow is an open source Deep Learning library developed by Google that is used to perform complex numerical operations and several other tasks to model Deep Learning models. It’s architecture allows easy deployment of computations across multiple platforms like CPU’s, GPU’s, etc. It consists of high-level deep learning APIs which make building many deep learning models relatively very easier and thus making the work of tuning the hyperparameters quick.</li></ul><h3><strong>LAMBDA ARCHITECTURE WITH SPARK</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F9dV1FYqKzbAtCmTfyIIzA.png" /></figure><p>Spark is the most popular data processing engine used right now for such tasks because of its efficiency and usage of RDDs which handle fault tolerance while distributing the data over multiple processors. Spark ML library was developed which can be used to build simple ML models(Tree based, linear models) for many simple and common ML tasks.</p><p>A basic lambda architecture using spark would look like the figure above.<br>You can use other live data streaming softwares instead of Kafka if you wish.</p><p>STEP BY STEP ARCHITECTURE:<br>- Kafka is used to process data streams from the websites, apps, IoT etc.<br>- Spark Streaming takes the input from Kafka and stores the data in hdfs for batch processing later as well as process this data and provide the output to serving layer as real time views. (Cassandra can be used for storing data in serving layer to store views)<br>- Spark engine process the whole data batch taken as input from hdfs and provide the output to the serving layer as batch views.<br>- At any time, the results from real time views and batch views can be merged to answer the query.</p><h3><strong>LAMBDA ARCHITECTURE USING TENSORFLOW</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*jOTczmzMudt-qscI8R_iHw.png" /></figure><p>Support for streaming data in TensorFlow is very new and thus not very popular right now. It has support for Kafka, AWS Kinesis, Google Pubsub.</p><p>A short code can now be used to take the input from Kafka, an example is given below:</p><blockquote>1.import tensorflow_io.kafka as kafka_io</blockquote><blockquote>2.dataset = kafka_io.KafkaDataset(‘topic’, server=’localhost’,group=’’)</blockquote><blockquote>#Preprocessing, if required</blockquote><blockquote>3.dataset=dataset.map(lambda x: ….)</blockquote><blockquote>#Model building</blockquote><blockquote>4.model = tf.keras.models….</blockquote><blockquote>5.model.compile(…)</blockquote><blockquote>6.model.fit(dataset, epochs=5)</blockquote><blockquote>#keras callback</blockquote><blockquote>7.class OutputCallback(tf.keras.callbacks.Callback):</blockquote><blockquote>8. def.__init__(self, batch_size, topic, servers):</blockquote><blockquote>9. self.sequence = kafka_io.KafkaOutputSequence(topic=topic, servers=servers)</blockquote><blockquote>10. self._batch_size = batch_size</blockquote><blockquote>11. def on_predict_batch_end(self, batch, logs=None):</blockquote><blockquote>12. self._sequence.setitem(index, class_names[np.argmax(output)])</blockquote><blockquote>#results with callback for streaming input and output</blockquote><blockquote>13.model.predict(test_dataset, callbacks=[OutputCallback(32,’topic’,’localhost’)])</blockquote><p>Also, through TensorFlow Distribute Strategy, parallel processing of data over multiple CPUs, GPUs or TPUs installed in multiple workers can be done. For more information on Distributed Training on TensorFlow, go to <a href="https://www.tensorflow.org/guide/distributed_training">https://www.tensorflow.org/guide/distributed_training</a></p><p>STEP BY STEP ARCHITECTURE<br>- Kafka is used to process data streams from the websites, apps, IoT etc.<br>- Camus API can be used to write data from Kafka to hdfs which will be used for batch processing later while tf.data API of tensorflow can be used to take input from kafka and process real time operations and give the output back to serving layer as real time views simultaneously.<br>- Tensorflow extracts data from hdfs nodes using tf.data.Dataset API and does the batch processing and then storing them to serving layer as batch views.<br>- At any time, the results from real time views and batch views can be merged to answer the query.</p><blockquote>Lambda Architecture with TensorFlow is still very uncommon, so the resources on internet too are rare and are difficult to find but with a little bit of hard-work, you can make it work.</blockquote><h3>When to Use Which of them?</h3><p>Use Cases of Spark</p><ul><li>Data Manipulation</li><li>Feature Engineering</li><li>simple ML models (ex linear models like SVM, Linear Regression etc)</li><li>Basic calculations on data (ex, mean, variance etc.)</li></ul><p>Use Cases of TensorFlow</p><ul><li>Complex deep learning models, they provide high accuracy for complex tasks.</li><li>simple ML models (SVM, linear regression etc)</li></ul><h3><strong>Here comes Another Way- TensorFlowonSpark</strong></h3><p>Yahoo created a framework called TensorflowonSpark for integrating these two frameworks which in a nutshell uses features of both these libraries to produce efficient processing.<br>TensorflowonSpark provides a way of taking input in form of rdds but processing with tensorflow. It also supports the high level Keras APIs.</p><p><strong>Situations when TF and Spark should be used together through TfoS</strong></p><ul><li>· For example, lets say we take up data with 10 features but we have to generate 20–25 features from them or that we have to perform some expensive preprocessing before we can put the data into our tensorflow model.<br> Then we use Spark for producing these new features or preprocessing for efficient parallel processing in rdds, and then put this data through to tensorflow models.</li><li>Also, this is used when there is already a setup created to collect data with spark/hadoop and we need to model deep learning networks on that data.</li></ul><p>This way we can make the use of best of both tensorflow and spark.<br><strong>Lambda Architecture</strong> in this case will be as same as in the case of Spark.</p><h3><strong>CONCLUSION</strong></h3><p>Lambda Architecture is deemed to be a huge success in the of Data Science and is very widely used as means of decreasing the latency in the real time queries required by the user.<br>We also learnt that Spark is a data processing engine while Tensorflow is a deep learning library, so it is used mainly when deploying deep learning models. Deep Learning models are common in fields of Computer Vision, NLP etc because they provide state of the art accuracy for these complex tasks.<br>In all other cases, Spark is preferred as ‘efficient distributed data processing’ was the sole aim behind developing Spark framework but the aim behind developing Tensorflow was to provide tools for building different models easily and thus spark provides faster computation and easier maintenance.<br>So, the use cases of both these frameworks differ by a great margin and thus they both are useful in their different ways and we need them both and integrating them together may work the best for some cases. So you need to work around all these options and then stick to what gets suitable for your use case.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=81f3b92b4856" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>