<?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 Er. Shrawan, Phd Researcher  on Medium]]></title>
        <description><![CDATA[Stories by Er. Shrawan, Phd Researcher  on Medium]]></description>
        <link>https://medium.com/@ershrawan014?source=rss-b06738d7a791------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*di1D4rXT_h17mf8Mn-A12Q@2x.jpeg</url>
            <title>Stories by Er. Shrawan, Phd Researcher  on Medium</title>
            <link>https://medium.com/@ershrawan014?source=rss-b06738d7a791------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 21:32:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ershrawan014/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[Stop Trusting the Network: Why VPN Accesss the Wrong Abstraction for Privileged Access]]></title>
            <link>https://medium.com/@ershrawan014/stop-trusting-the-network-why-vpn-accesss-the-wrong-abstraction-for-privileged-access-81d1b3d96de5?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/81d1b3d96de5</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[information-security]]></category>
            <category><![CDATA[zero-trust-security-model]]></category>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Tue, 15 Sep 2026 05:01:02 GMT</pubDate>
            <atom:updated>2026-09-15T05:01:02.436Z</atom:updated>
            <content:encoded><![CDATA[<p>Building Citadel taught me that Zero Trust isn’t a feature you bolt on it’s a discipline you have to survive your own architecture proving,</p><p>Author: Rajiv Bastola, System Manager at Dish Media Network Limited</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t6hfzLBsd1WwZY88wA8VTg.png" /></figure><p><strong>What if the entire model of “connect to the network, then trust everyone on it” is the actual vulnerability?</strong></p><p>For decades, that’s exactly how privileged access has worked. You get a VPN connection, and suddenly you’re “inside.” Inside the perimeter. Inside the trust boundary. Inside the blast radius of every credential, every server, every misconfigured firewall rule that anyone ever forgot about.</p><p>It’s a model built for a world of offices, LANs, and a handful of servers in a back room. It is not a model built for cloud infrastructure, remote teams, contractors, service accounts, and attackers who only need one standing credential to move laterally through everything you own.</p><p>So a few months ago, I started asking a different question — not “how do we secure the VPN?” but <strong>“why does access require a network location at all?”</strong></p><p>That question became <strong>Citadel</strong>, a Zero Trust Network Access (ZTNA) and Privileged Access Management (PAM) platform I’ve been designing and building from the ground up.</p><h3>The Core Idea: Access Should Answer Five Questions, Not One</h3><p>Traditional remote access answers one question: <em>“Are you connected?”</em></p><p>Citadel is built around a much less comfortable set of questions — the ones security teams actually get asked during an incident review, usually too late:</p><blockquote><strong><em>Who is calling? What are they allowed to do? Which resource are they touching? Why are they accessing it? How long should that access exist? Where was the decision actually enforced? And can we prove, afterward, exactly what happened?</em></strong></blockquote><p>If a system can’t answer all seven of those in real time, it isn’t Zero Trust. It’s a VPN with better branding.</p><p>The founding principle behind Citadel is simple to say and hard to build:</p><blockquote><strong><em>Users should not receive network access just because they are trusted. They should receive narrowly scoped access to a specific resource, for a specific reason, for a limited period of time.</em></strong></blockquote><p>Everything else in the architecture exists to make that sentence enforceable not aspirational.</p><h3>Inside the Architecture: Five Planes, One Discipline</h3><p>Rather than bolting security onto a flat network, Citadel separates concerns into five distinct planes. Each plane has a narrow job, and critically none of them trust each other by default.</p><h3>Identity Plane</h3><p>Handles identity federation, authentication, and MFA. This is where <em>who you are</em> gets established and nothing else.</p><h3>Control Plane</h3><p>Evaluates policy and makes access decisions. This is the brain: given an identity, a resource, and a context, should this request be allowed <em>right now</em>?</p><h3>Credential Plane</h3><p>Issues short-lived credentials and SSH certificates. No standing secrets. No forever-valid keys sitting in a vault waiting to be stolen.</p><h3>Data Plane</h3><p>The actual access path SSH, RDP, and HTTP routed through controlled gateways instead of a flat network tunnel.</p><h3>Security Plane</h3><p>Continuously evaluates risk, records sessions, enforces DLP, and generates the forensic telemetry that lets you reconstruct exactly what happened, after the fact.</p><p>Separating these planes isn’t just clean architecture for its own sake. It means a compromise in one plane doesn’t automatically hand an attacker the keys to the others which is precisely the failure mode that flat VPN access creates.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bhsjqdt_TzSW0RDlu3h1NQ.png" /></figure><h3>The Engineering Principles Behind the Architecture</h3><p>A handful of non-negotiable decisions shape every part of Citadel:</p><ul><li><strong>No standing privileged credentials</strong> nothing long-lived to steal.</li><li><strong>Just-in-time access</strong> access exists only for the duration it’s needed.</li><li><strong>Resource-level authorization</strong> not network-level, not server-level, <em>resource</em>-level.</li><li><strong>MFA and device posture checks </strong>identity alone is not enough.</li><li><strong>Risk-aware access decisions </strong>context changes the outcome, not just the credential.</li><li><strong>Session recording and forensic integrity</strong> every session is provable, not just loggable.</li><li><strong>Policy enforcement at centralized chokepoints </strong>not scattered, inconsistent checks.</li><li><strong>Strict separation between control, credential, and data planes</strong></li><li><strong>Open-source infrastructure wherever practical</strong> auditable over opaque</li></ul><p>Each one sounds obvious in a slide deck. Each one is genuinely difficult to hold true once real services, real edge cases, and real deadlines show up.</p><h3>The Uncomfortable Truth: Building Security Software Is Not the Hard Part</h3><p>Here’s what I didn’t fully appreciate until I was deep in it:</p><p><strong>Adding security features is the easy 80%. Proving the architecture stays secure as it grows is the hard 20% and it’s where almost everything that matters actually lives.</strong></p><p>During development and internal auditing, we surfaced problems that were completely invisible at the feature level:</p><ul><li><strong>Authorization gaps</strong> that only appeared when two services made slightly different assumptions about who had already been checked</li><li><strong>Contract inconsistencies</strong> between services where Service A assumed Service B had validated something, and Service B assumed the opposite</li><li><strong>Overly broad internal trust assumptions </strong>the kind of “well, it’s an internal call, it’s probably fine” thinking that Zero Trust is supposed to eliminate</li><li><strong>Enforcement that existed in the wrong layer </strong>a check that was implemented somewhere in the code, but not at the actual policy chokepoint where the access decision is made</li></ul><p>None of these showed up as a broken feature. The dashboard worked. The demo worked. The gap only became visible when we deliberately went looking for the seams between components the places where one plane’s assumptions quietly met another plane’s assumptions, and nobody had verified they actually agreed.</p><p>That’s the lesson worth sitting with:</p><blockquote><strong><em>A Zero Trust product cannot simply implement Zero Trust at the edge. Its own internal architecture must follow the same principles it enforces on its users.</em></strong></blockquote><p>If Citadel demands narrowly scoped, time-limited, provable access from every user who touches a production server but its own internal services trust each other by default the whole model collapses into theater. So the same seven questions above get asked internally, between planes, not just externally, between a user and a resource.</p><h3>Where This Is Headed</h3><p>Citadel is still an engineering journey, not a finished claim. I’m not going to pretend every edge case is solved that would be exactly the kind of overconfidence this whole approach is meant to eliminate.</p><p>The objective is practical, not theoretical: build a ZTNA/PAM platform that can actually be deployed in real enterprise and infrastructure environments particularly where <strong>SSH, RDP, internal applications, and privileged access</strong> need meaningfully stronger controls than “connect to the VPN and hope.”</p><p><strong>Zero Trust is not a product feature.</strong> <strong>It is an architectural discipline.</strong></p><p>It’s not a checkbox, a marketing term, or a firewall rule. It’s a standing commitment to keep asking uncomfortable questions about your own system — especially the parts that already “work.”</p><p><em>If you’re working on ZTNA, PAM, or Zero Trust architecture and have run into similar seams between planes — I’d genuinely like to compare notes. What’s the internal trust assumption that bit you when you least expected it?</em></p><p>#ZeroTrust #ZTNA #PAM #CyberSecurity #InformationSecurity #PrivilegedAccessManagement #NetworkSecurity #OpenSource #SecurityArchitecture #Citadel</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=81d1b3d96de5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Glacier Gave Nepal 30 Minutes. It Wasn’t Enough.]]></title>
            <link>https://medium.com/@ershrawan014/the-glacier-gave-nepal-30-minutes-it-wasnt-enough-59a6d29dac56?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/59a6d29dac56</guid>
            <category><![CDATA[floods]]></category>
            <category><![CDATA[globalwarning]]></category>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Sat, 29 Aug 2026 18:41:09 GMT</pubDate>
            <atom:updated>2026-08-31T11:22:07.681Z</atom:updated>
            <content:encoded><![CDATA[<p>A record flash flood killed hundreds in Nepal and exposed the limits of even the best early-warning tech in a warming world.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kUSo8M6ogEIIcrjkzKMz7Q.png" /></figure><h3><em>Should we keep building better sensors to detect disasters or spend harder on removing the conditions that create them?</em></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XzsgDC5SJj7IebGOOqro6g.png" /></figure><h3><em>The August 2026 Rasuwa catastrophe suggests the honest answer is both, and shows why the “both” has to be taken more seriously than it has been.</em></h3><p><em>Rasuwa, Nepal &amp; Beyond — Updated August 29, 2026</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lnkHUpT9h49DDe4B_AmT2Q.png" /></figure><p>On the morning of August 26, 2026, a section of glacier near Langtang Lirung roughly 600 metres wide sheared away at about 5,200 metres elevation and fell some 1,200 vertical metres into the valley below.</p><p>What followed was one of the deadliest disasters in Nepal’s modern history: flash floods and mudslides tore along a 72-kilometre stretch of the Trishuli River, destroyed the Gyirong Port trade crossing on the China border, and carried victims as far as 240 kilometres downstream into India.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LcjUty5_RzEa8P7ciR6KMQ.png" /></figure><p>This raises a hard question that goes beyond Nepal: are we putting too much faith in detecting floods after the danger has already formed, and not enough into removing the conditions that are making these events more frequent and more violent?</p><p>The answer is not to abandon early-warning systems glaciers, oceans and the wider climate system will keep responding to the warming already locked in for decades, even if emissions stopped today. But early warning can only ever be one layer. The larger, harder job is cutting the greenhouse-gas emissions driving the warming in the first place.</p><h3>A chain of risk, not a single cause</h3><p>Carbon dioxide does not “create” a flood. It works indirectly, through a long causal chain which is exactly why it’s easy to underweight in the moment a river is rising:</p><p>1. Fossil-fuel combustion.</p><p>2. CO₂ accumulates in the atmosphere.</p><p>3. Global and regional warming accelerates.</p><p>4. Glaciers, permafrost and slopes destabilise.</p><p>5. Greater potential for extreme hazards.</p><p>6. Floods, landslides, debris flows.</p><p>The Hindu Kush Himalaya (HKH) is experiencing rapid climatic and cryospheric changes, with significant implications for glaciers, snow cover, and regional water resources. Under global warming of <strong>1.5°C–2°C</strong>, HKH glaciers are projected to lose approximately <strong>30%–50% of their volume by 2100</strong> compared with 2015 levels, while glacier-volume loss could increase to <strong>55%–75% under 3°C warming</strong> and <strong>70%–80% under 4°C warming</strong>. Even the relatively large glaciers of the <strong>West Kunlun and Karakoram</strong> are projected to retain only about half of their present glacier area. Observations also indicate a substantial acceleration in glacier mass loss, increasing from approximately <strong>−0.17 m water equivalent (w.e.) per year during 2000–2009 to −0.28 m w.e. per year during 2010–2019</strong>, representing an increase of around <strong>65%</strong>. The HKH region experienced a mean temperature increase of approximately <strong>0.28°C per decade between 1951 and 2020</strong>, while parts of the <strong>Tibetan Plateau, Amu Darya and Brahmaputra basins, and the headwaters of the Mekong and Yangtze rivers</strong> experienced warming rates of up to <strong>0.66°C per decade</strong>. Particularly rapid glacier mass loss has been observed in <strong>southeast Tibet and the Nyainqêntanglha region</strong>, reaching approximately <strong>−0.78 ± 0.10 m w.e. per year during 2010–2019</strong>. In addition, snow-cover extent is projected to decline by approximately <strong>1%–26%</strong> as average temperatures increase from <strong>1.1°C to 4°C</strong>. Although episodes of heavy snowfall are already becoming more frequent and are projected to increase further in frequency and intensity, the contribution of <strong>snowmelt to streamflow is expected to decrease under all climate scenarios</strong>, indicating substantial changes in the timing and availability of water resources across the HKH.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q2Zy8NKvqfCA3bYXvHa-0A.png" /><figcaption>Figure: Distribution of permafrost (in green) and glaciers (in blue) and summary statistics for glaciers and permafrost in the major river basins of the HKH.</figcaption></figure><p>SOURCE: <a href="https://hkh.icimod.org/hi-wise/ice/">https://hkh.icimod.org/hi-wise/ice/</a></p><p>That’s the mechanism behind Rasuwa in one picture: every fraction of a degree of warming buys a proportionally larger share of the “water tower of Asia.” Scientists have not yet quantified exactly how much climate change contributed to this specific collapse attribution takes time but the broader trend of accelerating HKH ice loss is not in dispute.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-BRFmWMHbXWvxv2T23WCfA.png" /></figure><h3>The data-centre paradox</h3><p>The tools we increasingly rely on to detect and predict these disasters — satellites, AI models, remote sensing pipelines run on infrastructure with its own growing footprint. A data centre’s Power Usage Effectiveness (PUE) measures overhead: a PUE of 1.5 means that for every 1 kWh consumed by IT equipment, roughly another 0.5 kWh goes to cooling and supporting systems. But PUE alone is the wrong metric to fixate on what matters more is where the electricity comes from.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gDUUF5nlFnPqA44_JQWuUA.png" /></figure><p>If AI is used to monitor climate disasters, the infrastructure running that AI has to become part of the emissions solution too not a quiet exception to it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uF3YwVh66VynEuNr4I-T2A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AIiHx3gakwS0h8D_9q5aNg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dj_L7LdwNYTqx8G65eNp3g.png" /></figure><p>Data centers CO2 emissions for different power demands</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ypGfTF_jwiyt9hEfePjQRQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cA5Yn9Ecb_gUIuaZTKt5gQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zdg2eOLve1yfmO1Q88spyw.png" /></figure><h3>The same problem, on the roads</h3><p>Data centres are a small slice of a much bigger picture. Road transport alone produced just over 6 gigatonnes of CO₂ in 2024 — more than ten times all data-centre electricity emissions combined — with more than 60% of that coming from passenger cars and vans.</p><p><strong>GLOBAL ROAD-TRANSPORT CO₂, 2024: ~6.1 Gt</strong></p><ul><li>Cars andvans: 60%+</li><li>Trucks, buses, 2/3-wheelers: remainder</li></ul><p><em>Source: IEA road-transport emissions data, 2024</em></p><p>Add coal- and gas-fired power, cement, industry, aviation, shipping, deforestation, agriculture and waste, and the picture is unambiguous: this is not a single sector’s problem, or one country’s, or one technology’s. It’s the entire global energy system.</p><p><strong>Should Nepal stop investing in flood warning?</strong></p><p>No that would be exactly the wrong conclusion. Nepal sits among the countries most exposed to climate-driven mountain hazards while contributing a negligible share of global emissions. Communities living beneath these glaciers cannot wait for international climate policy to work.</p><p>But Rasuwa also exposed a real gap: traditional river-gauge monitoring watches for water that has already started rising downstream. The 2026 event developed from a glacier collapse far upstream and reached population centres within minutes — river-level sensors alone were never going to give people enough warning. What’s needed is monitoring that watches the glacier and the slope itself, not just the water that eventually results.</p><p><em>The gap Rasuwa exposed: a 9-metre river rise in 30 minutes leaves almost no time to evacuate once a downstream gauge trips. Detecting the ice-rock avalanche at its 5,200-metre source — via satellite, seismic sensors or radar — is the only way to buy back those lost minutes.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_Z4lucywZBDuKWEyJlyhdw.png" /></figure><h3>From early warning to early prevention</h3><p>The path forward runs on two tracks at once, not one instead of the other:</p><p>① <strong>Early Warning</strong></p><ul><li>Glacier and ice-mass monitoring</li><li>Satellite remote sensing</li><li>Drone/UAV surveys of unstable slopes</li><li>River-level and flow sensors</li><li>Seismic monitoring</li><li>AI-based anomaly detection</li><li>LoRaWAN and resilient mesh networks</li><li>SMS, sirens, community alerts</li></ul><p>② <strong>Climate-Risk Reduction</strong></p><ul><li>Renewable electricity generation</li><li>Electric public transport and EVs</li><li>Energy-efficient buildings</li><li>Low-carbon, carbon-aware data centres</li><li>Efficient, renewably-powered cooling</li><li>Reduced fossil-fuel dependence</li><li>Forest and ecosystem protection</li><li>Climate-resilient infrastructure</li></ul><p><strong><em>Mitigation + Adaptation + Early Warning = Climate Resilience</em></strong></p><h3>Rethinking what “efficient” computing means</h3><p>For data centres, the industry has a chance to demonstrate that technology can shrink its own footprint rather than just monitor everyone else’s. The right question isn’t simply “how do we lower PUE” — it’s broader:</p><ul><li>↓ Lower total energy consumption.</li><li>↓ Lower carbon intensity of that electricity.</li><li>↓ Efficient processors and workload scheduling.</li><li>✓ Resilient, carbon-aware infrastructure.</li></ul><p>Waste-heat recovery, liquid cooling where appropriate, carbon-aware scheduling that shifts compute toward hours of cleaner grid supply, and continued renewable procurement all matter more than PUE alone because PUE says nothing about what’s actually generating the electricity in the first place.</p><h3>Nepal’s particular burden and opportunity</h3><p>Nepal is positioned, almost unfairly, at the front line of a crisis it did almost nothing to cause. The Himalayas supply water, biodiversity, hydropower and livelihoods to hundreds of millions of people, even as warming reshapes the cryosphere those systems depend on. The lesson from Rasuwa isn’t “install more flood sensors.” It’s:</p><p><em>We need both better sensors at the source of the hazard, and a far more serious global effort to cut the emissions reshaping the climate system that produces the hazard.</em></p><p>A sensor can tell communities that danger is coming. A warning system can help them escape. But only sustained, global emissions reduction can shrink the odds and severity of the next glacier collapse in the first place. Nepal can keep building the tools that protect people today — it cannot, on its own, slow the warming driving the risk tomorrow.</p><p><strong>The sequence climate technology is moving through:</strong></p><ol><li>Detection</li><li>Prediction</li><li>Warning</li><li>Adaptation</li><li>Prevention</li><li>Emission reduction</li></ol><p>We shouldn’t have to choose between early-warning systems and cutting carbon. We need both, moving at the same time: one saves people from today’s disaster, the other reduces the odds of tomorrow’s.</p><blockquote><em>Rasuwa is a warning in more ways than one.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=59a6d29dac56" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Livox MID360 and NVIDIA Jetson Nano: A Complete ROS Melodic Setup Guide]]></title>
            <link>https://medium.com/@ershrawan014/livox-mid360-and-nvidia-jetson-nano-a-complete-ros-melodic-setup-guide-1a3910f92a44?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a3910f92a44</guid>
            <category><![CDATA[robotics-operating-system]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[lidar-technology]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Wed, 08 Jul 2026 10:02:25 GMT</pubDate>
            <atom:updated>2026-07-08T10:02:25.396Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A field guide through every wall I hit dependency errors, the wrong ROS distro, broken package managers, and network configuration so you don’t have to hit them too.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L11YHIy4yZ3WXSZSMhLqJA.jpeg" /></figure><p>If you’ve searched for “Livox MID360 Jetson Nano ROS” expecting a clean, ten-minute setup, you’ve probably already discovered the truth: the official Livox documentation assumes a world where your Ubuntu version, your ROS distro, and your hardware architecture all line up perfectly. On a Jetson Nano, they usually don’t.</p><p>This post walks through the real troubleshooting path the errors, the wrong turns, and the fixes for getting livox_ros_driver2 building and talking to a MID360 sensor on a Jetson Nano running Ubuntu 18.04.</p><h3>The Setup</h3><ul><li><strong>Board: </strong>NVIDIA Jetson Nano</li><li><strong>OS: </strong>Ubuntu 18.04.6 LTS (Bionic Beaver): the version that ships with Jetson’s L4T-based images</li><li><strong>Target driver: </strong>livox_ros_driver2 (github.com/Livox-SDK/livox_ros_driver2)</li><li><strong>Sensor: </strong>Livox MID360</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/837/1*GAT--0jJL2TksJ3o87IgYA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*a4Xa61sedBkUr9vy9L0xBA.png" /></figure><h3>Methodology</h3><p>Rather than following the official docs top to bottom and hoping nothing breaks, this setup follows a diagnose-first methodology — check assumptions before installing anything, so failures point at a root cause instead of a symptom:</p><ol><li>Verify environment compatibility first. Confirm OS version and architecture (lsb_release -a, uname -m) before touching ROS at all. Most of the failures in this build trace back to skipping this step.</li><li>Match the ROS distro to the OS, not the other way around. Don’t try to force a ROS version onto an incompatible Ubuntu release — pick the ROS version the OS actually supports.</li><li>Resolve the package manager’s state before installing anything new. A half-finished apt/dpkg transaction will silently break every install after it until it’s explicitly repaired.</li><li>Build the sensor driver in isolation before wiring in the network. Get catkin_make to succeed with a placeholder config first, so build errors and network errors never get tangled together in the same debugging session.</li><li>Configure networking as its own discrete stage. Static IP on the host, broadcast-code-derived IP on the sensor, and the three driver config files are one cohesive unit of configuration — get all of it right together, then test end to end.</li><li>Validate with a visual sanity check. RViz showing a live point cloud is the real success criterion; a clean compile or a clean roslaunch with no errors is necessary but not sufficient.</li></ol><h3>System data flow</h3><p>Once every stage above is working, data moves through the system in one direction, sensor to application: the MID360 streams point cloud and IMU data over Ethernet to the Jetson Nano, where livox_ros_driver2 publishes it as standard ROS topics that any downstream node — RViz, a SLAM stack, a navigation planner — can subscribe to.</p><h3>Mistake #1: Assuming Noetic Will Just Work</h3><p>The natural first move is to clone the repo and follow the generic instructions:</p><pre>git clone https://github.com/Livox-SDK/livox_ros_driver2.git ~/ws_livox/src/livox_ros_driver2<br>cd ~/ws_livox/src/livox_ros_driver2<br>source /opt/ros/noetic/setup.sh<br>./build.sh ROS1</pre><p>This immediately breaks:</p><pre>bash: /opt/ros/noetic/setup.sh: No such file or directory</pre><p>The reason is architectural, not a typo: ROS Noetic only supports Ubuntu 20.04 (Focal). Jetson Nano’s stock JetPack image is Ubuntu 18.04 (Bionic), and ROS never published Noetic packages for Bionic — it’s not there to install, at any version or mirror.</p><p>Confirm your OS version before assuming otherwise:</p><pre>lsb_release -a</pre><p>If it says 18.04.6 LTS, Noetic is a dead end unless you reflash the board.</p><h3>Mistake #2: Trying to Force Noetic Anyway</h3><p>Even after realizing this, it’s tempting to try installing it directly:</p><pre>sudo apt install ros-noetic-desktop-full -y</pre><p>Result:</p><pre>E: Unable to locate package ros-noetic-desktop-full</pre><p>Checking the ROS source list confirms why:</p><pre>cat /etc/apt/sources.list.d/ros-latest.list<br># deb http://packages.ros.org/ros/ubuntu bionic main</pre><p>The repo is pinned to bionic and Noetic packages simply don’t exist for that codename on ROS’s package server. There’s no flag or workaround; it’s not published.</p><p><strong>The real choice at this point:</strong></p><ol><li>Reflash the Jetson Nano with an unofficial Ubuntu 20.04 image (community builds like Qengineering’s exist for this) to get genuine Noetic support at the cost of wiping the SD card.</li><li>Stay on 18.04 and use ROS Melodic instead. livox_ros_driver2 supports Melodic natively via the same ROS1 build argument, with no loss of functionality for this driver specifically.</li><li>For most people just trying to get a MID360 talking to a Jetson Nano, option 2 is the pragmatic choice.</li></ol><h3>Mistake #3: A Half-Finished apt Install</h3><p>Switching to Melodic isn’t automatically smooth either. A common snag:</p><pre>sudo apt install ros-melodic-desktop-full -y</pre><pre>E: dpkg was interrupted, you must manually run &#39;sudo dpkg --configure -a&#39; to correct the problem.</pre><p>This usually happens when a previous apt operation gets killed mid-install often due to the Nano running low on memory during dependency resolution. The fix:</p><pre>sudo dpkg --configure -a<br>sudo apt --fix-broken install -y<br>sudo apt update<br>sudo apt install ros-melodic-desktop-full -y</pre><p>If you’re on a 4GB Jetson Nano, it’s worth adding swap space before large installs like this one, since apt and later catkin_make can both be memory-hungry:</p><pre>sudo fallocate -l 4G /swapfile<br>sudo chmod 600 /swapfile<br>sudo mkswap /swapfile<br>sudo swapon /swapfile</pre><p>Once Melodic installs cleanly:</p><pre>source /opt/ros/melodic/setup.bash<br>cd ~/ws_livox/src/livox_ros_driver2<br>./build.sh ROS1</pre><p>If the Nano struggles during the C++17 compile (the driver requires it), cap parallel jobs to avoid the compiler getting OOM-killed:</p><pre>export MAKEFLAGS=&quot;-j2&quot;<br>./build.sh ROS1</pre><h3>Network Configuration: Getting the MID360 and Jetson to Actually Talk</h3><p>Building the driver is only half the job the MID360 communicates over raw Ethernet with a fixed IP scheme, and both sides need to agree on addresses.</p><h3>Step 1: Set a Static IP on the Jetson’s Ethernet Port</h3><p>The MID360 ships expecting a host in the 192.168.1.x subnet. On the Jetson, the GUI network settings don’t always bind cleanly to the right connection profile, so the more reliable route is nmcli:</p><pre>nmcli connection show</pre><p>Find the profile name tied to eth0 (e.g., “Wired connection 1”), then:</p><pre>sudo nmcli connection modify &quot;Wired connection 1&quot; ipv4.addresses 192.168.1.50/24<br>sudo nmcli connection modify &quot;Wired connection 1&quot; ipv4.method manual<br>sudo nmcli connection down &quot;Wired connection 1&quot;<br>sudo nmcli connection up &quot;Wired connection 1&quot;</pre><p>Confirm it took:</p><pre>ip addr show eth0</pre><p>You want to see inet 192.168.1.50/24 listed. If eth0 shows only an IPv6 link-local address, the static config hasn’t applied yet — this is exactly the failure mode that sends people back to the GUI in circles.</p><h3>Step 2: Find the MID360’s Broadcast Code</h3><p>Each MID360 unit has a 14-character broadcast code (format like 47MDL1C0010081), usually printed on a label on the sensor housing. The last two digits of that code determine the sensor’s expected IP address on the network: 192.168.1.1XX.</p><p>If the label isn’t accessible, alternatives include:</p><ul><li>Reading it from the box the unit shipped in.</li><li>Connecting the sensor to a PC running Livox Viewer 2, which auto-detects and displays it.</li><li>Launching the ROS driver with a placeholder config and checking the terminal log during device discovery — the broadcast code is typically printed there too.</li></ul><h3>Step 3: Update the Driver’s Config Files</h3><p>Three files need the IP values to match:</p><ul><li>livox_ros_driver2/config/MID360_config.json</li><li>livox_ros_driver2/launch_ROS1/rviz_MID360.launch</li><li>livox_ros_driver2/launch_ROS1/msg_MID360.launch</li></ul><p>The key section in MID360_config.json:</p><pre>{<br>  &quot;lidar_summary_info&quot;: {<br>    &quot;lidar_type&quot;: 8<br>  },<br>  &quot;MID360&quot;: {<br>    &quot;lidar_net_info&quot;: {<br>      &quot;cmd_data_port&quot;: 56100,<br>      &quot;push_msg_port&quot;: 56200,<br>      &quot;point_data_port&quot;: 56300,<br>      &quot;imu_data_port&quot;: 56400,<br>      &quot;log_data_port&quot;: 56500<br>    },<br>    &quot;host_net_info&quot;: [<br>      {<br>        &quot;lidar_ip&quot;: &quot;192.168.1.1XX&quot;,<br>        &quot;host_ip&quot;: &quot;192.168.1.50&quot;,<br>        &quot;cmd_data_port&quot;: 56101,<br>        &quot;push_msg_port&quot;: 56201,<br>        &quot;point_data_port&quot;: 56301,<br>        &quot;imu_data_port&quot;: 56401,<br>        &quot;log_data_port&quot;: 56501<br>      }<br>    ]<br>  },<br>  &quot;lidar_configs&quot;: [<br>    {<br>      &quot;ip&quot;: &quot;192.168.1.1XX&quot;,<br>      &quot;pcl_data_type&quot;: 1,<br>      &quot;pattern_mode&quot;: 0,<br>      &quot;extrinsic_parameter&quot;: {<br>        &quot;roll&quot;: 0.0,<br>        &quot;pitch&quot;: 0.0,<br>        &quot;yaw&quot;: 0.0,<br>        &quot;x&quot;: 0,<br>        &quot;y&quot;: 0,<br>        &quot;z&quot;: 0<br>      }<br>    }<br>  ]<br>}</pre><p>Replace 192.168.1.1XX with the sensor’s actual IP derived from its broadcast code in both places — host_net_info and lidar_configs. This value isn’t arbitrary; it must match the real hardware, or the driver will fail to discover the sensor and you’ll just see connection timeouts with no data.</p><p>host_ip stays as 192.168.1.50 to match the static IP set on the Jetson in Step 1.</p><h3>Running It</h3><p>With the workspace built and configs updated:</p><pre>cd ~/ws_livox<br>source /opt/ros/melodic/setup.bash<br>catkin_make</pre><p><strong>Terminal 1: Start the LiDAR driver:</strong></p><pre>cd ~/ws_livox/<br>source devel/setup.bash<br>roslaunch livox_ros_driver2 msg_MID360.launch</pre><p><strong>Terminal 2: Visualize in RViz:</strong></p><pre>cd ~/ws_livox/<br>source devel/setup.bash<br>roslaunch livox_ros_driver2 rviz_MID360.launch</pre><p>If RViz opens but shows no point cloud, the usual suspects are: an IP mismatch between the config and the sensor’s real broadcast code, the Ethernet cable not seated before power-on, or a typo in the last two digits derived from the broadcast code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7NPdavnCvzMnq6hsqxCiUg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ac3nzN3l_QJcsbIO-iOc9g.png" /></figure><h3>Why Bother: Use Cases for This Edge Combination</h3><p>The Jetson Nano plus MID360 pairing shows up often in robotics and perception projects because it hits a specific price/performance/power point: a real 360°-class solid-state LiDAR feeding a small, low-power board that can run ROS and basic perception locally, without needing a full PC or a cloud round-trip. Some of the places this combination is actually used:</p><ul><li><strong>Autonomous mobile robots (AMRs) and indoor delivery bots. </strong>The MID360’s wide field of view gives near-complete coverage from a single sensor, and the Nano handles local obstacle detection and point-cloud-to-costmap conversion for navigation stacks like move_base or Nav2, without depending on a network connection back to a server.</li><li><strong>Drone and UAV obstacle avoidance. </strong>The MID360 is light and low-power enough for small UAV payloads, and an edge board processes the point cloud onboard for real-time avoidance — critical when latency to an offboard computer isn’t acceptable.</li><li><strong>3D mapping and surveying rigs. </strong>Portable scanning rigs pair a LiDAR with a small onboard computer to log point cloud and IMU data directly to storage in the field, with the heavier SLAM/registration processing done later offline.</li><li><strong>Precision agriculture. </strong>Mounted on a ground vehicle, the sensor’s coverage supports row detection, crop-height estimation, and obstacle sensing for autonomous farm equipment operating in unstructured outdoor terrain.</li><li><strong>Perimeter security and intrusion detection. </strong>A fixed MID360 with an edge board can run basic intrusion or loitering detection locally and only send alerts (not raw point clouds) over the network, reducing bandwidth needs versus streaming everything to a central server.</li><li><strong>Warehouse and logistics robotics. </strong>AMRs in warehouses use the sensor for localization and dynamic obstacle avoidance around forklifts, pallets, and people, with the Nano acting as the always-on perception front-end feeding a higher-level planner.</li><li><strong>Research and education platforms. </strong>Because ROS drivers exist for both Melodic and Noetic, and the Nano is inexpensive relative to industrial compute units, this pairing is a common teaching/prototyping platform for students and labs working on SLAM, sensor fusion, or robotic perception before scaling up to more powerful hardware.</li></ul><p>The common thread across all of these: the Nano isn’t trying to run heavy SLAM or deep learning inference by itself in most of these cases it’s the edge front-end that handles driver-level sensor I/O and lightweight processing, while heavier computation either runs on a more powerful onboard companion computer or offline. That division of labor is exactly why getting the driver and networking layer right the part covered in this post matters so much: everything downstream depends on this layer working cleanly first.</p><h3>Takeaways</h3><ul><li><strong>Check your OS-to-ROS-distro compatibility before anything else. </strong>Ubuntu 18.04 → Melodic. Ubuntu 20.04 → Noetic. There’s no in-between, and apt errors around “unable to locate package” almost always trace back to this mismatch.</li><li><strong>A stalled apt install on a memory-constrained board (like the Nano) leaves dpkg in a broken state — </strong>sudo dpkg — configure -a is the fix, and swap space prevents a repeat.</li><li><strong>livox_ros_driver2 doesn’t care whether you’re on Melodic or Noetic — </strong>both work fine via the same ROS1 build argument, so there’s rarely a reason to force a risky OS reflash just to chase Noetic specifically.</li><li><strong>Network configuration is where most “silent failures” happen. </strong>The host IP, the sensor IP derived from the broadcast code, and the config files all have to agree — get any one wrong and you’ll get a clean-looking launch with zero data.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a3910f92a44" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From On-Prem to Cloud: OpenStack for Research and Innovation]]></title>
            <link>https://medium.com/@ershrawan014/from-on-prem-to-cloud-openstack-for-research-and-innovation-ccf1d4ceb093?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/ccf1d4ceb093</guid>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[innovation]]></category>
            <category><![CDATA[openstack-private-cloud]]></category>
            <category><![CDATA[research]]></category>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Thu, 25 Dec 2025 13:33:40 GMT</pubDate>
            <atom:updated>2025-12-25T13:33:40.328Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MhsNwY8PWUD7zSBZBTaF-Q.png" /><figcaption><a href="https://www.openstack.org/">https://www.openstack.org</a></figcaption></figure><p><strong>Introduction</strong></p><p>The purpose of this initiative is to leverage <strong>OpenStack</strong>, an open-source cloud platform, to create an <strong>institution-led cloud and datacenter ecosystem</strong>.</p><p>This initiative serves multiple goals:</p><ul><li>Academic research and laboratory hosting</li><li>Learner skill development and professional certification</li><li>Commercial cloud services for startups, enterprises, and government</li><li>Revenue generation and strategic positioning</li></ul><p>By implementing OpenStack within an <strong>academic and research environment</strong>, the institution can transition from a <strong>cloud consumer to a cloud provider</strong>, creating a unique value proposition at both local and regional levels.</p><p><strong>About OpenStack:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SqImkbmUJxwhcJu7.png" /></figure><p>OpenStack is a cloud operating system that controls large pools of compute, storage, and networking resources throughout a datacenter, all managed and provisioned through APIs with common authentication mechanisms.</p><p>Dashboards are also available, giving administrators control while empowering their users to provision resources through a web interface. There are OpenStack CLI tools and SDKs giving operators the flexibility to create OpenStack cloud applications in the language of their choice. Supported languages include Go, Python, Ruby, and Java.</p><p>Beyond standard infrastructure-as-a-service functionality, additional components provide orchestration, fault management and service management amongst other services to provide operators flexibility to customize their infrastructure and ensure high availability of user applications.</p><p>OpenStack is an <strong>open-source cloud platform</strong> providing scalable compute, storage, and networking resources.</p><ul><li><strong>Components:</strong> Nova (compute), Neutron (networking), Cinder/Swift (storage), Keystone (identity), Horizon (dashboard).</li><li><strong>Capabilities:</strong> Multi-tenancy, automation, self-service provisioning, security, and data sovereignty.</li><li><strong>Use Case in University:</strong> Hosting virtual labs, research workloads, AI/ML compute, private cloud services, and commercial offerings.</li></ul><p><strong>Participate in the community and Scientific Working Group</strong></p><p>The meaning of openness for OpenStack is prescribed by the Four Opens: open source, open design, open development, and open community. Community development and collaboration is a defining OpenStack value for global science organizations. Scientists, faculty, <strong>HPC engineers</strong>, operators and developers from academia and leading-edge businesses are fully engaged in the vibrant Scientific OpenStack community.</p><p><strong>Members of scientific organizations collaborate in various ways:</strong></p><ul><li>OpenStack User Committee mailing list, using [Scientific] in the subject</li><li>Internet Relay Chat (IRC)</li><li>The OpenStack Scientific Working Group</li></ul><p>The Working Group represents and advances the use cases and needs of research and high-performance computing at top OpenStack.</p><h3><strong>Virtualized HPC on OpenStack at Monash University:</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UY_vUFOQFigaVRMfi_BiWw.png" /></figure><p>From its inception in 2012, Australian scientific research has benefited from the NeCTAR Research Cloud federation. Now comprising eight institutions from across the country, NeCTAR was an early adopter of OpenStack and has been at the forefront of development of the project from that moment. NeCTAR’s federated cloud compute infrastructure supports a wide range of scientific research with diverse requirements. Monash Advanced Research Computing Hybrid (MonARCH) was commissioned in 2015/2016 to provide a flexible and dynamic HPC resource. MonARCH has 35 dual socket Haswell-based compute nodes and 820 CPU cores. MonARCH exploits cloud-bursting techniques to grow elastically by using resources from across the NeCTAR federation. The infrastructure uses a fabric of 56G Mellanox Ethernet for a converged, high-speed network. The cloud control plane is running Ubuntu Trusty and the KVM hypervisor. OpenStack Liberty (as of Q3’2016) was deployed using Ubuntu distribution packages (including selected patches as maintained by NeCTAR Core Services), orchestrated and configured using Puppet. MonARCH makes extensive use of SR-IOV for accessing its HPC network fabric.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JFyq1sXhRvQoSVFAfnA06g.png" /><figcaption><a href="https://www.monash.edu/researchinfrastructure/eresearch/capabilities/computing">High-performance computing — Monash eResearch</a></figcaption></figure><p>The high-speed network is configured to use VLANs for virtual tenant networking, enabling layer-2 RoCEv1 (RDMA over Converged Ethernet). RDMA is used in guest instances in support of tightly coupled parallel MPI workloads, and for high-speed access to 300TB of Lustre storage. Following MonARCH, Monash University recently built a mixed CPU &amp; GPU cluster called M3, the latest system for the MASSIVE (Multi-modal Australian ScienceS Imaging and Visualisation Environment) project. Within M3, there are 1700 Haswell CPU cores along with 16 quad-GPU compute nodes and an octo-GPU compute node, based upon the NVIDIA K80 dual-GPU. Staff at Monash University’s Research @ Cloud Monash (R@CMon) cloud research group have integrated SR-IOV networking and GPU pass-through into their compute instances.</p><h3>Virtualized <strong>HPC </strong>on <strong>OpenStack</strong> at <strong>University of CAMBRIDGE:</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xftmh3CzUgDfBgVLkPySTw.png" /><figcaption><a href="https://www.hpc.cam.ac.uk/scientific-openstack">Scientific OpenStack | Research Computing Services</a></figcaption></figure><p>Scientific OpenStack is a cloud computing platform that is designed to support scientific research and data-intensive applications. Scientific OpenStack is a variant of OpenStack that is customised to meet the specific needs of scientific research and development. Research and scientific disciplines were some of the earliest and most prevalent use cases for OpenStack clouds and OpenStack today provides compelling solutions for the challenges of delivering flexible infrastructure for high-performance computing (HPC) and high-throughput computing (HTC), with the development community rapidly expanding existing and new services to meet future demands.</p><p>Scientific OpenStack provides a range of features and tools that enable researchers to store, manage, and perform complex analysis of large volumes of data. Some of the key features of Scientific OpenStack include:</p><p><strong>High-performance computing capabilities</strong> — Scientific OpenStack is designed to support high-performance computing workloads, such as simulation and modelling, data analysis, and machine learning.</p><p><strong>Customisable infrastructure: </strong>Scientific OpenStack allows researchers to customise the infrastructure to meet their specific needs, including compute, storage, and networking resources.</p><p><strong>Containers: </strong>Scientific OpenStack supports containerization technologies such as Docker and Kubernetes.</p><p><strong>Security: </strong>Scientific OpenStack is designed to meet the highest standards of data security and confidentiality.</p><p>An OpenStack cloud (named ‘Arcus’) is currently the base infrastructure provider for all services deployed by the Research Computing division at the West Cambridge Data Centre, including provisioning of new high-performance CSD3 HPC clusters, Secure Research Computing environments, storage, hypervisor and web application platform services.</p><h3>Cambridge University opens new horizons with software-defined telescope, bioinformatics research</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-aOvhGnVNKPckTp1JSsuzQ.png" /></figure><p>One of the world’s oldest universities is looking to the future with OpenStack.</p><p>The alma mater of Isaac Newton and Francis Bacon is not resting on its laurels. From the mid-20th century, the University of Cambridge has pioneered the use of computing in fields like radio astronomy and biology. More recently, the University has driven the use of commodity x86–64 HPC clusters to support a wide research base across many scientific disciplines.</p><p>The research university, founded in 1209, now has its sights set on continuing this endeavor on the frontiers of space and translational medicine. OpenStack has an opportunity to play a big role in these potentially life-changing discoveries.</p><p>Jonathan Bryce and I recently had a chance to visit the campus and meet Dr. Paul Calleja, deputy director, research and institutional services, whose team provides research computing services for the university while also supporting research projects with high performance computing (HPC) and big data solutions. They currently have 665 active users across nearly 200 research projects, growing at a rate of 40 percent per year. Their approach is to design, implement and support their own solutions rather than getting locked into inflexible, purpose-built hardware. OpenStack will be tapped for a variety of use cases, including research computing and storage infrastructure as a service, application development, HPC as a service and HDPA as a service (such as hadoop and machine learning infrastructure).</p><h4>Harnessing big data for health:</h4><p>Dr. Lydia Drumright, university lecturer in clinical informatics, also spoke to us about her vision for correlating gene sequencing insights with clinical patient data to deliver real-time recommendations to doctors. For example, in Iowa, Dr. John Cromwell has created a model to reduce post-op infections by 58 percent by changing treatment in real-time based on models created from patient data to predict post-operative infection.</p><p>Interestingly, the cost of gene sequencing has dropped dramatically over the last few years. While the cost of computing has also come down, the lower cost of genome sequencing has provided so much genomic data that is has become prohibitive to analyze and correlate it all. And while gene sequencing data on its own delivers insights, it’s even more powerful when you can annotate the sequenced genes (essentially add metadata), which can be correlated with real clinical patient data for real-time intervention into patient care.</p><p><strong>Deep space diving</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oOpi3vROgsZcVTnb-bqTCg.png" /><figcaption><a href="https://superuser.openinfra.org/articles/cambridge-openstack/?_ga=2.141953522.1702474440.1766666671-572183868.1762569704">Cambridge University opens new horizons with software-defined telescope, bioinformatics research — Superuser</a></figcaption></figure><p>Looking a bit farther into the future (and more pertinently the past), Cambridge physics professor Paul Alexander are helping drive forward the Square Kilometer Array (SKA) project, a software-defined telescope which will allow us to see deeper into space than ever before, exploring the origins of galaxy formation and dark matter, the nature of black holes and exploring fundamental building-blocks of life from extraterrestrial radio signals. The physical receivers will be located in Western Australia and South Africa, with a large cloud for analyzing data in Regional Science Centres (RSC) across the globe. It’s backed by numerous countries with a €650-million euro budget for the initial construction phase, expected to be completed and online in 2023.</p><p>The SKA team is examining other open source technologies, such as big data frameworks like Spark, which offers us a big opportunity to collaborate with those communities around a common goal. Ultimately, for economics, flexibility and speed, the SKA team wants to rely on a distributed system on commodity gear, not a converged appliance. OpenStack has a huge opportunity to power this research, but the community will need to continue to incorporate recommendations of the Scientific Working Group, and others.</p><h3>Advancing <strong>HPC</strong> Research Infrastructure with <strong>OpenStack:</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*syqb91f3bSNp9plXEIkmWw.png" /><figcaption><a href="https://thesai.org/Publications/ViewPaper?Volume=3&amp;Issue=4&amp;Code=SpecialIssue&amp;SerialNo=8">Advancing Research Infrastructure Using OpenStack</a></figcaption></figure><p><strong>BRIGHT COMPUTING CLUSTER ON DEMAND:</strong></p><p>Bright Computing has developed its proprietary products for HPC cluster management and adapted them for installation, configuration and administration of OpenStack private clouds. The solution is capable of partitioning a system into a mix of bare metal HPC compute and OpenStack private cloud.</p><p><strong>COMBINING THE STRENGTHS OF CLOUD WITH HPC WORKLOAD MANAGEMENT:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CBsUwHychYwtkX2ESIOqsw.png" /></figure><p>Randles’s solution was to use OpenStack Glance as a portal between the user’s development environment on their workstation and the HPC cluster. Compared with the previous approach, the Glance API was accessible from both the user’s workstation and the HPC cluster management environment. The images stored in Glance were backed up, and OpenStack’s user model provided greater flexibility than traditional UNIX users and groups, enabling fine-grained control over the sharing of application images.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sRmdW9lUO5U-DYUhCJEw2g.png" /></figure><p>OpenStack delivers new capabilities to flexibly manage compute clusters as on demand resources. The ability to define a compute cluster and workload manager through code, data and configuration plays to OpenStack’s strengths. With the exception of some niche high-end requirements, OpenStack can be configured to deliver CaaS with minimal performance overhead compared with a conventional bare metal HPC resource.</p><p><strong>OpenStack for AI: Scalable, Open Infrastructure for Next-Gen Workloads</strong></p><p>Infrastructure requirements for AI workloads are growing rapidly in both complexity and scale. OpenStack’s advantage in meeting these demands lies not only in its mature, modular codebase but also in its open, community-driven development model. Unlike proprietary platforms, OpenStack is engineered by the same community that deploys and operates it in production. This enables rapid iteration and implementation of emerging capabilities, such as multi-tenant GPU scheduling, NUMA-aware placement, and agent-to-agent protocol support for distributed LLM orchestration, without waiting on a vendor-controlled roadmap.</p><p>As AI workloads become increasingly resource-intensive and latency-sensitive, OpenStack continues to provide a robust virtualization and infrastructure abstraction layer, capable of supporting high-throughput, heterogeneous compute environments through services like Nova, Neutron, Cinder, and Ironic. Its proven scalability and extensibility make it well-suited for the next generation of AI and HPC workloads.</p><p>The OpenStack community collaborated to deliver the architectural and technology impact of using OpenStack to support AI workloads in a new white paper: Open Infrastructure for AI: OpenStack’s Role in the Next Generation Cloud.</p><h3>OpenStack for Scientific Research</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*YpQLHzNfN__tr-5nkLihjA.png" /></figure><p>Research and science disciplines are some of the earliest and most prevalent use cases for OpenStack clouds. OpenStack provides compelling solutions today for the challenges of delivering flexible infrastructure for high-performance computing (HPC) and high-throughput computing (HTC), and the development community is rapidly expanding services to meet exponential future demands.</p><p>OpenStack progress is driven by the astonishing pace of new research projects in radio telemetry, bioinformatics, astronomy, cancer and genome research, and more. One such project, the multinational Square Kilometre Array (SKA) radio telescope, will probe deeper into space and further back in time, to unlock the secrets of phenomena such as pulsars, gravity, and the cosmic dawn.</p><p>Evolving research cloud federations span geographies and organizations offering secure, tailored, self-service compute power, high-volume data access and collaboration to researchers around the world.</p><p>Explore how OpenStack is bringing the benefits of cloud and federation to HPC workloads in the second edition of “OpenStack for Scientific Research.”</p><h3>Edge Computing: Next Steps in Architecture, Design and Testing</h3><p><a href="https://www.openstack.org/use-cases/edge-computing/edge-computing-next-steps-in-architecture-design-and-testing/">Edge Computing: Next Steps in Architecture, Design and Testing — OpenStack is open source software for creating private and public clouds.</a></p><p>While edge computing has rapidly gained popularity over the past few years, there are still countless debates about the definition of related terms and the right business models, architectures and technologies required to satisfy the seemingly endless number of emerging use cases of this novel way of deploying applications over distributed networks.</p><p>In these types of infrastructures, there is no one well defined edge; most of these environments grow organically, with the possibility of different organizations owning the various components. For example, a public cloud provider might supply some of the core infrastructure, while other vendors are supplying the hardware, and yet a third set of integrators are building the software components. Trying to create a one size fits all solution is impossible for edge use cases due to the very different application needs in various industry segments. Interestingly, while cloud transformation started later in the telecom industry, operators have been pioneers in the evolution of cloud computing out to the edge. As owners of the network, telecom infrastructure is a key underlying element in edge architectures.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e2EKmQgXaP7Pzd4SVTLtEQ.png" /></figure><p>After four years, while there is no question that there is continuing interest in edge computing, there is little consensus on a standard edge definition, solution or architecture. That doesn’t mean that edge is dead. Edge must be by its very nature highly adaptable. Adaptability is crucial to evolve existing software components to fit into new environments or give them elevated functionality. Edge computing is a technology evolution that is not restricted to any particular industry. As edge evolves, more industries find it relevant, which only brings fresh requirements or gives existing ones different contexts, attracting new parties to solve these challenges. Now more than ever, edge computing has the promise for a very bright future indeed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*duhDSthtpdoi3w1khZek7Q.png" /></figure><h4>Content Caching at the Edge</h4><p>Reducing backhaul and latency metrics and improving quality of service (QoS) are good reasons for pushing content caching and management out to the network edge. A caching system can be as simple as a basic reverse-proxy or as complex as a whole software stack that not only caches content but provides additional functionality, such as video transcoding based on the user equipment (UE) device profile, location and available bandwidth.</p><p>Content delivery networks (CDN) are not a new concept. However, the creation of more CDN nodes with regional points of presence (PoP) are one of the first examples of what can now be considered near-edge-computing. With the explosion of video streaming, online gaming and social media, combined with the roll-out of 5G mobile networks, the need to push caching out to the far-edge has increased dramatically. The “last-mile” must become increasingly shorter to meet customer demand for better performance and user experience with these applications that are highly sensitive to network latency. This is encouraging content providers to migrate from a traditional, regional PoP CDN model to edge-based intelligent and transparent caching architectures.</p><h3>Manufacturing in the Digital Era</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kXkx5DdHMRgIJuUDWOZpcQ.png" /></figure><p>Industry 4.0 is often identified with the fourth industrial revolution. The concept is that factories are using computers and automation in new ways by incorporating autonomous systems and machine learning to make smarter factories. This paradigm shift includes the use of open hardware and software components in the solutions.</p><p>Factories are using more automation and leveraging cloud technologies for flexibility, reliability and robustness, which also allows for the possibility of introducing new methods such as machine vision and learning to increase production efficiency. The amount of data processing and computational power needed to support these technologies is increasing by orders of magnitude. Many applications move the data from the factory floor to a public or private cloud, but in many cases the latency impacts and transmission costs can lead to disruptions on the assembly line. To fulfill the high performance and low latency communication needs, at least some of the data processing and filtering needs to stay within the factory network, while still being able to use the cloud resources more effectively. Further processing of the data collected by various sensors is done in the centralized cloud data center. Reusable portable microservices located at the edge nodes fulfill tasks that are part of new vision applications or deep learning mechanisms.</p><p>Similarly to the telecommunication industry, manufacturing also has very strict requirements. To fulfill the control systems’ real-time and functional safety needs, they can use technologies such as Time Sensitive Networking (TSN) on the lower layers of the architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ko94SEXWzqiOd7QwZmtGVw.png" /></figure><p>Some of the system functions and elements that need to be taken into consideration include:</p><ul><li><strong>Environmental monitoring</strong>, including data collection and reporting of metrics such as: outdoor temperature and humidity, water quality, PH value and temperature, dissolved oxygen, ammonia, nitrogen, and nitrite</li><li><strong>Video surveillance</strong> for illegal intrusion detection and compliance identification of staff using clothing and face recognition</li><li><strong>Smart breeding</strong> that includes automated feeding and inventory tracking (food, medicine, auxiliary materials, disinfectant and so forth)</li><li><strong>Platform traceability</strong> to query and display the entire supply chain to ensure high quality of aquatic products</li></ul><p>By automating and connecting these farms, the solution minimizes the isolation that exists in this industry. The platform provides data to be collected and analyzed both locally on the farms and centrally to improve the environmental conditions and prevent mistakes while using chemicals like auxiliary materials and disinfectants.</p><p>With more computational power at the edge data centers, it is possible to store and analyze local monitoring data for faster reaction time to manage changes in environmental conditions or modify feeding strategy. The system can also pre-filter data before sending it to the central cloud for further processing. For instance, the system can pre-process water quality data from the monitoring sensors and send structured information back to the central cloud. The local node can provide much faster feedback compared to performing all operations in the central cloud and sending instructions back to the edge data centers.</p><h3>Conclusion:</h3><p>Implementing OpenStack is a <strong>proven strategic initiative</strong>, not just an infrastructure upgrade. Widely adopted by leading academic and research institutions, it supports teaching labs, HPC, and research clouds, demonstrating strong technical maturity and scalability.</p><p>OpenStack enables <strong>hands-on cloud learning and advanced research</strong> across AI, data science, cybersecurity, and engineering. When extended to <strong>edge and IoT environments</strong>, it supports modern use cases such as smart systems, real-time analytics, and distributed AI through a hybrid cloud–edge architecture.</p><p>Beyond research and education, OpenStack fosters <strong>talent development, professional certification, and sustainable revenue opportunities</strong> through cloud services, partnerships, and training programs. Overall, it positions institutions as <strong>trusted cloud and edge service providers</strong>, driving innovation, competitiveness, and long-term digital transformation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ccf1d4ceb093" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How far can it go? Range testing of the Ai-Thinker Ra-02 LoRa/FSK/00K Module]]></title>
            <link>https://medium.com/@ershrawan014/how-far-can-it-go-range-testing-of-the-ai-thinker-ra-02-lora-fsk-00k-module-2caae12420bd?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/2caae12420bd</guid>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Thu, 02 Oct 2025 15:11:49 GMT</pubDate>
            <atom:updated>2025-10-02T15:13:50.388Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LqnzdkiAGEnOHFD6" /></figure><p>The RA-02 by Ai-Thinker is a compact ISM-band LoRa transceiver module (410 MHz to 525 MHz).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/369/1*tslO4kBYYL8EyTEqRZUH7Q.jpeg" /></figure><p>It is designed for low-power, long-range wireless communication in IoT, sensor networks, and remote monitoring systems. Below are its key specifications and features:</p><p><strong>Overview</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jcZxWeXXBlI1FuPdKhmYVw.jpeg" /><figcaption>Ra-02 Ai-Thinker</figcaption></figure><ul><li>Product Type: RF Transceiver Module (ISM band, &lt;1 GHz)</li><li>Protocol / Modulation: LoRa, FSK, GFSK, GMSK, MSK, OOK</li><li>Frequency Range: 410 MHz to 525 MHz</li><li>RF Output Power: up to 18 dBm</li><li>Receiver Sensitivity: down to –141 dBm</li><li>Data Rate: Up to 300 kbps</li><li>Serial Interface: SPI</li><li>Antenna Connection: I-PEX connector</li></ul><p><strong>Power</strong></p><ul><li>Supply Voltage: 2.5 V to 3.7 V</li><li>Current Consumption (Receive): ~12.15 mA</li><li>Current Consumption (Transmit): 93 mA to 97 mA (at maximum output)</li></ul><p><strong>Introduction</strong></p><p>The Internet of Things (IoT) is growing quickly, and people are finding new ways to use it all the time. Some examples are healthcare, satellite communications, unmanned aerial vehicles, and industrial automation. IoT technologies must also meet strict standards for power use, quality of service (QoS), and transmission distances.</p><p>LPWAN is a type of network that works with a lot of different IoT setups. It connects over long distances and uses little power, making it cheap to run and keep up with. Long-range (LoRa) technology is one of the best LPWAN technologies because it lets you send and receive messages over long distances with low power and low rates. A lot of research has been done on it, which has helped businesses grow.</p><p>LoRa sends symbols that are frequency chirps that cover the whole available bandwidth using chirp spread spectrum (CSS) modulation. The spreading factor (SF) is what determines how much LoRa gains. Setting the SF correctly can help you find the best balance between the data rate and the range of transmission.</p><p>A higher SF makes the transmission range longer but the data rate slower. LoRaWAN’s medium access control (MAC) layer usually uses an ALOHA-based method. The LoRa transmitter sends packets at random times, which causes interference because the packets hit each other.</p><p>There are two main types of interference in LoRa systems: co-SF interference, which happens between end-devices that use the same SF, and inter SF interference, which happens between end-devices that use different SFs. Because LoRa has a spread spectrum feature, these two types of interference are unavoidable.</p><p>This is likely to have a bad effect on LoRaWAN coverage and throughput performance as the number of LoRa devices and the amount of traffic they handle grows. This is what will happen with IoT apps in the future.</p><p><em>Credit</em>: <a href="https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&amp;arnumber=10531262&amp;isnumber=10721242">https://ieeexplore.ieee.org/stamp/stamp.jsptp=&amp;arnumber=10531262&amp;isnumber=10721242</a></p><p>Long Range (LoRa) technology has become one of the most important wireless communication methods for Internet of Things (IoT) applications. LoRa allows devices to send and receive data over long distances while using very low power.</p><p>This makes it perfect for projects where devices need to work for months or years without changing batteries.</p><p>LoRa works without needing an internet connection, which makes it very useful in places where internet is not available.</p><p>In this project, we tested how well two LoRa Module Ra-02 modules can communicate with each other. One module acts as a transmitter and the other as a receiver.</p><p>When an obstacle is detected by an IR sensor connected to the transmitter, it sends a signal to the receiver, which then turns on an LED and buzzer to show that the message was received.</p><p>Working Mechanism of LoRaWAN</p><p>LoRaWAN (Long Range Wide Area Network) is part of a bigger family called LPWAN (Low Power Wide Area Network). LPWAN technologies are designed to send small amounts of data over very long distances while using very little power. Think of LPWAN as a big family of wireless technologies, and LoRaWAN is one of the most popular members of this family.</p><p>LoRaWAN works by using special radio waves that can travel much farther than Wi-Fi or Bluetooth. It can send data up to 15 kilometers in open areas and several kilometers in cities. The technology uses something called “spread spectrum modulation” which helps the signal stay strong even when there are obstacles like buildings or trees in the way. This makes LoRaWAN perfect for smart cities, farms, and industrial monitoring where devices are spread across large areas.</p><h4><strong>What We Did at the Transmitter End</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nfOhDSV0St5BZcCuTNnLfA.png" /><figcaption>Tx</figcaption></figure><p>At the transmitter end, we used a NodeMCU 8266 microcontroller as the main brain of our system. We connected a LoRa Ra-02 module to this microcontroller using Serial Peripheral Interface (SPI) communication. The Ra-02 module works at 433MHz frequency and can transmit data up to 15 kilometers away under good conditions.</p><p><strong>Factors Affecting Range:</strong></p><ul><li>Antenna quality and placement</li><li>Transmission power (up to 100 mW for Ra-02)</li><li>Data rate / spreading factor</li><li>Obstacles (buildings, trees, terrain)</li></ul><p>We also connected an IR (Infrared) sensor to detect obstacles. When an object comes close to the IR sensor, it sends a LOW signal to the NodeMCU. The NodeMCU then tells the LoRa module to send a message to the receiver. The whole transmitter system is powered by 3.3V, which is perfect for long battery life.</p><h4>What We Did at the Receiver End</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*THCWOtIs1KBuEVuLjsRC6w.png" /><figcaption>Rx</figcaption></figure><p>The receiver setup is very similar to the transmitter.</p><p>We used another NodeMCU 8266 connected to a LoRa Ra-02 module. But instead of an IR sensor, we connected an LED and a buzzer to show when a message is received.</p><p>When the LoRa module receives a signal from the transmitter, the NodeMCU immediately turns on the LED and makes the buzzer sound. This tells us that the communication was successful, and the obstacle detection message was received properly.</p><p><strong>Smart Alert System Using LoRa</strong></p><p>We made a simple alert system that works wirelessly. An infrared (IR) sensor is used on the transmitter side to detect if there is an obstacle in front of it.</p><p>When an obstacle is found, it sends a signal through the LoRa module. On the receiver side, when this signal is received, a buzzer makes a sound and a light glow to give an alert. This way, without using any wires between the two devices, we can send a warning message from one place to another. It is like a smart communication system where one device detects an obstacle, and another device shows the alert.</p><p><strong>Transmitter Code (NodeMCU + LoRa + IR Sensor)</strong></p><p>This part uses the IR sensor to check for obstacles. If something is detected, it immediately sends a message through the LoRa module to the receiver.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pg4w5QFD3xM9MNWbYJIIpw.png" /></figure><p><strong>Receiver Code (NodeMCU + LoRa + LED + Buzzer)</strong></p><p>This part of the project waits for a signal from the transmitter. When a message is received, the LED and buzzer are turned on for one second to give a clear alert.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/1*TYCS25JImXd_xY2XqLZJQg.png" /></figure><p><strong>OUTPUT</strong></p><p>When the IR sensor detects an obstacle, the transmitter sends the word “OBSTACLE” to the receiver. As soon as the receiver gets it, the LED glows and the buzzer make a sound for one second. This shows how the system can alert people wirelessly when an object or obstacle is present.</p><p><strong>At transmitter side (IR sensor + NodeMCU + LoRa):</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/0*JLVhwHIlVesRox1t" /></figure><p><strong>At receiver side (NodeMCU + LoRa + LED + Buzzer):</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/702/0*ht7SpyzOTqsFBMi3" /></figure><p><strong>Real Field Testing</strong></p><p>We conducted two main tests to see how powerful LoRa communication really is. In our first test, we placed the transmitter and receiver ~500 meters apart, but the environment was not an open field there were buildings, trees, and passing cars in between. When an object was detected by the IR sensor, the signal was transmitted and received in less than one second. This shows that LoRa is very fast for sending simple messages.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uGdz658cmGC1ObLw20rAaA.png" /></figure><p>In our second test, we wanted to see how well LoRa works through obstacles. We placed the transmitter on the fourth floor of a building and the receiver on the ground floor. Even with concrete walls, floors, and other obstacles between them, the signal still got through successfully.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PRSqklfc8X4MxxZn" /></figure><p>When an object was detected, the LED on the ground floor lit up and the buzzer sounded in less than 1 second. This proves that LoRa signals are very good at going through buildings and obstacles.</p><p>When we tried to increase the distance beyond 600 meters, we noticed that the latency (delay time) increased slightly, but the communication still worked well. This is normal because radio signals take more time to travel longer distances and may need to be sent multiple times to make sure, they arrive safely.</p><p>The main reason we chose LoRa for this project is that it provides wireless communication without needing any network infrastructure like Wi-Fi or cellular towers.</p><p>This makes it perfect for remote areas, emergency situations, or places where internet is expensive or unreliable. LoRa can be used for many applications like monitoring farms, tracking vehicles, measuring water levels, and creating smart city systems.</p><p><strong>How Ai Thinker Series LoRa Ra-08H Can Help When Latency Increases</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*OHuUYci_nn0mZH68" /></figure><p>When distances get very long and latency starts to increase, the newer Ra-08H modules can provide better performance than Ra-02. The Ai Thinker LoRa Series Ra-08H works at higher frequencies (803MHz to 930MHz) compared to Lora Ra-02 (410MHz to 525MHz). Higher frequencies can carry data faster and with less delay, which helps reduce latency problems.</p><p>The Ai Thinker LoRa Series Ra-08H also has better sensitivity (-138dBm) and higher transmit power (+22dBm) compared to some other modules. This means it can detect weaker signals and send stronger signals, which helps communication work better over long distances.</p><p><strong>Conclusion</strong></p><p>Our testing shows that LoRa Ra-02 communication is very reliable and powerful for wireless projects. We successfully demonstrated communication at ~500 meters with less than 1 second latency, and even through multiple floors of a building.</p><p>The combination of NodeMCU 8266, LoRa Ra-02 modules, and simple sensors like IR creates a robust system for obstacle detection and wireless communication. LoRa technology is excellent for IoT projects because it works without internet, uses very little power, and can communicate over very long distances. For projects that need even better performance at longer distances, upgrading to Ra-08H modules can help reduce latency and improve signal strength. This makes LoRa perfect for many real-world applications where reliable wireless communication is needed without depending on expensive network infrastructure.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2caae12420bd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI-Powered Tomato Harvesting Robot: The Future of Smart Farming]]></title>
            <link>https://medium.com/@ershrawan014/ai-powered-tomato-harvesting-robot-the-future-of-smart-farming-380ea5675534?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/380ea5675534</guid>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Mon, 08 Sep 2025 11:56:20 GMT</pubDate>
            <atom:updated>2025-09-08T11:56:20.182Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How computer vision and edge computing are revolutionizing agriculture.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/948/1*5JWAq7yKIwiEIQcdfPkb7g.png" /></figure><h3>The Challenge: Labor Shortages Meet Growing Demand</h3><p>Agriculture faces a critical crossroads. With global food demand rising and manual labor becoming increasingly scarce and expensive, farmers need innovative solutions. Enter the DOFBOT Robotic Hand a sophisticated harvesting system that’s changing how we think about farming automation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*j_bBQEZx4UhsLNha.jpg" /></figure><h3>The Technology Stack: Small but Mighty</h3><p>At the heart of this revolutionary system lies the <strong>NVIDIA Jetson Nano</strong>, a compact powerhouse that brings AI processing directly to the field. This edge computing approach eliminates the delays and connectivity issues that plague cloud-based systems, delivering lightning-fast decisions when every millisecond counts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/970/0*TsUJHmmF7CuUD4rK.jpg" /></figure><p><strong>Key specifications:</strong></p><ul><li>128-core GPU with CUDA support</li><li>4GB memory for real-time processing</li><li>Power consumption: just 5–10 watts</li><li>Complete cycle time: 50 milliseconds per tomato</li></ul><h3>How It Works: Computer Vision Meets Precision Robotics</h3><p>The system uses a sophisticated computer vision pipeline that would make any tech enthusiast excited:</p><h3>1. Advanced Object Detection</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*6wQQbke_fFAzh9mh.png" /></figure><p><strong>YOLOv5</strong> handles the heavy lifting, scanning greenhouse environments at 112 frames per second to locate tomatoes among complex plant structures. The system maintains 94.1% detection accuracy even when fruits are partially hidden by leaves.</p><h3>2. Ripeness Classification</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/0*bJEot0vAaFD8Lkiu" /></figure><p><strong>ResNet-50</strong> neural networks analyze each detected tomato, distinguishing between ripe (red) and unripe (green) fruits with remarkable precision. The model achieves 96.8% accuracy by processing HSV color space data the same way humans naturally perceive color.</p><h3>3. Gentle Harvesting</h3><p>Force feedback sensors ensure the robotic gripper applies just enough pressure to pluck tomatoes without damage. The system completes each harvest in an average of 24.34 seconds with only a 2.1% fruit damage rate.</p><h3>Edge Computing: The Game Changer</h3><p>The decision to process everything locally on the Jetson Nano rather than relying on cloud computing proves transformative. Rural farms often struggle with unreliable internet connectivity, making cloud-dependent systems impractical. Edge processing eliminates network latency entirely while providing consistent performance regardless of external conditions.</p><p><strong>Response time comparison:</strong></p><ul><li>Edge processing: 50ms total cycle time</li><li>Traditional laptop/cloud: 187ms total cycle time</li></ul><h3>Real-World Impact</h3><p>This isn’t just impressive technology — it’s solving real problems:</p><h3>Economic Benefits</h3><ul><li><strong>ROI period:</strong> 1.5–2.5 years</li><li><strong>40–60% faster</strong> than manual harvesting</li><li><strong>Consistent quality</strong> without human fatigue</li><li><strong>Reduced labor costs</strong> by $3,000–10,000 per hectare annually</li></ul><h3>Environmental Advantages</h3><ul><li>Lower carbon footprint through electric operation</li><li>Reduced chemical waste through precision application</li><li>Minimal soil compaction</li><li>Optimized harvest timing reduces food waste</li></ul><h3>The Technology Behind the Magic</h3><h3>Deep Learning Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*OlXQ7Trm_jUPbV6q.png" /></figure><p>The system leverages transfer learning, starting with ImageNet pretrained models and fine-tuning them specifically for tomato classification. This approach dramatically reduces training time while improving accuracy.</p><p>Recent integration of <strong>AgriNet</strong> models — trained on over 160,000 agricultural images — shows 18.6% accuracy improvement over standard ImageNet models for crop-specific tasks.</p><h3>Multi-Modal Processing</h3><p>Beyond visual analysis, the system integrates depth information for precise 3D localization. This multi-modal approach enables better spatial understanding and more informed harvesting decisions.</p><h3>Challenges and Limitations</h3><p>No technology is perfect, and this system faces several challenges:</p><ul><li><strong>High initial costs</strong> ($5,300–7,500 for five years)</li><li><strong>Technical expertise</strong> required for operation</li><li><strong>Limited effectiveness</strong> with heavily occluded tomatoes</li><li><strong>Scale requirements</strong> for economic viability</li></ul><h3>What’s Next: The Future of Agricultural Robotics</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/0*66YYC7Q6AwsBXf9H.jpg" /></figure><p>The implications extend far beyond tomato harvesting. This platform provides a foundation for:</p><ul><li><strong>Multi-crop adaptation</strong> for various fruits and vegetables</li><li><strong>Disease detection</strong> through hyperspectral imaging</li><li><strong>Predictive analytics</strong> for harvest optimization</li><li><strong>Fleet coordination</strong> for large-scale operations</li></ul><h3>Emerging Technologies</h3><ul><li><strong>Jetson AGX Xavier</strong> upgrades for 32 TOPS AI performance</li><li><strong>Few-shot learning</strong> for rapid adaptation to new varieties</li><li><strong>Federated learning</strong> across multiple farms</li><li><strong>Wireless power systems</strong> for continuous operation</li></ul><h3>The Bottom Line</h3><p>This tomato harvesting robot represents more than technological achievement — it’s a glimpse into agriculture’s sustainable future. By combining cutting-edge AI with practical engineering, the system addresses labor shortages while improving efficiency and reducing environmental impact.</p><p>The 96.8% accuracy rate and sub-50ms response times demonstrate that edge AI has matured enough for real-world agricultural deployment. For medium to large-scale operations, the economic case is compelling: consistent quality, reduced labor dependency, and 24/7 operation capability.</p><p>As global food security challenges intensify, innovations like this DOFBOT system point toward a future where technology and nature work in harmony, ensuring sustainable food production for generations to come.</p><p><em>The farm of tomorrow isn’t just automated — it’s intelligent, sustainable, and ready to feed the world.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=380ea5675534" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Label Studio: Medical Image Classification with Bounding Boxes - Open-Source Data Labeling Platform]]></title>
            <link>https://medium.com/@ershrawan014/label-studio-medical-image-classification-with-bounding-boxes-open-source-data-labeling-10a19015639a?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/10a19015639a</guid>
            <category><![CDATA[bounding-box]]></category>
            <category><![CDATA[label-studio]]></category>
            <category><![CDATA[medical-image-analysis]]></category>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Sun, 26 Jan 2025 12:20:33 GMT</pubDate>
            <atom:updated>2025-01-26T12:20:33.214Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kGZBhZPrYBzJO19jx7_tqQ.png" /></figure><p><a href="https://labelstud.io/guide/quick_start">Label Studio Documentation - Quick start guide for Label Studio</a></p><p>Install Label Studio</p><pre>pip install label-studio</pre><p>Start Label Studio</p><pre>label-studio start</pre><p>Open Label Studio at <a href="http://localhost:8080/">http://localhost:8080</a></p><ol><li>Sign up with an email address and password that you create.</li><li>Click Create to create a project and start labeling data.</li><li>Name the project and optionally enter a description and select a color.</li><li>Click Data Import and upload the data files that you want to use. If you want to use data from a local directory, cloud storage bucket, or database, skip this step for now.</li><li>Click Labeling Setup and choose a template and customize the label names for your use case.</li><li>Click Save to save your project.</li></ol><h3>Installation</h3><p>Install Label Studio on premises or in the cloud. Choose the installation method that works best for your environment:</p><h3>Install prerequisite</h3><p>Install Label Studio in a clean Python environment. We highly recommend using a virtual environment (venv or conda) to reduce the likelihood of package conflicts or missing packages.</p><h3>Install using pip</h3><p>To install Label Studio with pip and a virtual environment, you need Python version 3.8 or later. Run the following:</p><pre>python3 -m venv env<br>source env/bin/activate<br>python -m pip install label-studio</pre><p>To install Label Studio with pip, you need Python version 3.8 or later. Run the following:</p><pre>pip install label-studio</pre><p>After you install Label Studio, start the server with the following command:</p><pre>label-studio</pre><p>The default web browser will automatically open at <a href="http://localhost:8080/">http://localhost:8080</a> with Label Studio. Please refer to <a href="https://labelstud.io/guide/start">start Label Studio</a> for more options when starting Label Studio.</p><p><a href="https://labelstud.io/templates/medical_imaging_classification">Label Studio - Medical Image Classification with Bounding Boxes Template</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QHJ9N7QkiQNMsgUt.png" /></figure><p>This template interface allows annotators to:</p><ul><li>Draw bounding boxes around areas identified as tumors in the image using the “Tumor” label.</li><li>Classify the entire image by selecting one of “Benign”, “Malignant”, or “Normal”.</li></ul><p>This setup is useful in medical imaging tasks where you need to localize tumors and also provide an overall assessment of the image.</p><h3>Labeling configuration</h3><pre>xml&lt;View&gt;<br>  &lt;Image name=&quot;image&quot; value=&quot;$image&quot;/&gt;<br>  &lt;RectangleLabels name=&quot;label&quot; toName=&quot;image&quot;&gt;<br>    &lt;Label value=&quot;Tumor&quot; background=&quot;green&quot;/&gt;<br>  &lt;/RectangleLabels&gt;<br>  &lt;Choices name=&quot;classification&quot; toName=&quot;image&quot;&gt;<br>    &lt;Choice value=&quot;Benign&quot;/&gt;<br>    &lt;Choice value=&quot;Malignant&quot;/&gt;<br>    &lt;Choice value=&quot;Normal&quot;/&gt;<br>  &lt;/Choices&gt;<br>&lt;/View&gt;</pre><h3>About the Labeling configuration</h3><p><strong>Image</strong></p><pre>&lt;Image name=&quot;image&quot; value=&quot;$image&quot;/&gt;</pre><p>This displays the image. The value=&quot;$image&quot; means it will use the image field from your task data.</p><p><strong>Bounding Boxes</strong></p><pre>&lt;RectangleLabels name=&quot;label&quot; toName=&quot;image&quot;&gt;<br>  &lt;Label value=&quot;Tumor&quot; background=&quot;green&quot;/&gt;<br>&lt;/RectangleLabels&gt;</pre><p>This defines the image segmentation you can use. In this template, you’re drawing rectangles (bounding boxes).</p><ul><li>The RectangleLabels tag creates a tool for drawing bounding boxes, and toName=&quot;image&quot; means that the boxes will be associated with the tag named image (which in this example is the name assigned to the &lt;Image&gt; tag).</li><li>The Label tag specifies that the bounding boxes represent “Tumor” regions, displayed with a green background.</li></ul><p>For more information about working with bounding boxes, see</p><p><a href="https://labelstud.io/templates/image_bbox">Label Studio - Image Object Detection Data Labeling Template</a></p><p><strong>Classification</strong></p><pre>&lt;Choices name=&quot;classification&quot; toName=&quot;image&quot;&gt;<br>  &lt;Choice value=&quot;Benign&quot;/&gt;<br>  &lt;Choice value=&quot;Malignant&quot;/&gt;<br>  &lt;Choice value=&quot;Normal&quot;/&gt;<br>&lt;/Choices&gt;</pre><h4>This adds image-level classification choices.</h4><ul><li>The &lt;Choices&gt; tag provides a set of options for annotators to select.</li><li>toName=&quot;image&quot; applies these choices to the entire image.</li><li>Annotators can classify the image as “Benign”, “Malignant”, or “Normal”.</li></ul><h3>How to do Medical Image Labeling with Label Studio</h3><p>In the medical field, imaging is a quick way to see what’s going on inside or outside the body. Training models to classify these images, or the structures inside them, is becoming increasingly popular. There are many groups out there that are using modeling to help improve treatment and diagnosis.</p><p><a href="https://humansignal.com/customers/bioticsai/">BioticsAI Scales Lifesaving AI with Label Studio | HumanSignal</a></p><p>for example — they’re leveraging Label Studio to help them quickly and efficiently leverage their Subject Matter Experts to label their data and greatly improving treatment and diagnostics for OB/GYNs.</p><p>We’ve put together a brief tutorial and template to help you get started with labeling and classifying your own medical images in Label Studio. This allows you to get data that you can be fully confident in, especially given the fact that in the medical field there is no margin for error. Expertise is expensive, so making sure that your SME time is used as efficiently as possible is critical. Take a look below for our tutorial, or find just the template here.</p><h3>Getting Started</h3><p>To begin, we downloaded</p><p><a href="https://www.kaggle.com/datasets/aryashah2k/breast-ultrasound-images-dataset">Breast Ultrasound Images Dataset</a></p><p>from Kaggle, which contains breast ultrasound images. The dataset is grouped into 3 classes — normal, benign, and malignant. We’ll use this dataset to show what medical imaging might look like in Label Studio!</p><p>Let’s start by creating a new project in Label Studio. Click on the blue “create” button on the upper right hand corner of your screen. We’ll give the project a name, and you could fill out the description with any additional information that you’d like to have on hand. Here, we’ll leave it blank.</p><h3>Upload Your Data</h3><p>Uploading the data to this project is easy! We’re just going to drag and drop the images from the Kaggle dataset into our project on the Data Import screen. When you unzip the dataset after you download it from Kaggle, you’ll notice the 3 folders that correspond to the 3 classes. Within each folder, there is a mask and an image for each sample. We’re going to ignore the mask files, and just drag and drop one of the regular images into the data import screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WUdTU3pCsr4s4k10.png" /></figure><h3>Configure Your Medical Image Labeling Project</h3><p>For this task, we have two goals — draw a bounding box around the tumor, and classify it as benign, malignant, or normal. You can see the labeling config for this project below. Notice that we show the image first, using the “Image” tag, and then have a RectangleLabels object for the bounding box around the tumor. You could easily swap this out with a BrushLabels tag if you wanted to draw a more precise shape around the tumor. Finally, we have the choices tag, which allows us to classify the image as benign, malignant, or normal. Click on the “custom template” button on the bottom of the left hand column and paste the code below into that screen.</p><pre>&lt;View&gt;<br>&lt;Image name=&quot;image&quot; value=&quot;$image&quot;/&gt;<br>&lt;RectangleLabels name=&quot;label&quot; toName=&quot;image&quot;&gt;<br>&lt;Label value=&quot;Tumor&quot; background=&quot;green&quot;/&gt;<br>&lt;/RectangleLabels&gt;<br>&lt;Choices name=&quot;classification&quot; toName=&quot;image&quot;&gt;<br>&lt;Choice value=&quot;Benign&quot;/&gt;<br>&lt;Choice value=&quot;Malignant&quot;/&gt;<br>&lt;Choice value=&quot;Normal&quot;/&gt;<br>&lt;/Choices&gt;<br>&lt;/View&gt;</pre><h3>Time to Label!</h3><p>Now, you’re ready to label! Click into any of the samples, or click the “Label All Tasks” button at the top of the Data Manager. Select the Tumor label below the image, and then draw your bounding box. Then, you can click on whichever label you’d like to apply. Finally, click submit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/0*jkD9WKO5vRseIoD2.png" /></figure><p>And you’re done! Labeling medical images in Label Studio with bounding boxes is very straightforward and will greatly reduce your time to a model or model evaluation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10a19015639a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Improving the Effectiveness of RAG Systems: Lesson 1]]></title>
            <link>https://medium.com/@ershrawan014/improving-the-effectiveness-of-rag-systems-lesson-1-684381fa996a?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/684381fa996a</guid>
            <category><![CDATA[llm-rag]]></category>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Tue, 08 Oct 2024 03:59:21 GMT</pubDate>
            <atom:updated>2024-10-08T03:59:21.776Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ueysqtFgZC-Lf0ua2zSug.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*DkPpmtKSGAaaHG_Lh6vC7A.png" /></figure><h3><strong>Exploring and Preparing your Dataset for Retrieval</strong></h3><p>Large language models (LLMs) are powerful tools for solving real-world problems — as long as they have the information necessary to help.</p><p>Useful LLM-based systems need to be able to integrate new information reliably and quickly. Both of those goals can be achieved via retrieval-augmented generation (RAG): retrieving information from a data source and injecting it into the LLM’s prompt.</p><p>This greatly simplifies the problem that the LLM has to solve. Instead of requiring the information to have been available during training, the LLM can simply “read” the sources it receives as context and use them to find a solution.</p><h3>Data Exploration:</h3><p>Tech Blogs are HTML pages from a WordPress Blog. They have a leading title, and then are often further divided into sections, which can be one or more paragraphs. The blogs contain a mix of regular text, code, and images.</p><p>Have a look at a few of these articles using these links:</p><ul><li><a href="https://developer.nvidia.com/blog/create-share-and-scale-enterprise-ai-workflows-with-nvidia-ai-workbench-now-in-beta/">https://developer.nvidia.com/blog/create-share-and-scale-enterprise-ai-workflows-with-nvidia-ai-workbench-now-in-beta/</a></li><li><a href="https://developer.nvidia.com/blog/improving-cuda-initialization-times-using-cgroups-in-certain-scenarios/">https://developer.nvidia.com/blog/improving-cuda-initialization-times-using-cgroups-in-certain-scenarios/</a></li><li><a href="https://developer.nvidia.com/blog/bringing-generative-ai-to-the-edge-with-nvidia-metropolis-microservices-for-jetson/">https://developer.nvidia.com/blog/bringing-generative-ai-to-the-edge-with-nvidia-metropolis-microservices-for-jetson/</a></li></ul><p>If we “embed” the text of each post, we get a floating-point vector with hundreds or even thousands of dimensions quantifying the “meaning” of each blog post.</p><p>To visualize this, we can reduce the dimensionality of these vectors so each blog is now represented by a 3D point which we can easily plot.</p><p>Note how the embeddings naturally cluster the blogs, and we’ve color coded the clusters. Orange might represent blogs in the realm of healthcare and life-sciences. Magenta might capture blogs within the realm of robotics, etc.</p><h3><strong>Imports:</strong></h3><p>import math<br>import os<br>import json<br>import asyncio<br>import httpx<br>import time<br>import shutil<br>from datetime import datetime</p><h3>Create Download Functions:</h3><p>The following function will download the latest blogs from the Wordpress API.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/835/1*rJqXWIgzFOf8NNTF1VY1Jg.png" /></figure><h3><strong>Create Data Directory:</strong></h3><p>data_dir = os.path.join(os.getcwd(), ‘data’, ‘techblogs’)</p><h3>Load and Organize Tech Blogs:</h3><p>Now let’s organize all our downloaded data into a simple dictionary where the key is the URL, just for the purposes of easier access of a few examples.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*qBtQl4W2ePR-uJ1jFkLzKA.png" /></figure><h3><strong>Explore Tech Blogs Data:</strong></h3><p>example1 = techblogs_dict[“<a href="https://developer.nvidia.com/blog/improving-cuda-initialization-times-using-cgroups-in-certain-scenarios/">https://developer.nvidia.com/blog/improving-cuda-initialization-times-using-cgroups-in-certain-scenarios/</a>&quot;]<br>example1</p><p>example2 = techblogs_dict[“<a href="https://developer.nvidia.com/blog/bringing-generative-ai-to-the-edge-with-nvidia-metropolis-microservices-for-jetson/">https://developer.nvidia.com/blog/bringing-generative-ai-to-the-edge-with-nvidia-metropolis-microservices-for-jetson/</a>&quot;]<br>example2</p><h3>Importance of Chunking:</h3><p>If you haven’t already, take a moment to click through those article links to get a visual sense of how long they are and what kind of text style they use.</p><p>These articles can be quite extensive! Sending entire posts as context to our downstream LLM might not be the best approach — especially when there could be hundreds of posts with relevant sections for a given prompt. Using full posts can make it more difficult for the LLM to pinpoint the necessary information and may also drive up costs, since API-based LLMs charge per token.</p><p>A better approach would be to divide these articles into smaller segments and create an index for those chunks.</p><p>Chunking is critical for a RAG (Retrieval-Augmented Generation) system, and the way you design chunks can significantly affect the system’s performance.</p><p>There isn’t a universal chunking strategy that fits all datasets or downstream tasks. Some use cases benefit from larger context within each chunk, while others perform better by combining many smaller chunks. Experimentation is key to finding the strategy that works best for your specific needs.</p><p>Some chunking methods can be sophisticated (and computationally expensive), identifying natural break points where the document shifts topics.</p><p>For this lesson, we’ll explore some simpler chunking strategies through a service we’ve set up. This service offers basic methods for chunking text and HTML based on word counts — a convenient way to gauge how many chunks will fit into a fixed LLM prompt size.</p><p>You can find the source code for this in chunking/src.</p><h3>Introducing the Chunking Service through API Docs:</h3><p>!docker-compose logs chunking</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/872/1*q7Xlwy-ivZFl1jK2TU-yCw.png" /></figure><p>The chunking service is a FastAPI Python web app, running with Uvicorn. FastAPI has better performance than the more popular Flask framework and built-in asynchronous support for endpoints. This will let us chunk more than one document at a given time, to make the data upload process faster.</p><p>FastAPI also has built in auto-generated API documentation (in a Swagger/OpenAPI format). If you visit the link you just generated in your browser, you should see an API docs page. If you click and expand the endpoint `/api/chunking` you will see examples of the Request Body you’d send to the endpoint in order to use different chunking strategies. Each example has an `Example Description` explaining what is happening.</p><p>If you click “Try It out” button and then click “Execute” button, you can hit the chunking API entirely through the web browser.</p><h3>Experimenting Programmatically with Chunking Service:</h3><p>Using the API docs is nice for testing, but in order to send lots of requests at once, we want to hit the chunking API programmatically.</p><h3>Create API Client:</h3><p>We can accomplish this using the Python `httpx` library, which is very similar to the popular `requests` library but with better async support.</p><p>client = httpx.Client()</p><h3>Create API Request Function:</h3><p>Here we create a `chunk_request` function for making requests to the chunking API. Note: the chunking service we are already running for you is running at the `chunking` hostname.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/557/1*GJUqMkVhdFtHhI7qXRO0OQ.png" /></figure><h3>Sentence-by-Sentence Chunking:</h3><p>First we do a standard sentence-by-sentence chunking to see what that looks like.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/527/1*7hZT3373oq7DIwVCE6YqOg.png" /></figure><p>These chunks are probably too small to be useful — they often refer to information outside of the chunk that’s important to understanding it.</p><h3>Increase Minimum Chunk Size:</h3><p>Let’s increase the minimum size of the chunks (measured in number of words) to 250. The chunking service will add sentences to each chunk until we exceed the minimum word count.</p><p>But what if that border we picked breaks up a meaningful segment of text? We can let chunks overlap — making it more likely that sentences are chunked with any important context in at least one of the chunks on either side of a boundary. Let’s set overlap at least 50 words.</p><p>The chunking microservice uses the Python spacy package internally to count words.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/468/1*5lY5MajAlv-kpVgaSYpVyA.png" /></figure><p>print(len(chunks))</p><p>for i, chunk in enumerate(chunks):<br> print(f”Chunk #{i}”)<br> print(f”Word Count: {sum(chunk[‘word_count’])}”)<br> # print(chunk[“text”])<br> print(“==========”)</p><p>If we inspect the word count in each chunk, we see that we don’t always hit the minimum number of words we set as a parameter (250).</p><p>Check out Chunk #3 for example, which only has 21 words. Too many small chunks like this will “clog” our retrieval system with bad data. This forces us to retrieve a larger <br>batch of results (top K has to be set to a larger number) and then an LLM (or person, if they’re looking at the LLM’s sources) would need to sift through too many bad matches.</p><p>Even if a small chunk is not helpful, it can still come up in a search if the document title or other metadata cause a close semantic/keyword search match. Small chunks are especially prone to this problem because they don’t have enough content of their own to “dilute” the effect of metadata matches.</p><p>chunks[3][“text”]</p><h3>Dealing with Code in your Documents:</h3><p>This chunk is this small because the default behavior of the chunking microservice is to enforce boundaries between code and non-code sections in HTML. It will not combine a section of the article written in natural language with another section of only code. This little sentence comes right before a large code section in the article, so the chunking service ends the chunk right there.</p><p>Our use case therefore requires us to handle the presence of large code sections within our HTML.</p><p>Lots of text documents at NVIDIA contain a mix of code and natural language, whether it’s blog posts like these, SDK documentation, Git repository README markdown files, etc.</p><p>These sections of code are very different syntactically and grammatically from regular natural language text, and so an embedding model that has not been trained on code may not perform well with code present. For embedding models that are trained on code and natural language, it’s also going to be important to delimit the code with the characters the embedding model was trained on. The chunking service uses triple backticks (```) to indicate a section of code.</p><p>The chunking service as written supports three strategies to deal with code. <br>1. The default (`”code_behavior”: “enforce_code_boundaries”`) is to enforce hard boundaries between code and non-code. This has the benefit of separation, but has the drawback that sometimes you will end up with awkward small chunks because of these boundaries.<br>2. The second option (`”code_behavior”: “ignore_code_boundaries”`) is to just ignore the boundaries and lump code and non-code together, while still keeping the backticks as delimiters. This is a good option if your embedding model supports both code and non-code.<br>3. The third option (`”code_behavior”: “remove_code_sections”`) is to remove the long only-code sections from the actual text that will be embedded, but store the code as metadata which can later be used. For example, the code can be supplied to an LLM that is generating a response based on the retrieval results it found by matching on the accompanying natural language.</p><h3>Remove Only Code Sections:</h3><p>Let’s try option 3, since for this lesson we will be using the `SentenceTransformers` embedding model [`e5-large-unsupervised`](<a href="https://huggingface.co/intfloat/e5-large-unsupervised">https://huggingface.co/intfloat/e5-large-unsupervised</a>), which was not trained on code. Additionally, this model has a maximum token limit of 512 tokens, or roughly ~380 typical words. To be on the safe side we’ll use a minimum of 250 words.</p><ul><li>Note: `e5-large-unsupervised` should only be used for English language text. There is a multilingual version of the e5 model on HuggingFace if you’re interested. *</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/1*ia47Ti45f3SM84RxPBcDVA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*ByEWUPk-CHkXsx2e3Ps_yg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/856/1*hRl-jiXK2471mvHHTmPFaA.png" /></figure><h3>Handling Heading Sections:</h3><p>There are many further tweaks we could consider, beyond just changing the minimum words per chunk or number of overlap words.</p><p>For example, we could choose to chunk by adding paragraphs instead of sentences until we hit the minimum number of words. Perhaps it doesn’t make sense to break apart paragraphs, since the author saw them as one logical unit.</p><p>Let’s additionally consider the implicit structure provided by the headings. We could chunk only off the headings, though this would likely result in a similar issue of awkward small chunks for heading sections that are irregular sizes (especially if we taking code sections out of the embeddable text).</p><p>The chunking microservice lets us preserve which heading section a sentence/paragraph came from and insert that into the chunk text, helping the embedding model understand longer-range context for the chunk. This way, if a chunk starts in the middle of a particular section, it can still be interpreted alongside the title of that section. We just change `strategy` to `heading_section_sentence`</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/905/1*1rmENO46pr-skDlYblEfSw.png" /></figure><h3>Unstructured vs. Structred Text:</h3><p>Chunking structured text like HTML articles is different than chunking unstructured text like the transcript of a video. With structured text, we can take advantage of the implicit structure provided by the original authors. With unstructured text, we have to find other methods.</p><p>For structured text, we could use a recursive strategy that looks at the largest logical chunks of the HTML articles first, breaking HTML by the largest heading sections (since heading levels suggest hierarchy). Then if necessary, break into smaller heading sections (for example h3 headings nested under h2 headings). And then progressively break into paragraphs and so on.</p><p>Similarly, with unstructured text, we might assume that e.g. a presentation is comprised of topics. We could then embed small chunks, combining adjacent ones with close enough embeddings (i.e. ones likely on the same topic) into larger chunks.</p><p>After this course is complete, you’ll be well positioned to explore those techniques!</p><h3>Another Chunking Strategy: Summarization</h3><p>When we started exploring the data, we were considering potential use cases. The chunking strategy we’ve selected so far gives us direct access to the contents of the articles, and it’s well-suited for a question-answering (QA) task where we need to extract fine-grained details from a document to answer a user’s question.</p><p>A good semantic search system enables an array of use cases, including a more general version of classic search: finding which articles are available on a given topic, without needing to know the relevant keywords.</p><p>For this kind of asset discovery task, the system doesn’t need to know all the detailed information in each article — the kind that we were preserving in chunks — so instead we could summarize each article and store that summary as a chunk.</p><p>Plus, as long as we keep the original text in our database, we could simultaneously support full-article retrieval and question-answering.</p><p>To accomplish this we will do the following:<br>- First use the chunking service to split articles by heading and remove code sections<br>- Next, concatenate the non-code sections and send to an LLM for summarization<br>- Finally, concatenate all text (including the code sections) and store that as additional metadata.</p><h3>Split by Heading and Remove Code Sections:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/865/1*z8vLoOkvsC7kPhRC62Gdgw.png" /></figure><h3>Concatenate Non-code Sections:</h3><p>clean_text_no_code = “\n”.join([x[“text”] for x in chunks])<br>print(clean_text_no_code)</p><h3>Concatenate Code and Non-code Sections</h3><p>clean_text_with_code = “\n”.join([ x[“heading_section_title”][0] + “\n” + “\n”.join(x[“text_components”]) for x in chunks])<br>print(clean_text_with_code)</p><h3>Use LLM to Summarize Blog Posts (Non-code Sections):</h3><p>In order to summarize, we’ll rely on making calls to an LLM.</p><h3>NeMo Inference Microservice Mixtral 8x7B:</h3><p>As a default for our LLM we will use a local instance of Mistral’s Mixtral 8x7B instruct model served via NIM. NVIDIA NIM, part of NVIDIA AI Enterprise, is a set of easy-to-use microservices designed to accelerate deployment of generative AI across your enterprise. This versatile runtime supports a broad spectrum of AI models — from open-source community models to NVIDIA AI Foundation models, as well as custom AI models. Leveraging industry standard APIs, developers can quickly build enterprise-grade AI applications with just a few lines of code. Built on the robust foundations including inference engines like Triton Inference Server, TensorRT, TensorRT-LLM, and PyTorch, NIM is engineered to facilitate seamless AI inferencing at scale, ensuring that you can deploy AI applications anywhere with confidence. Whether on-premises or in the cloud, NIM is the fastest way to achieve accelerated generative AI inference at scale.</p><p>To get started, users can experience the accelerated generative AI models on the API catalog. When ready to deploy, enterprises can export models with NVIDIA NIM which is included with the NVIDIA AI Enterprise license, and run anywhere, giving them ownership to their customizations and full control of their IP and AI application.</p><p>Here we import a `ChatOpenAI` instance of our local NIM Mixtral 8x7B model configured and ready for use with LangChain from an [`llms` helper file](llms.py).</p><p>from llms import llms</p><p>llm = llms.nim_mixtral_llm</p><h3>Optional Remote LLMs:</h3><p>Optionally, instead of using our local model, you can also use either NVIDIA AI Foundation’s Mixtral 8x7B model or OpenAI’s gpt-3.5-turbo.</p><p>For either of these 2 options you’ll need an API key.</p><h3>NVIDIA AI Foundation Mixtral 8x7B:</h3><p># from llms import set_api_key<br># set_api_key(‘NVIDIA_API_KEY’, ‘&lt;your_nvidia_api_key&gt;’)<br># llm = llms.nvai_mixtral_llm</p><h3>OpenAI GPT-3:</h3><p># from llms import set_api_key<br># set_api_key(‘OPENAI_API_KEY’, ‘&lt;your_openai_api_key&gt;’)<br># llm = llms.openai_gpt3_llm</p><h3>Test Model:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/655/1*AuQ561uJjRQjESzdN8SHbg.png" /></figure><h3>Use LLM to Summarize Blog Post:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/625/1*TXgeYqXIM_1N-XI7EKR3rQ.png" /></figure><p>To recap, we’ve got two different chunking strategies to use for preparing data for our search system.</p><p>One is chunking the actual text of the articles using a running word count, while the other is summarizing the article and using that summary as the chunk.</p><p>Each of these strategies is suited to its own task: raw text chunking for question-answering, and full-article summarization for asset discovery.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=684381fa996a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building an Autonomous Vehicle with Jetson Nano: An Open-Source Project]]></title>
            <link>https://medium.com/@ershrawan014/building-an-autonomous-vehicle-with-jetson-nano-an-open-source-project-0ee2f15bb2ff?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/0ee2f15bb2ff</guid>
            <category><![CDATA[image-processing]]></category>
            <category><![CDATA[autonomous-vehicles]]></category>
            <category><![CDATA[jetson-nano]]></category>
            <category><![CDATA[nvidia]]></category>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Sun, 01 Sep 2024 06:40:42 GMT</pubDate>
            <atom:updated>2024-09-01T06:40:42.562Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*it6WJZXaVurYsRNSVcmOxA.jpeg" /></figure><p>Autonomous vehicles are no longer a futuristic concept. Thanks to advancements in machine learning, computer vision, and robotics, self-driving cars are becoming a reality. One of the most exciting developments in this field is the use of affordable hardware like NVIDIA’s Jetson Nano to bring autonomous vehicle technology within reach of hobbyists, researchers, and educators. This article will guide you through the journey of building an open-source autonomous vehicle using the Jetson Nano, an impressive edge AI computing device.</p><h4>What is the Jetson Nano?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/0*6fnKBLYf_ftWPNCT.jpg" /></figure><p>The NVIDIA Jetson Nano is a small, powerful computer designed to run multiple neural networks in parallel for applications like image classification, object detection, segmentation, and speech processing. It features a quad-core ARM Cortex-A57 CPU, a 128-core Maxwell GPU, and supports the full suite of NVIDIA AI software.</p><h4>Why Choose Jetson Nano for Autonomous Vehicles?</h4><ol><li><strong>Affordability</strong>: At around $99, the Jetson Nano provides a cost-effective solution for high-performance AI computing. Its price point makes it accessible for enthusiasts and educational purposes.</li><li><strong>Power Efficiency</strong>: With a power consumption of just 5–10 watts, the Jetson Nano is suitable for mobile applications where power efficiency is crucial.</li><li><strong>Rich Software Ecosystem</strong>: NVIDIA provides a comprehensive set of AI tools and frameworks, including TensorRT, CUDA, cuDNN, and the NVIDIA JetPack SDK, making it easier to develop and deploy AI applications.</li><li><strong>Community Support</strong>: The open-source community around Jetson Nano is vibrant, with many projects, tutorials, and forums that can help guide you through your development journey.</li></ol><h4>Building Your Autonomous Vehicle</h4><p>Creating an autonomous vehicle with the Jetson Nano involves several steps, including hardware assembly, software setup, and training the AI models. Below, we outline the key stages of the project.</p><p>1. <strong>Hardware Setup</strong></p><p>To start, you need to gather the necessary hardware components:</p><ul><li><strong>Jetson Nano Developer Kit</strong>: The brain of your autonomous vehicle.</li><li><strong>Chassis Kit</strong>: A simple robotic car chassis that includes wheels, motors, and a mounting platform.</li><li><strong>Motor Driver Module</strong>: To control the motors using the Jetson Nano’s GPIO pins.</li><li><strong>Camera Module</strong>: For visual input, such as a USB webcam or Raspberry Pi Camera Module.</li><li><strong>Power Supply</strong>: A battery pack to power the Jetson Nano and motors.</li><li><strong>Ultrasonic Sensors</strong>: For obstacle detection and collision avoidance.</li></ul><p>Assemble these components to create the basic framework of your vehicle. The Jetson Nano can be mounted on the chassis, and the camera and sensors can be attached to the front for clear visibility.</p><p>2. <strong>Software Setup</strong></p><p>Once the hardware is set up, the next step is to configure the software environment:</p><ul><li><strong>Install JetPack SDK</strong>: This provides the Linux operating system, libraries, and APIs needed for development on the Jetson Nano. JetPack includes TensorRT, OpenCV, and other essential libraries.</li><li><strong>Set Up Computer Vision Libraries</strong>: Install OpenCV, a popular library for computer vision tasks. OpenCV will be used for image processing and camera interfacing.</li><li><strong>Deep Learning Frameworks</strong>: Install frameworks like TensorFlow or PyTorch, which will be used to train and run neural networks.</li></ul><p>3. <strong>Training the AI Models</strong></p><p>The core of an autonomous vehicle is its ability to understand its environment and make decisions. This is achieved through training AI models using deep learning techniques.</p><ul><li><strong>Data Collection</strong>: Start by collecting data using the camera mounted on the vehicle. Drive the vehicle manually and record the video footage, which will be used to train the model.</li><li><strong>Data Annotation</strong>: Label the data to indicate road lanes, obstacles, and other relevant features. This labeled data is crucial for supervised learning.</li><li><strong>Model Training</strong>: Use convolutional neural networks (CNNs) to train models for tasks like lane detection and object recognition. Transfer learning can be employed to fine-tune pre-trained models to suit specific needs.</li><li><strong>Simulation and Testing</strong>: Before deploying on the actual vehicle, test the models in a simulated environment. Tools like Gazebo or Unity can be used for creating virtual driving scenarios.</li></ul><p>4. <strong>Deploying and Fine-Tuning</strong></p><p>Deploy the trained models onto the Jetson Nano. Use the NVIDIA TensorRT library to optimize the models for better performance on the edge device.</p><ul><li><strong>Real-Time Inference</strong>: Implement the inference pipeline to process real-time video input from the camera and make driving decisions based on the model’s output.</li><li><strong>Sensor Integration</strong>: Incorporate data from ultrasonic sensors to enhance obstacle detection and avoidance capabilities.</li><li><strong>Feedback Loop</strong>: Set up a feedback loop to continually improve the model’s accuracy. As the vehicle collects more data from different driving scenarios, retrain the models to handle edge cases and improve performance.</li></ul><h4>Challenges and Considerations</h4><p>Building an autonomous vehicle is a complex project that presents several challenges:</p><ul><li><strong>Data Quality</strong>: The performance of AI models heavily depends on the quality and diversity of the training data. Ensure that the data captures a wide range of driving scenarios.</li><li><strong>Real-Time Processing</strong>: Running AI models in real-time with low latency is critical for autonomous driving. Optimization techniques like model pruning, quantization, and using TensorRT are essential.</li><li><strong>Safety and Reliability</strong>: Safety is paramount in autonomous driving. Implement fail-safes, redundancy systems, and rigorous testing to ensure reliable operation.</li></ul><h4>Conclusion</h4><p>Building an autonomous vehicle using the Jetson Nano is an exciting and rewarding project that blends hardware and software skills. The combination of NVIDIA’s powerful hardware, a rich software ecosystem, and the collaborative spirit of the open-source community makes it possible to create sophisticated AI-driven systems at a fraction of the traditional cost. Whether you are an enthusiast, a student, or a researcher, embarking on this project will provide invaluable insights into the world of autonomous vehicles and edge AI computing.</p><p>As technology continues to advance, the skills and knowledge gained from working on such projects will be increasingly valuable. So, gear up, start building, and drive your way into the future of autonomous vehicles!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0ee2f15bb2ff" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Developing a Web Application for Decision Tree Models with Streamlit and MLJAR Studio]]></title>
            <link>https://medium.com/@ershrawan014/developing-a-web-application-for-decision-tree-models-with-streamlit-and-mljar-studio-6b1db151c858?source=rss-b06738d7a791------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b1db151c858</guid>
            <dc:creator><![CDATA[Er. Shrawan, Phd Researcher ]]></dc:creator>
            <pubDate>Thu, 08 Aug 2024 10:00:46 GMT</pubDate>
            <atom:updated>2024-08-08T10:00:46.069Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*faSp2Vu5InHWN_zjPYghRw.png" /></figure><p>Building a web application for a Decision Tree model using Streamlit and MLJAR Studio combines the power of machine learning with user-friendly interfaces, making it accessible to a broader audience.</p><p>This article will guide you through the process of creating such an application, highlighting key concepts and practical steps.</p><h3>Understanding Decision Trees</h3><p>A Decision Tree is a supervised machine learning algorithm used for both classification and regression tasks. It works by splitting the data into subsets based on the value of input features, creating a tree-like model of decisions. The final decision is made based on the majority class (for classification) or average value (for regression) of the leaf nodes.</p><p>This model is particularly favored for its interpretability and ease of visualization.</p><h3>Setting Up the Environment</h3><p>To build a web application, we will need to set up your development environment. The following tools are essential:</p><ol><li>Python: The programming language used for building the model.</li><li>Streamlit: A framework for creating interactive web applications in Python.</li><li>MLJAR Studio: A platform for automating machine learning tasks, which simplifies model training and evaluation.</li></ol><h3>Installation</h3><p>Can install Streamlit and MLJAR Studio using pip:</p><pre>pip install streamlit mljar-supervised</pre><p><a href="https://mljar.com/">MLJAR - Outstanding Data Science Tools</a></p><h3>Building the Decision Tree Model</h3><h3>Step 1: Import Libraries</h3><p>Start by importing the necessary libraries:</p><pre>import pandas as pd<br>import numpy as np<br>from sklearn.tree import DecisionTreeClassifier<br>import matplotlib.pyplot as plt<br>from sklearn.tree import plot_tree</pre><h3>Step 2: Load and Prepare Data</h3><p>For demonstration, we will use the Iris dataset, a classic dataset for classification tasks:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/611/1*ecLAFmq4KF3jZWF4oQcJiw.png" /></figure><pre># Load dataset</pre><pre>df = pd.read_csv(&quot;C:/Users/ShrawanThakur/Documents/Python Scripts/irisdata.csv&quot;)</pre><pre># Define features and target variable<br>X = df.drop(&quot;class&quot;, axis=1)  # Features<br>y = df[&quot;class&quot;]                # Target variable</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/719/1*GptoKAXXXTm3qD_EurU-fA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/1*_yHE2oy2SI3HUeSnXDjC-g.png" /></figure><h3>Step 3: Train the Model</h3><p>Create and train the Decision Tree model:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/370/1*v9wRZ3m-2VwwWPWefGHWZQ.png" /></figure><pre># Initialize and train the model<br>model = DecisionTreeClassifier(criterion=&quot;gini&quot;, random_state=42)<br>model.fit(X, y)</pre><h3>Step 4: Visualize the Decision Tree</h3><p>Visualizing the tree helps in understanding the decision-making process:</p><pre>plt.figure(figsize=(20,10))<br>plot_tree(model, feature_names=X.columns, class_names=np.unique(y), filled=True)<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YbZ8lPjja_bwlt3tNbMEpA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*eovgaM6RUQhn5Wz7StIEIQ.png" /></figure><h3>Creating the Streamlit Web Application:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pl3BVS2nlo-fdAwh.png" /></figure><h3>Step 1: Initialize Streamlit</h3><p>Create a new Python file (e.g., app.py) and start with the Streamlit setup:</p><p><a href="https://streamlit.io/">Streamlit * A faster way to build and share data apps</a></p><pre>import streamlit as st<br>st.title(&quot;Decision Tree Classifier&quot;)</pre><h3>Step 2: User Input</h3><p>Allow users to input feature values for prediction:</p><pre>st.sidebar.header(&quot;User Input Features&quot;)<br>def user_input_features():<br>    sepal_length = st.sidebar.slider(&quot;Sepal Length&quot;, 4.0, 8.0, 5.0)<br>    sepal_width = st.sidebar.slider(&quot;Sepal Width&quot;, 2.0, 4.5, 3.0)<br>    petal_length = st.sidebar.slider(&quot;Petal Length&quot;, 1.0, 7.0, 1.5)<br>    petal_width = st.sidebar.slider(&quot;Petal Width&quot;, 0.1, 2.5, 0.2)<br>    return pd.DataFrame([[sepal_length, sepal_width, petal_length, petal_width]],<br>                        columns=[&quot;sepal_length&quot;, &quot;sepal_width&quot;, &quot;petal_length&quot;, &quot;petal_width&quot;])<br>input_data = user_input_features()</pre><h3>Step 3: Make Predictions</h3><p>Use the trained model to make predictions based on user input:</p><pre>prediction = model.predict(input_data)<br>st.write(f&quot;Predicted class: {prediction[0]}&quot;)</pre><h3>Step 4: Run the Application</h3><p>To run the application, use the command:</p><pre>streamlit run app.py</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/806/1*qCfYQDojxbqJHz-YFptyiA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b1db151c858" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>