<?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 An Nguyen on Medium]]></title>
        <description><![CDATA[Stories by An Nguyen on Medium]]></description>
        <link>https://medium.com/@fromtheast?source=rss-700f3d95771c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by An Nguyen on Medium</title>
            <link>https://medium.com/@fromtheast?source=rss-700f3d95771c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 21:08:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@fromtheast/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[Fast camera live streaming with UDP & OpenCV]]></title>
            <link>https://medium.com/@fromtheast/fast-camera-live-streaming-with-udp-opencv-de2f84c73562?source=rss-700f3d95771c------2</link>
            <guid isPermaLink="false">https://medium.com/p/de2f84c73562</guid>
            <category><![CDATA[computer-vision]]></category>
            <category><![CDATA[opencv]]></category>
            <category><![CDATA[computer-network]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[An Nguyen]]></dc:creator>
            <pubDate>Tue, 21 Jan 2020 04:07:46 GMT</pubDate>
            <atom:updated>2020-01-21T23:19:35.251Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>For camera live-streaming application over the computer network, TCP/IP or Transmission Control Protocol/Internet Protocol could come first as a reasonable choice. This method allows a large piece of information to be transmitted reliably, as it manages how a large packet being broken into smaller packets to be transmitted and reassembled in the right order at the the destination. [1]</p><p>Another famous network protocol is UDP or User Datagram Protocol. The implementation of this method is for fast data transmission (low-latency). However, UDP’s drawback is less reliable compared to TCP/IP as there is always chance of data loss (packet drop)[2]. UDP is structured in the way that not necessarily implementing many of the control checks as in TCP/IP for the speed trade-off. From author’s experience in using UDP, lossy is there but not always a concern in reliable network.</p><p>In this project, I’ll explore live streaming over the network with UDP for speedy streaming.</p><h3>Pre-requisites</h3><p>Python 2 or 3<br>OpenCV<br>Numpy<br>Webcam</p><h3>Code Implementation</h3><p><a href="https://github.com/ancabilloni/udp_camera_streaming">https://github.com/ancabilloni/udp_camera_streaming</a></p><h4>Image Frame Packaging</h4><p>Explore the <strong>sender.py</strong> file.</p><p>The implementation are two steps. OpenCV library is being used to obtain image from webcam in main(), then passing frameinto the FrameSegment() class to break down the frame and send over UDP.</p><pre>def main():<br>  “”” Top level main function “””<br>  # Set UDP socket<br>  s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)<br>  port = 12345</pre><pre>  fs = FrameSegment(s, port)<br> <br>  cap = cv2.VideoCapture(0)<br>  while (cap.isOpened()):<br>    _, frame = cap.read()<br>   fs.udp_frame(frame)<br> <br>  cap.release()<br>  cv2.destroyAllWindows()<br>  s.close()</pre><p>Something to note here is that the <strong>encoding</strong> and <strong>decoding</strong> feature in OpenCV being used to further compress the raw image size significantly but still maintaining decent image quality after decompress.</p><p>After the raw frame is compressed, implementing <strong>numpy</strong>’s <strong>tostring()</strong> feature to convert the array into one-dimension bytes-array. The data packet sent by UDP is called <strong>datagram</strong>, the maximum limit of each datagram is 2¹⁶ or 65536 bytes with some bytes are reserved for header. To avoid data overflow and corrupt the codes, I do not use up to the maximum datagram’s size limit.</p><p>To determine the number of segments, I am using ceiling to round up the quotient of <strong>bytearray_size/MAX_IMAGE_DGRAM</strong>. Because <strong>math.ceil</strong> in Python2 is not rounding up as in Python3, so adding <strong>from __future__ import division </strong>helps to get this function to ceiling up properly [3].</p><p>In this simple implementation, I use the first byte for current segment number, which serves as a simple flag for the receiver to know whether there are still more segments of the image data coming. If the segment number is 1, this is the last data segment. Others are welcomed to try other flag/checksum method for more reliable check (for example: if a packet is dropped/never arrived, how the logic is handled?)</p><pre>class <strong>FrameSegment</strong>(object):<br>  “”” <br>  Object to break down image frame segment<br>  if the size of image exceed maximum datagram size <br>  “””<br>  MAX_DGRAM = 2**16<br>  MAX_IMAGE_DGRAM = MAX_DGRAM — 64 # minus 64 bytes in case UDP frame overflown<br>  <br>  def __init__(self, sock, port, addr=”127.0.0.1&quot;):<br>    self.s = sock<br>    self.port = port<br>    self.addr = addr</pre><pre>  def udp_frame(self, img):<br>    “”” <br>    Compress image and Break down<br>    into data segments <br>    “””<br>    compress_img = cv2.imencode(‘.jpg’, img)[1]<br>    dat = compress_img.tostring()<br>    size = len(dat)<br>    num_of_segments = math.ceil(size/(MAX_IMAGE_DGRAM))<br>    array_pos_start = 0<br>    <br>    while num_of_segments:<br>      array_pos_end = min(size, array_pos_start + MAX_IMAGE_DGRAM)<br>      self.s.sendto(<br>                   struct.pack(“B”, num_of_segments) +<br>                   dat[array_pos_start:array_pos_end], <br>                   (self.addr, self.port)<br>                   )<br>      array_pos_start = array_pos_end<br>      num_of_segments -= 1</pre><h4>Image Frame Decode</h4><p>Explore the <strong>receiver.py</strong> file.<br>The logic on the receiver is simple. It is basically a reverse process of the sender:<br>- Read buffer of the current frame first to make sure we are not starting in the middle of the segment stream.<br>- Gather and concatenate all data segments (using the segment number for logic).<br>- Using <strong>numpy’s</strong> <strong>fromstring()</strong> to convert the byte-array back to numpy array.<br>- Using <strong>OpenCV’s</strong> <strong>imdecode</strong> to decode the compressed numpy array back to numpy image.<br>- Lastly, display the image.</p><pre>MAX_DGRAM = 2**16</pre><pre>def dump_buffer(s):<br>  “”” Emptying buffer frame “””<br>  while True:<br>    seg, addr = s.recvfrom(MAX_DGRAM)<br>    print(seg[0])<br>    if struct.unpack(“B”, seg[0:1])[0] == 1:<br>      print(“finish emptying buffer”)<br>      break</pre><pre>def main():<br> “”” Getting image udp frame &amp;<br> concate before decode and output image “””<br> <br> # Set up socket<br> s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)<br> s.bind((‘127.0.0.1’, 12345))<br> dat = b’’<br> dump_buffer(s)</pre><pre> while True:<br>   seg, addr = s.recvfrom(MAX_DGRAM)<br>   if struct.unpack(“B”, seg[0:1])[0] &gt; 1:<br>     dat += seg[1:]<br>   else:<br>     dat += seg[1:]<br>     img = cv2.imdecode(np.fromstring(dat, dtype=np.uint8), 1)<br>     cv2.imshow(‘frame’, img)<br>     if cv2.waitKey(1) &amp; 0xFF == ord(‘q’):<br>       break<br>     dat = b’’</pre><pre> # cap.release()<br> cv2.destroyAllWindows()<br> s.close()</pre><h3>Result</h3><p>Here is a quick screen record result. (The screen recording is not reflecting the actual result. The result is actually better than it looks.)</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FHctlRoi_RVA%3Ffeature%3Doembed&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DHctlRoi_RVA&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FHctlRoi_RVA%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/4cac4266c8eaa7c24ec17b487c139dcb/href">https://medium.com/media/4cac4266c8eaa7c24ec17b487c139dcb/href</a></iframe><h3>Reference</h3><p>1. https://searchnetworking.techtarget.com/definition/TCP-IP<br>2. https://searchnetworking.techtarget.com/definition/UDP-User-Datagram-Protocol<br>3. https://stackoverflow.com/a/17511341</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de2f84c73562" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Self Driving Car System Integration — The Basics]]></title>
            <link>https://medium.com/@fromtheast/self-driving-car-system-integration-the-basics-50cfc3d7c6bc?source=rss-700f3d95771c------2</link>
            <guid isPermaLink="false">https://medium.com/p/50cfc3d7c6bc</guid>
            <category><![CDATA[science]]></category>
            <category><![CDATA[self-driving-cars]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[udacity]]></category>
            <dc:creator><![CDATA[An Nguyen]]></dc:creator>
            <pubDate>Tue, 24 Oct 2017 05:17:39 GMT</pubDate>
            <atom:updated>2017-10-24T08:59:29.581Z</atom:updated>
            <content:encoded><![CDATA[<p>I am the team lead of team RoboFolks, part of the System Integration final project on Self Driving Car program with Udacity. Proudly present to the internet audience some interesting knowledge we unveil under the hood of the magic self driving car on the news these days.</p><p><strong>I. Vision and Detection</strong></p><p>As human in motion, one of first sense and probably the easiest we can use is our vision. We look at where we go or want to go, make sure the path is clear and safe then we can move toward it. If that path is not clear nor safe, the brain will compute for other alternatives.</p><p>Similar in self driving car, the camera is the car’s eyes. With the AI technology today, in one picture, we can really tell quite a few things going on. Utilizing the Machine Learning and Deep Learning methods, we can train a model that has the ability detect certain objects in a picture. The very specific example in our project is to detect <em>traffic lights. </em>As the car moves on road, as long as the camera sees a traffic light, evaluate whether it’s RED/YELLOW/GREEN then the path planner can compute a proper course of action to ask the car to take.</p><p><strong>II. Planner</strong></p><p>As I mentioned earlier about when we see things, our brain can start to calculate the proper course of action depending on our purpose. This is where it happens for the self driving car, inside the planner.</p><ol><li><strong>Visualize our world</strong></li></ol><p><em>How do we really know where we are in the world? </em><br>It’s easy, we have Google Map with the lighting fast GPS system equip on our smart phone to tell us exactly where we are on world map.</p><p>But as engineers, we may want to fall back on something a little more boring than the amazing graphic like on Google Map. Think of the world we live in is a GRID map and every location in our world has a unique coordinate values to set it apart from other location. Imagine if your house is point A with coordinate (x1, y1) on the map, and you want to walk to our neighbor house at point B with coordinate (x2,y2), then you can set a path AB and just move along on this path to reach your neighbor. And guess what? it’s the same on self driving car!</p><p>Every road can be pre-recorded with world coordinates as a set of continuous points which we call <strong>waypoints , </strong>and store this information in the archive data for self driving car to use anytime along with other information such as speed limit on certain road and yaw/rotation angle from one point to the next.</p><p>The car knows exactly where it is in the world with GPS system to find the nearest waypoint it can get to if it needs to get on the road.</p><p><strong>2. What does the planner need to plan?</strong></p><p>The planner plans on the waypoints the car can take to approach the target destination. It should also make some decision base on the feedback from Vision system. Back on our previous example about the traffic light detection, if the car sees traffic light and recognizes light signal, what should it do?</p><p>A few decisions we normally do which can also apply to car are:</p><p>Given X is the maximum distance from car to STOP LINE which the car can gradually slow down when it sees RED light from afar:</p><ul><li>If light is RED and the car is within X, the car should really need to slow down.</li><li>If light is GREEN and the car is within X but it still needs some time to get to stop line at its current speed, it should consider slow down a little as well for caution.</li><li>If light is GREEN and the car can just speed up and cross the light pretty quick in a couple of second, then it should go ahead.</li><li>If the car is not in X, then just keep driving with speed limit.</li></ul><p><strong>3. What does planner reflect on after planning?</strong></p><p>Base on the decisions to plan actions for the car, the planner assigns target velocities (angular and linear) to every waypoint in the future that the self driving car should take.</p><p><strong>III. Controls</strong></p><p>When we actually drive, how we control the car as a driver is to steer the steering wheel constantly to make sure the car stay in lane safely, and to hit the gas pedal or brake pedal to remain/increase/decrease the current speed. The control codes in self driving will do exactly all these tasks.</p><ol><li><strong>Steering</strong></li></ol><p><em>Speaking of a basic case when the car only needs to drive straight and stay inside the lane:</em></p><p>Under the Control roof, some math would happen to calculate the amount of steering the car should take from its current position to stay on the given path of future waypoints which are passed from the Planner.</p><p><strong>2. Accelerating/Decelerating</strong></p><p>Part of other information from the planner is the target velocities the car should take for every future waypoint, the control codes can make a comparison between the current velocity and the target velocity, adjustment is then be made to whether there is a need to apply throttle or brake.</p><p><em>~There you have it, some basics behind three main components in System Integration of the magic self driving car.~</em></p><blockquote>“It’s still MAGIC even if you know how it’s done.” — Terry Pratchett</blockquote><p><em>When all above combine, we have the result in this first test drive on simulator: (credit to </em><a href="https://medium.com/u/422facfa0f21"><em>Andrew Wilkie</em></a><em>)</em></p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FFfqRF8RTDv0%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DFfqRF8RTDv0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FFfqRF8RTDv0%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/afd5d4be215549b228edc4205cdc6da0/href">https://medium.com/media/afd5d4be215549b228edc4205cdc6da0/href</a></iframe><p><em>Thank you team RoboFolks members: </em><a href="https://medium.com/u/422facfa0f21"><em>Andrew Wilkie</em></a><em>, </em><a href="https://medium.com/u/f422dae9bf8d"><em>evotianusx</em></a><em>, </em><a href="https://medium.com/u/7f1d7bb0378b"><em>qiang lu</em></a><em>, </em><a href="https://medium.com/u/f77660c2f9b9"><em>Rohit Patil</em></a><em> for the contribution to the project and many hard lessons we went through together.<br>Thank you so many classmates to help on clarifying the mystery along the way, what a great community Udacity’s Self Driving Car team has provided us students!<br>Lastly, thank you </em><a href="https://medium.com/u/8190c86ea791"><em>David Silver</em></a><em>, Udacity’s Self Driving Car developer and mentor teams have put together the entire Self Driving Car program to allow us to learn and to break hard into this topic in the past 11 months.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=50cfc3d7c6bc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reflect and Recharge (Self Driving Car Nanodegree) Part 1]]></title>
            <link>https://medium.com/@fromtheast/reflect-and-recharge-self-driving-car-nanodegree-part-1-56b8cc583c16?source=rss-700f3d95771c------2</link>
            <guid isPermaLink="false">https://medium.com/p/56b8cc583c16</guid>
            <category><![CDATA[udacity]]></category>
            <category><![CDATA[mooc]]></category>
            <category><![CDATA[self-driving-cars]]></category>
            <category><![CDATA[autonomous-vehicles]]></category>
            <category><![CDATA[nanodegree]]></category>
            <dc:creator><![CDATA[An Nguyen]]></dc:creator>
            <pubDate>Fri, 21 Apr 2017 16:27:36 GMT</pubDate>
            <atom:updated>2017-04-22T18:02:36.237Z</atom:updated>
            <content:encoded><![CDATA[<p><em>*Note: There is nothing technical about this article, just a short note on my personal experience.*</em></p><p>I belong to the November group, but we really didn’t start the course until the end of November. I remember vividly how excited I was the night waiting for the reply from Udacity about admission result to their brand new Self Driving Car program. The first thing I did in the morning was to show my loved one the invitation email, and I am glad that his answer was “Go for it!”. All I need was his support, and he gave me it without any request.</p><p>I gave much thought for the price of the program, $800 a term, this is the most expensive MOOCs that I ever pay. But too much thinking can’t give me any good answer either because nobody else knows the answer. There is no such program like this out there and we are the first groups going through beta test. So for once, I shut down my thought, entered my credit card numbers and decided to trust Udacity’s mission and SDC team there. What can I say? I have <em>risky</em> factor in my blood.</p><p><strong>The Fear</strong></p><p>To be frank, I had no idea what I was doing or getting into before I jumped into the program. I saw some discussions for the Self Driving Car challenge but that sounded like alien language. I studied Mechanical Engineering, so I have solid Math and Physics knowledge. However, I have been intimated by programming my entire life.</p><p><strong>How did I start programming anyway?</strong></p><p>In the middle of passion desperation, I started to recall about what I really wanted to do in the past, it is Robotics. I started picking up some Python a year ago from Udacity’s Introduction to Computer Science class. Let me describe my feeling: it’s like you hate a fruit because of its smell even you never tried it, then you challenged yourself to eat it for once. After you ate the horrible thing, you realize it doesn’t taste bad at all but in fact delicious.</p><p>It was my first brick — to get over my fear about Programming. Since then, many things have changed for better. I unlocked one thing to another just after that first step. So here I am saying this to other technology/science enthusiasts out there:</p><blockquote>If you haven’t already, pick up some programming techniques NOW in any language of your choice , you never know where it will take you.</blockquote><p>Udacity, Coursera, Edx, Sololearn, Codecademy, Khan Academy…and the list goes on for where you can learn for free. Only the sky is the limit!</p><p><strong>The SDC Program</strong></p><p><strong><em>Is it easy? No</em></strong></p><p>If you look at Udacity’s nanodegree list, this one is listed as <strong>advance</strong>. I guess because I shut off my fearful thinking so I wasn’t too intimated to sign up even I had only beginning level of Python at the time. But look, I survived first term somehow. Even wrote some medium articles about it.</p><p><strong><em>Is is something for beginner? Yes and No</em></strong></p><p>I am a solid proof of a “beginner” in whatever way you want to define it. It’s no question ask that one must know how to code prior to joining the program. But I have no knowledge of Computer Vision, Deep Learning or even Machine Learning.</p><p>For an average beginner, who looks into investing about 15 hours/week like other advance students, you won’t make it. But if you are the beginner like “me”, who is a bit crazy about learning, and willing to clock in “can’t-keep-track” the amount of hours to not only learn the provided materials but also look into outside sources, discuss on Slack, bug mentor, ramp Stackexchanges and dig through Medium posts of earlier students. Then you will make it. Just like me!</p><p>FYI, I do have a full-time engineering job but thanks for Christmas and New Year holiday, I had some more time to study.</p><p><strong>What happens to me now?</strong></p><p>After encouragement from a classmate, I applied to be classroom mentor for the program and I got in! I passed Term 1 with good dose of exposure on Deep Learning and Computer Vision. Mentoring helps me to strengthen those knowledge even more by helping and speaking with other students.</p><p>Now on term 2, I study Sensor Fusions and Controllers while programming in C++. These topics are close to my engineering background and I love it. Besides Udacity, I also actively join Hackerrank for the very first time, diligently solving challenges there.</p><p>Did I say I like to do robotics earlier? So Columbia and University of Pennsylvania just launched brand new courses for robotics on Edx. Udacity soon will release a Robotics Nanodegree . Too many good things are on their ways for online learners. Now, the only impossible thing I wish for is 48h a day.</p><p><em>*If you enjoy what you read, hit ❤ to spread the love. There is something else you like me to write about my experience? Please comment below. Until next time!*</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=56b8cc583c16" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Make sense of Kalman Filter]]></title>
            <link>https://medium.com/data-science/make-sense-of-kalman-filter-c59fe5f8202f?source=rss-700f3d95771c------2</link>
            <guid isPermaLink="false">https://medium.com/p/c59fe5f8202f</guid>
            <category><![CDATA[sensors]]></category>
            <category><![CDATA[self-driving-cars]]></category>
            <category><![CDATA[nanodegree]]></category>
            <category><![CDATA[udacity]]></category>
            <category><![CDATA[autonomous-vehicles]]></category>
            <dc:creator><![CDATA[An Nguyen]]></dc:creator>
            <pubDate>Mon, 27 Mar 2017 15:44:44 GMT</pubDate>
            <atom:updated>2017-04-04T01:12:40.399Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This material is made available from the the knowledge I gained under Udacity’s Self Driving Car Program. Special thanks to Sebastian Thrun and Mercedes Benz Engineers for lectures.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*KYwyeQpcrxTDn8cEy5O0-g.png" /><figcaption>Source: <a href="https://www.codeproject.com/Articles/865935/Object-Tracking-Kalman-Filter-with-Ease">https://www.codeproject.com/Articles/865935/Object-Tracking-Kalman-Filter-with-Ease</a></figcaption></figure><h3><strong>What is Kalman Filter?</strong></h3><p>Long answer: check out this Wikipedia <a href="https://en.wikipedia.org/wiki/Kalman_filter">link</a>. Want to study about it? This <a href="https://in.udacity.com/course/artificial-intelligence-for-robotics--cs373/">link</a>.</p><p>My (short &amp; more normal user friendly) answer: <br>- To predict position and velocity with some uncertainty. <br>- Then measure the experimental position and velocity with some uncertainty.<br>- Finally, increase the certainty of our prediction by combining our prediction with the measurement information.</p><h3><strong>Curious part 1: Why must we predict then measure and update?</strong></h3><p>Indeed. In the first look, it seems like the process is kinda abundant. What is the point of making all the prediction then coming around to measure the thing we just predicted? Can’t life be more simple by just jumping straight into measurement?</p><p>Life would be so much simple that way. However, I must ask you something before I reveal the secret of why.</p><blockquote>Imaging you are driving on the road, mind your own business and try to stay steady with 30 mph. Then, someone on your right lane gives signal to move over your lane. Since you are nice person (with a beautiful soul), you are okay with it. Without talking about anything technical here, what do you do in such situation so the person can get in front of you safely?</blockquote><blockquote>If that was me, I could use 2 seconds to do a whole observation of <strong><em>where the car is &amp; what kind of speed it is going relative to my speed</em></strong><em>. </em>My instinct can give a <strong>prediction </strong>what it’s about to do next. That way, I can either slow down to give way or increase the speed to get out of the way. Depends on where my car and the other car are, I would act according to my best judgement to let the other car moves over without causing any accident.</blockquote><blockquote>Assume the car makes the lane change successfully to get in front of me, I still continuously observe the car and adjust my speed so my car can always stay in the safe zone. If the car goes slow, I predict the car will still be slow in the next seconds and I’ll stay at a slow speed behind it. However, if it suddenly goes fast, I can speed up a little bit (as long as under speed limit) and update my belief. What I did there is a continuous process of <strong>prediction</strong> and <strong>update</strong>.</blockquote><p>So, if you follow my example, I think I already gave you the logic behind Kalman Filter. But Kalman Filter is not found to apply on human (or is it?&gt;:), it has been used for various engineering applications on machines because machine doesn’t have the ability to make logical thinking to act according to the environmental changes like human or animals.</p><h3><strong>Curious part 2: Why do we combine prediction and measurement? Isn’t measurement itself accurate enough for update?</strong></h3><p>Again. It makes sense to think using sensors information alone for the update is a right way to go. However, measurements can also have uncertainty (Wait…what???). For example, Lidar is used to detect locations and it is located outside of the car, there can be environmental effects (rain, fog, dirt,etc) which make the measurements less certain.</p><p>It is a good practice to not trust one side blindly, there is always room for uncertainty somewhere. By combining information, we have more information to lower the uncertainty/covariance and to give a more reliable final output.</p><h3>Conclusion</h3><p>Sensors are like our eyes, nose, ears. They sense things and send back information to the brain to process. For self driving car, we have camera, lidar and radar. Camera obtains images so that Deep Learning can recognize objects and even predict information. Lidar and radar sense speed and location so that the machine can make the decision to move accordingly per Kalman Filter application.</p><p><em>*Hope you enjoy this short read. If you like what you read, please hit </em>❤ <em>to share. I appreciate any feedback. Until next time!*</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c59fe5f8202f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/data-science/make-sense-of-kalman-filter-c59fe5f8202f">Make sense of Kalman Filter</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[Udacity Advance Lane Finding Notes]]></title>
            <link>https://medium.com/@fromtheast/computer-vision-resources-411ae9bfef51?source=rss-700f3d95771c------2</link>
            <guid isPermaLink="false">https://medium.com/p/411ae9bfef51</guid>
            <category><![CDATA[udacity]]></category>
            <category><![CDATA[self-driving-cars]]></category>
            <category><![CDATA[image-processing]]></category>
            <category><![CDATA[opencv]]></category>
            <category><![CDATA[computer-vision]]></category>
            <dc:creator><![CDATA[An Nguyen]]></dc:creator>
            <pubDate>Mon, 06 Feb 2017 04:04:43 GMT</pubDate>
            <atom:updated>2017-02-09T16:55:17.185Z</atom:updated>
            <content:encoded><![CDATA[<p><em>*Updating short definition and snippet codes*</em></p><p><strong>Project summary: </strong><br>- Applying calibration on all chessboard images that are taken from the same camera recording the driving to obtain distort coefficients and matrix.<br>- Applying perspective transform and warp image to obtain bird-eyes view on road.<br>- Applying binary threshold by combining derivative x &amp; y, magnitude, direction and S channel.<br>- Reduce noise and locate left &amp; right lanes by histogram data.<br>- Draw line lanes over the image</p><h4><strong>Calibration:</strong></h4><p>-object points 3D points <br>-image points 2D points <br>-radial distortion straight lines appear curves <br>-tangential distortion some area of image look nearer than expect <br>-intrinsic parameters include focal length and optical centers, also called camera matrix . (from OpenCV)<br>-extrinsic parameters correspond to rotation and translation vectors which translate a 3D point to a coordinate system (from OpenCV)</p><p><em>Source</em><strong><em>:</em></strong> <a href="http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_calib3d/py_calibration/py_calibration.html">http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_calib3d/py_calibration/py_calibration.html</a></p><p><em>**Notes**:</em><br>cv2.findChessboardCorners(gray,(nx,ny),None) cv2.drawChessboardCorners(undistort,(nx,ny),corners,ret)<br>Corners will be drawn starting from corner 0 to corner nx for first line, then on next line from corner nx+1 to corner 2*nx. Repeat to all lines.</p><h4><strong>Perspective Transform:</strong></h4><p><a href="http://docs.opencv.org/trunk/da/d6e/tutorial_py_geometric_transformations.html">http://docs.opencv.org/trunk/da/d6e/tutorial_py_geometric_transformations.html</a></p><h4><strong>Image Gradients — Sobel Operator:</strong></h4><p>-sobel x gradients taken in x direction, emphasizes edges closer to vertical <br>-sobel y gradients taken in y direction, emphasize edges closer to horizontal<br>-direction of gradient is the arctangent of y-gradient divided by x-gradient</p><p><a href="http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_imgproc/py_gradients/py_gradients.html">http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_imgproc/py_gradients/py_gradients.html</a></p><p><strong><em>Sobel example:</em></strong></p><pre>gray = cv2.cvtColor(im, cv2.COLOR_RGB2GRAY) or cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)<br>sobelx = cv2.Sobel(gray,cv2.CV_64F,1,0)&lt;= calculate derivative x<br>sobely = cv2.Sobel(gray,cv2.CV_64F,0,1)&lt;= calculate derivative y<br>abs_sobelx = np.absolute(sobelx)&lt;= absolute values<br>scaled_sobel = np.uint8(255*abs_sobelx/np.max(abs_sobelx)) &lt;= 8bit</pre><p>There are three ways to set binary thresholds:</p><ul><li>x and y gradients</li><li>Overall gradient magnitude</li><li>Gradient direction</li></ul><p><strong><em>Example binary threshold to select pixel:</em></strong></p><pre>thre_min = n<br>thre_max = m<br>sxbinary = np.zeros_like(scaled_sobel)<br>sxbinary[(scaled_sobel &gt;= thre_min) &amp; (scaled_sobel &lt;= thres_max)] = 1<br>plt.imshow(sxbinary, cmap=&#39;gray&#39;)</pre><p><strong><em>Binary threshold functions:</em></strong></p><pre># Convert to grayscale from RGB<br>def gray_cvt(image):<br>    return cv2.cvtColor(image,cv2.COLOR_RGB2GRAY)</pre><pre>#Sobel thresholds<br>def abs_sobel_thresh(img, orient=&#39;x&#39;, sobel_kernel=3, thresh=(0,255)):<br>    gray = gray_cvt(img)<br>    if orient == &#39;x&#39;:<br>        sobel = cv2.Sobel(gray,cv2.CV_64F,1,0,ksize=sobel_kernel)<br>    elif orient == &#39;y&#39;:<br>        sobel = cv2.Sobel(gray,cv2.CV_64F,0,1,ksize=sobel_kernel)<br>    abs_sobel = np.absolute(sobel)<br>    scaled_sobel = np.uint8(255*abs_sobel/np.max(abs_sobel))<br>    grad_binary = np.zeros_like(scaled_sobel)<br>    grad_binary[(scaled_sobel &gt;= thresh[0])&amp;(scaled_sobel &lt;= thresh[1])] = 1<br>    return grad_binary</pre><pre># Magnitude thresholds<br>def mag_thresh(image, sobel_kernel=3, mag_thresh=(0,255)):<br>    gray = gray_cvt(image)<br>    sobelx = cv2.Sobel(gray,cv2.CV_64F,1,0,ksize=sobel_kernel)<br>    sobely = cv2.Sobel(gray,cv2.CV_64F,0,1,ksize=sobel_kernel)<br>    abs_sobelxy = np.sqrt(sobelx**2+sobely**2)<br>    scaled_sobel = np.uint8(255*abs_sobelxy/np.max(abs_sobelxy))<br>    mag_binary = np.zeros_like(scaled_sobel)<br>    mag_binary[(scaled_sobel &gt;= mag_thresh[0])&amp;(scaled_sobel &lt;= mag_thresh[1])]=1<br>    return mag_binary</pre><pre># Direction thresholds<br>def dir_threshold(image, sobel_kernel=3, thresh=(0, np.pi/2)):<br>    gray = gray_cvt(image)<br>    abs_sobelx = np.absolute(cv2.Sobel(gray,cv2.CV_64F,1,0,ksize=sobel_kernel))<br>    abs_sobely = np.absolute(cv2.Sobel(gray,cv2.CV_64F,0,1,ksize=sobel_kernel))<br>    grad_dir = np.arctan2(abs_sobely,abs_sobelx)<br>    dir_binary = np.zeros_like(grad_dir)<br>    dir_binary[(grad_dir &gt;= thresh[0])&amp;(grad_dir &lt;= thresh[1])] = 1<br>    return dir_binary</pre><p><strong><em>Stack Color and Gradient (Udacity codes):</em></strong></p><pre><em># Convert to HLS color space and separate the S channel</em><br><em># Note: img is the undistorted image</em><br>hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)<br>s_channel = hls[:,:,2]<br><br><em># Grayscale image</em><br><em># NOTE: we already saw that standard grayscaling lost color information for the lane lines</em><br><em># Explore gradients in other colors spaces / color channels to see what might work better</em><br>gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)<br><br><em># Sobel x</em><br>sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0) <em># Take the derivative in x</em><br>abs_sobelx = np.absolute(sobelx) <em># Absolute x derivative to accentuate lines away from horizontal</em><br>scaled_sobel = np.uint8(255*abs_sobelx/np.max(abs_sobelx))<br><br><em># Threshold x gradient</em><br>thresh_min = 20<br>thresh_max = 100<br>sxbinary = np.zeros_like(scaled_sobel)<br>sxbinary[(scaled_sobel &gt;= thresh_min) &amp; (scaled_sobel &lt;= thresh_max)] = 1<br><br><em># Threshold color channel</em><br>s_thresh_min = 170<br>s_thresh_max = 255<br>s_binary = np.zeros_like(s_channel)<br>s_binary[(s_channel &gt;= s_thresh_min) &amp; (s_channel &lt;= s_thresh_max)] = 1<br><br><em># Stack each channel to view their individual contributions in green and blue respectively</em><br><em># This returns a stack of the two binary images, whose components you can see as different colors</em><br>color_binary = np.dstack(( np.zeros_like(sxbinary), sxbinary, s_binary))<br><br><em># Combine the two binary thresholds</em><br>combined_binary = np.zeros_like(sxbinary)<br>combined_binary[(s_binary == 1) | (sxbinary == 1)] = 1<br><br><em># Plotting thresholded images</em><br>f, (ax1, ax2) = plt.subplots(1, 2, figsize=(20,10))<br>ax1.set_title(&#39;Stacked thresholds&#39;)<br>ax1.imshow(color_binary)<br><br>ax2.set_title(&#39;Combined S channel and gradient thresholds&#39;)<br>ax2.imshow(combined_binary, cmap=&#39;gray&#39;)</pre><p><strong><em>Locate lane lines with sliding window (Udacity’s codes):</em></strong></p><pre><strong>import</strong> numpy <strong>as</strong> np<br><strong>import</strong> cv2<br><strong>import</strong> matplotlib.pyplot <strong>as</strong> plt<br><br><em># Assuming you have created a warped binary image called &quot;binary_warped&quot;</em><br><em># Take a histogram of the bottom half of the image</em><br>histogram = np.sum(binary_warped[binary_warped.shape[0]/2:,:], axis=0)<br><em># Create an output image to draw on and  visualize the result</em><br>out_img = np.dstack((binary_warped, binary_warped, binary_warped))*255<br><em># Find the peak of the left and right halves of the histogram</em><br><em># These will be the starting point for the left and right lines</em><br>midpoint = np.int(histogram.shape[0]/2)<br>leftx_base = np.argmax(histogram[:midpoint])<br>rightx_base = np.argmax(histogram[midpoint:]) + midpoint<br><br><em># Choose the number of sliding windows</em><br>nwindows = 9<br><em># Set height of windows</em><br>window_height = np.int(binary_warped.shape[0]/nwindows)<br><em># Identify the x and y positions of all nonzero pixels in the image</em><br>nonzero = binary_warped.nonzero()<br>nonzeroy = np.array(nonzero[0])<br>nonzerox = np.array(nonzero[1])<br><em># Current positions to be updated for each window</em><br>leftx_current = leftx_base<br>rightx_current = rightx_base<br><em># Set the width of the windows +/- margin</em><br>margin = 100<br><em># Set minimum number of pixels found to recenter window</em><br>minpix = 50<br><em># Create empty lists to receive left and right lane pixel indices</em><br>left_lane_inds = []<br>right_lane_inds = []<br><br><em># Step through the windows one by one</em><br><strong>for</strong> window <strong>in</strong> range(nwindows):<br>    <em># Identify window boundaries in x and y (and right and left)</em><br>    win_y_low = binary_warped.shape[0] - (window+1)*window_height<br>    win_y_high = binary_warped.shape[0] - window*window_height<br>    win_xleft_low = leftx_current - margin<br>    win_xleft_high = leftx_current + margin<br>    win_xright_low = rightx_current - margin<br>    win_xright_high = rightx_current + margin<br>    <em># Draw the windows on the visualization image</em><br>    cv2.rectangle(out_img,(win_xleft_low,win_y_low),(win_xleft_high,win_y_high),(0,255,0), 2) <br>    cv2.rectangle(out_img,(win_xright_low,win_y_low),(win_xright_high,win_y_high),(0,255,0), 2) <br>    <em># Identify the nonzero pixels in x and y within the window</em><br>    good_left_inds = ((nonzeroy &gt;= win_y_low) &amp; (nonzeroy &lt; win_y_high) &amp; (nonzerox &gt;= win_xleft_low) &amp; (nonzerox &lt; win_xleft_high)).nonzero()[0]<br>    good_right_inds = ((nonzeroy &gt;= win_y_low) &amp; (nonzeroy &lt; win_y_high) &amp; (nonzerox &gt;= win_xright_low) &amp; (nonzerox &lt; win_xright_high)).nonzero()[0]<br>    <em># Append these indices to the lists</em><br>    left_lane_inds.append(good_left_inds)<br>    right_lane_inds.append(good_right_inds)<br>    <em># If you found &gt; minpix pixels, recenter next window on their mean position</em><br>    <strong>if</strong> len(good_left_inds) &gt; minpix:<br>        leftx_current = np.int(np.mean(nonzerox[good_left_inds]))<br>    <strong>if</strong> len(good_right_inds) &gt; minpix:        <br>        rightx_current = np.int(np.mean(nonzerox[good_right_inds]))<br><br><em># Concatenate the arrays of indices</em><br>left_lane_inds = np.concatenate(left_lane_inds)<br>right_lane_inds = np.concatenate(right_lane_inds)<br><br><em># Extract left and right line pixel positions</em><br>leftx = nonzerox[left_lane_inds]<br>lefty = nonzeroy[left_lane_inds] <br>rightx = nonzerox[right_lane_inds]<br>righty = nonzeroy[right_lane_inds] <br><br><em># Fit a second order polynomial to each</em><br>left_fit = np.polyfit(lefty, leftx, 2)<br>right_fit = np.polyfit(righty, rightx, 2)</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=411ae9bfef51" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implement fit_generator( ) in Keras]]></title>
            <link>https://medium.com/@fromtheast/implement-fit-generator-in-keras-61aa2786ce98?source=rss-700f3d95771c------2</link>
            <guid isPermaLink="false">https://medium.com/p/61aa2786ce98</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[fit-generator]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[keras]]></category>
            <dc:creator><![CDATA[An Nguyen]]></dc:creator>
            <pubDate>Thu, 02 Feb 2017 05:36:32 GMT</pubDate>
            <atom:updated>2018-01-17T10:29:41.701Z</atom:updated>
            <content:encoded><![CDATA[<p>Here is an example of fit_generator():</p><pre>model.fit_generator(generator(features, labels, batch_size), samples_per_epoch=50, nb_epoch=10)</pre><p>Breaking it down:</p><p>generator(features, labels, batch_size): generates batches of samples indefinitely</p><p>sample_per_epoch: number of samples you want to train in each epoch</p><p>nb_epoch: number of epochs</p><p>As you can manually define <strong>sample_per_epoch</strong> and <strong>nb_epoch</strong> , you have to provide codes for <strong>generator</strong> . Here is an example:</p><p>Assume <strong>features</strong> is an array of data with shape (100,64,64,3) and <strong>labels</strong> is an array of data with shape (100,1). We use data from <strong>features</strong> and <strong>labels</strong> to train our model.</p><pre><strong>def</strong> generator(features, labels, batch_size):</pre><pre><strong> # Create empty arrays to contain batch of features and labels#</strong></pre><pre> batch_features = np.zeros((batch_size, 64, 64, 3))<br> batch_labels = np.zeros((batch_size,1))</pre><pre> while <strong>True</strong>:<br>   for i in range(batch_size):<br>     <strong># choose random index in features</strong><br>     index= random.choice(len(features),1)<br>     batch_features[i] = some_processing(features[index])<br>     batch_labels[i] = labels[index]<br>   <strong>yield</strong> batch_features, batch_labels</pre><p>With the generator above, if we define batch_size = 10 , that means it will randomly taking out 10 samples from features and labels to feed into each epoch until an epoch hits 50 sample limit. Then fit_generator() destroys the used data and move on repeating the same process in new epoch.</p><p>One great advantage about <strong>fit_generator()</strong> besides saving memory is user can integrate random augmentation inside the generator, so it will always provide model with new data to train on the fly.</p><p>For more information on fit_generator() arguments, refer to Keras website:</p><p><a href="https://keras.io/models/sequential/">Sequential - Keras Documentation</a></p><p><em>I hope you found the content is helpful. If so, please hit ❤ to share and I really appreciate any feedback. Until next time!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=61aa2786ce98" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You don’t need lots of data! (Udacity Behavioral Cloning)]]></title>
            <link>https://medium.com/@fromtheast/you-dont-need-lots-of-data-udacity-behavioral-cloning-6d2d87316c52?source=rss-700f3d95771c------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d2d87316c52</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[behavioral-cloning]]></category>
            <category><![CDATA[self-driving-cars]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[udacity]]></category>
            <dc:creator><![CDATA[An Nguyen]]></dc:creator>
            <pubDate>Wed, 01 Feb 2017 17:59:09 GMT</pubDate>
            <atom:updated>2017-03-25T03:06:26.245Z</atom:updated>
            <content:encoded><![CDATA[<p>This post is to give better understanding about balancing data to train car model in Udacity Behavioral Cloning project.</p><p><strong>Intro:</strong> Driving the car around a track to collect data and train it on neural network so that the car can eventually predict the angle to steer by itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*9EBVASHMuxw9-M9LtigIjg.png" /><figcaption>Track 1</figcaption></figure><p><strong>Challenge topic:</strong> Data!</p><p>I am certain that I am not the only one who admitted the challenge for this project is data. There are many posts out there talking about the whole process of training but I’ll just really focus on data topic alone here since there seems to have a common misconception that big data is the only way to make this model working. If you read this, it may save you a 50 hours trip of tuning.</p><p>For this project, just assuming you have a working neural network architecture (using Nvidia/comma.ai/VGG16/your own), you nail it 20%. The other 80% is your data. Just like anything we do, the longer we practice, the better we are good at it because we take in hour and hour of data into our brain memory/muscle memory. It’s the same here for neural net, the more variety of data you have to train your network, the better the model is at the task.</p><p>So let’s assume, you need to drive on a same road <strong>100 times</strong> beautifully to collect a massive number of data samples to make your model to work. Instead, you only drive <strong>8–10 times</strong> with 3 cameras (central, left, right), and thinking “hmm, can I make this work?”.</p><p>The answer is YES!</p><h3>Data Augmentation</h3><p>Thanks to Computer Vision &amp; Statistics. You can rotate, translate, flip, shift, transform to darker or brighter…however you want to your data with a few cv2 lines of code. Why though? Because doing these you can generate many kind of environments you think the car can be in. For example:</p><ul><li>I collect data on a bright beautiful day, what if it’s dark or raining when my autonomous car runs on a street, that wouldn’t be good because my car can be confused. So I should apply a range of random brightness to all of my training images by adjusting V channel on HSV. Then there are going to be a mix of dark and bright images to train.</li><li>Do I want to flip the image? Probably, it will look like the car drives in the opposite direction with opposite angle. But which image to flip? How about flipping a coin and let the coin decides? Then I will have a range of random data with opposite directions to train.</li><li>Do I want to rotate the image? Good idea, it may apply well for hilly environment even we collect data on a flat environment.</li></ul><p>Those are just a few examples you can do with data augmentation to generate your data randomly as much as possible on purpose.</p><h3><strong>Balance is the Key</strong></h3><p>I live in U.S midwest area, the road is pretty flat and straight to drive. But that doesn’t mean we don’t have to turn once in awhile. Same thing in this project, the training track is pretty flat and straight driving with light steering most of the time. But there are also a few sharp turns that can throw the car off the track if it doesn’t pay attention.</p><p>The problem is, too much straight driving data with limited turning data isn’t very safe to teach the car how to drive, especially if I aim to train it on small original data set with random augmentation. Hence, I can either down-sample the straight driving data or increase left and right turning data so all aspects are balance.</p><p>To be able to do so, I can take advantage of LEFT and RIGHT camera images. I can target when the car turns left, use its right camera images and add some adjustment angle into current steering angle so the car can turn a little more if it’s in such kind of position. Similarly in the opposite direction, I can do the same with the left camera images when the car turn right. By applying these, I add some <strong>RECOVERY</strong> into my data set so the car can recover when it is in such sharp turns.</p><h3><strong>The Powerful fit_generator()</strong></h3><p>At first, I didn’t like this one so much comparing to <strong>model.fit()</strong> on Keras. Well, because it was kinda confusing to understand. Now I understand it, I love it! Especially for my purpose of low original training data. To use <strong>fit_generator()</strong>, you need a <strong>generator</strong> code to feed batches into the model. The way we apply the generator with augmentation is:</p><p><strong>Generator &gt; Pick out a batch of random images from the original training data &gt; Apply random augmentation &gt; Feed to the model to train &gt; Model is done training with that batch, destroy the data &gt; Repeat the process</strong></p><p>With random augmentation directly on Generator, it’s almost unlikely that the training data feeding into fit_generator() are the same. So you end up always having new data to train without taking use a lot of your GPU/CPU memory.</p><p>For my extra write-up about fit_generator(). See here: <a href="https://medium.com/@fromtheast/implement-fit-generator-in-keras-61aa2786ce98#.9ivzotkz7">https://medium.com/@fromtheast/implement-fit-generator-in-keras-61aa2786ce98#.9ivzotkz7</a></p><p>I applied what I said above with 9000 balanced dataset on 20–25 epochs with 9000 samples per epoch, and here is the result:</p><p><strong>Track 1:</strong></p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FmR6Gswp5Xmo%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DmR6Gswp5Xmo&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FmR6Gswp5Xmo%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/782c5be311f800b088975c9eaa5c1b66/href">https://medium.com/media/782c5be311f800b088975c9eaa5c1b66/href</a></iframe><p><strong>Track 2:</strong></p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FhZfchwEIqqU%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DhZfchwEIqqU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FhZfchwEIqqU%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/3480fde7a897fa4a46545d7076f60e08/href">https://medium.com/media/3480fde7a897fa4a46545d7076f60e08/href</a></iframe><p><em>(Reference: </em><a href="https://github.com/ancabilloni/SDC-P3-BehavioralCloning"><em>https://github.com/ancabilloni/SDC-P3-BehavioralCloning</em></a><em>)</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d2d87316c52" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>