PaperLedge

Hey PaperLedge learning crew, Ernis here, ready to dive into another fascinating research paper! Today, we're tackling a problem that's super relevant to how AI understands and uses language, especially as it encounters new words and ideas.

Think of it this way: imagine you're teaching a robot to read. It starts with a basic vocabulary, like "cat," "dog," and "house." But what happens when it encounters a word like "quokka" or "blockchain"? It's completely lost, right? That's the challenge facing current language models, those powerful AI systems that power everything from chatbots to translation apps.

These models are built on a static vocabulary. That means the words they know are fixed from the beginning, during a process called "pretraining." When they encounter words outside that initial set, performance can suffer. It's like trying to build a house with only the Lego bricks you started with – you'll be missing key pieces!

Now, researchers have found a solution: add new words, or "tokens," to the model's vocabulary. But here's the catch: you can't just throw in a new word and expect the AI to understand it instantly. You need to give it a good starting point, a way to understand how that word relates to the other words it already knows. This is where embedding initialization comes in: it's like giving the robot a cheat sheet to quickly learn the meaning of the new word.

The problem is that existing methods for teaching the AI these new words are either computationally expensive (requiring more training data and time) or require pretraining additional modules (which is like teaching the robot another whole language first!).

That's where this paper comes in. The researchers propose a new method called AweDist, which stands for something a bit technical, but the key idea is distillation. Think of it like this: imagine you have a wise old professor (the original language model) who already understands a bunch of words. AweDist lets you tap into that professor's knowledge to quickly teach the robot (the updated language model) the meaning of the new word.

How does it work? AweDist uses the original tokenization to understand the new word in the context of the pre-existing vocabulary and then "distills" this understanding into a new embedding for the new token. Crucially, it doesn't require expensive retraining or additional modules. It's like giving the robot a super-efficient crash course!

The researchers tested AweDist on several open-weight models - which are essentially AI models whose code is publicly available - and found that it outperformed even strong baseline methods. In other words, AweDist was better at quickly and accurately teaching the AI new words.

So, why does this matter? Well, for:

This is a really promising step toward more adaptable and intelligent AI.

Here are a couple of things that popped into my mind:

What do you all think? Let me know in the comments! Until next time, keep learning!

Hey PaperLedge crew, Ernis here, ready to dive into some seriously fascinating research! Today, we're talking about how well Large Language Models – those AI brains that power things like ChatGPT – are doing at something super important: creating structured data.

Think of it like this: you ask an LLM to build you a website. It needs to not just write the words, but also create the behind-the-scenes code, like HTML, that tells the browser how to display everything. Or imagine asking it to organize your expenses into a spreadsheet – it needs to create a properly formatted CSV file. Getting that structure right is crucial.

Now, researchers have created something called StructEval – a brand new "report card" for LLMs, specifically focused on how well they handle different types of structured data. This isn't just about generating text; it's about producing accurate and usable code and data formats.

StructEval throws all sorts of challenges at these LLMs. It tests them in two main ways:

They're testing the models on a whopping 18 different formats – from everyday things like JSON and CSV to more complex stuff like HTML, React code, and even SVG images!

So, how are these LLMs doing? Well, the results are… interesting. Even the super-smart models aren't perfect. The best one tested, called o1-mini, only managed an average score of about 75%. Open-source alternatives are even further behind. Yikes!

"We find generation tasks more challenging than conversion tasks, and producing correct visual content more difficult than generating text-only structures."

That means it's harder for them to create a structure from scratch than it is to translate between existing structures. And, unsurprisingly, getting the visual stuff right (like creating a working SVG image) is tougher than just generating text-based data.

Why does this matter? Well, for developers, this tells us which LLMs are reliable for generating code and data. For businesses, it highlights the potential (and limitations) of using AI to automate tasks like data entry, report generation, and website design. And for everyone, it's a reminder that even the most advanced AI still has room to improve.

Think about it: if an LLM can't reliably generate structured data, it limits its usefulness in all sorts of applications. We rely on the structure of data for everything from analyzing scientific results to managing our finances.

So, here are a couple of things that are bouncing around in my head after reading this:

Let me know what you think, PaperLedge crew. This is Ernis, signing off. Keep learning!

Hey PaperLedge crew, Ernis here! Get ready to dive into some seriously cool AI research. Today, we're talking about how to figure out if two AI brains, or neural networks, are thinking alike, even if they learned in completely different ways.

Imagine you have two students, let's call them Alice and Bob. They both aced the same math test, but Alice studied using flashcards, while Bob learned by building robots. Did they actually learn the same math concepts, or did they just find different tricks to pass the test? That's the kind of question researchers are grappling with when it comes to AI.

Why does this matter? Well, for starters, if we know when AI models are truly learning the same things, we can:

So, how do we actually measure this "functional similarity"? One popular approach is called model stitching. Think of it like this: you try to "glue" two AI models together with a special adapter. If you can glue them together easily and the resulting model still works well, that suggests they were already thinking along similar lines.

The core idea is to find a mathematical transformation that aligns the internal representations of the two networks. If a simple transformation works, it suggests the networks are functionally similar.

"Model stitching...aligns two models to solve a task, with the stitched model serving as a proxy for functional similarity."

Now, here's where things get interesting. A new paper introduces a clever twist on model stitching called Functional Latent Alignment (FuLA). It's inspired by something called "knowledge distillation," where you try to teach a smaller, simpler AI model by having it mimic a larger, more complex one. FuLA essentially tries to find the best way to align the "thinking" of two AI models, focusing on the core knowledge they've learned, not just superficial tricks.

The researchers tested FuLA on a few different scenarios:

In essence, FuLA appears to be a more reliable way to measure functional similarity because it's less likely to be fooled by training artifacts or superficial similarities. It digs deeper to find out if two AI models are truly on the same wavelength.

So, what does this all mean for us?

Here are a couple of things that popped into my head:

That's all for this episode! Keep exploring, keep questioning, and I'll catch you next time on PaperLedge!

Hey PaperLedge crew, Ernis here, ready to dive into another fascinating piece of research! Today, we’re talking about a problem that's becoming increasingly relevant in the world of AI: how do we get these amazing Language Models, these digital brains, to work together better?

Think of it like this: you've got a team of experts, each brilliant in their own specific area. One's a whiz at writing poems, another's a coding guru, and a third is a walking encyclopedia of historical facts. Wouldn't it be awesome if you could combine their strengths without having to retrain them all from scratch every time you need a new project done?

That's essentially what this paper is tackling. Right now, there are tons of different Language Models (LMs) out there, each with its own strengths and weaknesses. But no single model is the ultimate champion. So, naturally, researchers are looking for ways to merge them, to create a super-brain that's better than the sum of its parts.

The problem is, the current methods for merging these models often have drawbacks. Some require a lot of extra data and computation, which can be expensive and time-consuming. Others end up messing with the internal knowledge that each model already possesses, kind of like scrambling the brains of our expert team.

That’s where this new technique, called SeMe (Semantic-based Merging), comes in. What's really cool about SeMe is that it’s data-free and training-free. That means it doesn’t need any extra data to work its magic, and it doesn't require retraining the models. It’s like finding a universal translator that allows our experts to collaborate seamlessly without needing to learn a new language.

So, how does it work? Well, SeMe focuses on aligning the semantic meaning of the models' internal representations. Think of it like this: each layer of a Language Model "thinks" about information in a certain way. SeMe figures out how those different ways of thinking relate to each other and then merges the models layer by layer, ensuring that the important stuff is preserved. It's like carefully combining the notes from different experts in a way that keeps the core message intact.

The researchers found that SeMe works surprisingly well across different types of Language Models and tasks. It consistently outperforms existing methods, both in terms of performance and efficiency. And, crucially, it doesn't mess with the models' existing knowledge!

This is a pretty big deal because it opens up the possibility of creating much more powerful and versatile AI systems without having to spend a fortune on data and training. Imagine being able to combine specialized AI models for everything from medical diagnosis to financial forecasting, creating customized solutions that are both accurate and efficient.

So, why should you care about this research?

For the AI enthusiasts: This is a major step towards more scalable and interpretable model composition. It could lead to the development of entirely new types of AI systems that are more powerful and efficient than anything we have today.

For the business leaders: SeMe offers a way to leverage the power of AI without breaking the bank. It could enable companies to create customized AI solutions that are tailored to their specific needs, without having to invest in massive amounts of data and training.

For everyone else: This research highlights the ongoing effort to make AI more accessible and useful. By finding ways to combine existing models, researchers are paving the way for a future where AI can help us solve some of the world's most pressing problems.

This paper brings up some interesting questions for me:

How far can we push this "knowledge-aware" merging? Could we eventually create a single, unified AI model that combines all the knowledge of the world?

What are the ethical implications of combining AI models in this way? How do we ensure that the resulting systems are fair and unbiased?

Could SeMe be adapted to merge other types of AI models besides Language Models, like image recognition or reinforcement learning models?

That's all for this episode of PaperLedge! I hope you found this research as fascinating as I did. Until next time, keep learning, keep questioning, and keep exploring the amazing world of AI!

Hey everyone, Ernis here, and welcome back to PaperLedge! Today we're diving into a fascinating new research paper that asks: How good are AI agents, like the ones powering self-driving cars or robots, at actually understanding and manipulating the world around them? Not just recognizing objects, but planning and building things in a virtual space?

The paper introduces something called MineAnyBuild, which is basically a super-cool, comprehensive benchmark designed to test the spatial planning skills of AI agents inside the Minecraft game. Think of Minecraft as the ultimate digital sandbox – agents can mine resources, craft tools, and build structures.

Now, previous tests for AI "spatial intelligence" often relied on things like answering questions about pictures (Visual Question Answering, or VQA). But the researchers argue that's like asking someone to describe how to build a house without ever handing them a hammer or letting them lay a brick. There's a gap between understanding the theory and actually doing it.

MineAnyBuild bridges that gap. It challenges AI agents to create executable building plans based on multi-modal instructions - think text descriptions, images, or even voice commands. So, a player could tell the agent: "Build a cozy cottage with a chimney next to the river using stone bricks and a wooden door." The agent then needs to figure out how to make that happen in Minecraft. It's like giving an architect a brief and expecting them to design a building that can actually be constructed.

The benchmark has 4,000 curated spatial planning tasks and can be infinitely expanded by leveraging player-generated content. That's a lot of digital LEGO bricks!

The researchers evaluate the agents on four key areas:

So, what did they find? Well, the existing AI agents, even the ones based on powerful Multimodal Large Language Models (MLLMs), struggled! They showed some potential, but also some serious limitations in their spatial planning abilities. It's like they can talk about building a house, but they don't know how to swing a hammer or read a blueprint.

Why does this matter? Well, think about it. If we want AI to truly help us in the real world – to build robots that can assemble furniture, design sustainable cities, or even assist in disaster relief – they need to be able to understand and plan in three-dimensional space. This research provides a valuable tool for measuring and improving those skills.

This research could be useful to:

This paper makes us think about some important questions:

That's it for this episode of PaperLedge! I hope you found this research as fascinating as I did. Until next time, keep learning and keep exploring!

Alright learning crew, Ernis here, ready to dive into some seriously cool research! Today, we're tackling a paper that's all about making AI smarter when it comes to understanding geometry – think shapes, angles, and spatial relationships. It's called... well, let's just call it "Making AI a Geometry Whiz."

So, what's the big deal? You know how Large Language Models (LLMs) like GPT-4 are amazing at understanding and generating text? Well, Large Multimodal Models (LMMs) are like their even cooler cousins – they can also understand images! They're trained on massive datasets of images and text, learning to connect what they see with what they read.

Think of it like this: imagine showing a toddler a picture of a dog and saying "dog." They eventually connect the image with the word. LMMs do something similar, but on a massive scale.

Now, these LMMs are pretty good at visual perception tasks, like identifying objects in a picture. But when it comes to really reasoning about geometric problems – like, say, figuring out the area of a triangle based on a diagram and some text – they often struggle. The researchers behind this paper found that the way these LMMs are initially trained limits their detailed reasoning abilities, especially in geometry.

Why? Because a common way to train the "vision" part of these models is through something called "contrastive learning." Imagine showing the AI a picture of a cat and telling it, "This is a cat." Then, you show it a picture of something else (like a dog) and tell it, "This is not a cat." The AI learns to distinguish between cats and non-cats by contrasting them. However, the "non-cat" examples are often too easy. It's like teaching someone to recognize the Mona Lisa by only showing them blurry photos of random objects as "not Mona Lisa."

"The inherent limitations of contrastive learning upon summarized descriptions fundamentally restrict the capabilities of models in meticulous reasoning, particularly in crucial scenarios of geometric problem-solving."

This is where the really clever part comes in. The researchers developed a new training method called "hard negative contrastive learning." Basically, they made the "non-cat" examples much harder. For the image side, they did this by taking a diagram and tweaking the code that generated the diagram in the first place to create similar, but incorrect, diagrams. For the text side, they did it by slightly changing the problem description using geometry rules or by finding similar but ultimately wrong descriptions from other problems.

Think of it like this: instead of showing the AI a blurry photo of a shoe as "not Mona Lisa," they showed it a slightly altered version of the Mona Lisa itself – maybe with a slightly different smile or background. This forces the AI to pay much closer attention to the details and learn to distinguish the real Mona Lisa from very similar fakes.

They used this "hard negative" approach to train a model based on CLIP (Contrastive Language-Image Pre-training), calling it MMCLIP (Multimodal Math CLIP). Then, they used this improved "vision" encoder to train an LMM specifically for geometric problem-solving, which they dubbed MMGeoLM.

And guess what? It worked! MMGeoLM significantly outperformed other open-source models on geometric reasoning benchmarks. They even claim that their 7B parameter model can compete with closed-source behemoths like GPT-4o!

In essence, these researchers have created a more robust foundation for geometry-aware AI by improving the model's ability to discern subtle nuances. This is incredibly important, because AI that can reason geometrically is crucial for applications like:

The team also dug deeper, experimenting with different ways to create these "hard negative" examples and seeing how the number of examples affected the performance. These experiments provided valuable insights into how to best train LMMs for geometric reasoning. All the code and data are available on Github, which is awesome for reproducibility and further research!

So, what does this all mean for us?

Well, it means that we're one step closer to AI that can truly understand and reason about the world around us. It demonstrates the immense impact of training data quality on the overall performance of multimodal models. It also highlights the importance of thinking outside the box when it comes to training AI – sometimes, making things harder can actually make them smarter.

Okay, learning crew, that's the gist of it! Let's think about this a bit more:

I'd love to hear your thoughts on this! Hit me up on the PaperLedge Discord channel. Until next time, keep learning!

Alright learning crew, Ernis here, ready to dive into another fascinating paper! Today, we're tackling a really interesting challenge in the world of AI, specifically with those super-smart Large Language Models, or LLMs – think of them as the brains behind chatbots and AI writing assistants.

So, these LLMs are constantly getting better, right? And to measure how good they are, we use something called a benchmark. Imagine a benchmark as a standardized test for LLMs, like a spelling bee for computers. It helps us see which models are truly improving and which are just good at sounding smart.

But here's the catch: putting these benchmarks out in the open, on the internet, can actually mess up future LLMs. It's like giving students the answer key before the exam! Why? Because developers might unintentionally (or even intentionally!) use the benchmark questions and answers to train their models. This is called data contamination, and it makes it really hard to know if a model is genuinely smart or just memorized the test.

Now, one way to avoid this is to keep the benchmark super secret, like a hidden vault. But then, we have to trust a single organization to run the tests fairly, and even then, people can still try to "overfit" to the test by repeatedly querying the system, slowly figuring out the answers. It's like trying to guess the combination to a lock by trying every possible number.

So, what's the solution? That's where this paper comes in! The authors propose a clever way to publish benchmarks without giving away all the answers. Their idea is to inject a little bit of randomness into the answers. Think of it like this: instead of having only one correct answer to a question, they create several logically correct answers, but only include one of them in the benchmark.

Imagine the question is "What is a synonym for 'happy'?" Instead of just "joyful," the benchmark might also accept "content," "elated," or "cheerful," but only one of those is marked as the "correct" answer. This introduces a level of uncertainty that makes it much harder for models to cheat. This approach reduces what is called the Bayes accuracy of the benchmark. In simple terms, it lowers the highest score a model could possibly achieve.

Why is this important? Because even the smartest LLM shouldn't be able to score above this Bayes accuracy if it's truly learning and not just memorizing the benchmark. If a model does surpass this limit, it's a big red flag that something's fishy – that it's likely been trained on the benchmark data and is therefore contaminated.

The researchers tested this method on a bunch of different benchmarks, models, and training techniques, and they found that it was surprisingly good at detecting data contamination. Basically, it's like a built-in lie detector for LLMs!

Why should you care?

So, a couple of things that popped into my head while reading this paper:

Food for thought, learning crew! What do you think? Let me know in the comments!

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool research! Today we're talking about giving AI a powerful new tool: the entire internet!

We all know how impressive those big language models are, right? Like ChatGPT, Gemini, the list goes on. They can answer almost anything, but a lot of that magic happens behind closed doors. It's like knowing the chef makes an amazing dish, but you have no idea what ingredients they use or how they cook it. That's where this paper comes in.

These researchers wanted to build a system, they call it ManuSearch, that makes "deep search" more accessible and transparent. Think of it like this: imagine you're trying to solve a complex puzzle. Instead of just staring at all the pieces at once, ManuSearch breaks it down into smaller, more manageable tasks, just like a team of experts working together.

So, how does it work? Well, it uses three “agents”:

First, we have the Solution Planning Agent. It's like the team leader, figuring out the best strategy and breaking down the big question into smaller, more focused sub-questions. Think of it as planning your road trip - you need to figure out the destination, the route, and the stops along the way.

Next up is the Internet Search Agent. This agent is the researcher. It goes out and finds relevant information on the web using those sub-questions. It's like having a super-efficient research assistant who can quickly find exactly what you need online.

Finally, we have the Structured Webpage Reading Agent. This agent is like your highly skilled note-taker. It sifts through all the web pages found by the Search Agent and extracts the key pieces of information, structuring it for the other agents to use. It's like highlighting the important sentences in a textbook chapter.

These agents work together. The Solution Planning Agent defines the sub-questions, the Internet Search Agent finds the answers, and the Webpage Reading Agent extracts the key evidence. Then, they all collaborate to solve the original problem.

Now, to test how well ManuSearch works, the researchers created a new, super-challenging benchmark called ORION. This benchmark focuses on "long-tail entities", which are basically obscure or niche topics. Think of it like asking the AI about a really specific species of beetle found only in a remote part of the Amazon rainforest. This requires real reasoning and the ability to sift through a lot of potentially irrelevant information.

And guess what? ManuSearch didn't just perform well; it beat existing open-source systems and even some of the top closed-source systems! That's a huge deal because it shows that this transparent, modular approach is not only feasible but also incredibly effective.

Why does this matter?

For researchers: It provides a framework that can be easily extended and improved upon. It allows for more reproducible and transparent research in the field of deep search.

For developers: It offers a blueprint for building their own web-augmented LLMs.

For everyone: It moves us closer to a future where AI is more accessible and understandable.

The researchers have even released their code and data, which is fantastic news for the open-source community!

So, what questions does this research bring to mind?

First, given that ManuSearch is built around internet search, how vulnerable is it to misinformation or biased sources online? In other words, if the internet is full of junk, how does ManuSearch filter out the noise and find the truth?

Second, could this approach be adapted to other complex problem-solving tasks beyond just answering questions? What about using it for scientific discovery, or creative writing, or even something like coding?

Third, if systems like ManuSearch become more powerful, what are the ethical implications of having AI that can access and process vast amounts of information? How do we ensure that these systems are used responsibly and don't perpetuate harmful biases?

That's all for this episode! Let me know your thoughts on ManuSearch. I'm curious to see where this research leads!

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool science! Today, we're shrinking down – way down – to the nanoscale, where things get… well, let's just say seeing and understanding these tiny particles is a huge challenge. Think of it like trying to assemble a LEGO set where you only have a blurry photo of the finished product.

The paper we're looking at tackles this problem head-on. Nanomaterials, these incredibly small substances, are becoming super important in everything from better batteries to targeted drug delivery. To really use them effectively, we need to know exactly what they look like – their topology, as the scientists say. Are they spheres? Rods? Weird, lumpy blobs? This shape dictates their properties.

Now, the problem is, getting good images of these nanoparticles is tough. Really tough. And even when you do get an image (usually from something like a scanning electron microscope, or SEM), figuring out what you're actually seeing – segmenting the image – is even harder. It's like trying to pick out individual grains of sand on a beach from a satellite photo. That means labeling these images is painstaking and requires experts. And that means… not many labeled images exist!

This lack of data is a major bottleneck for training AI to automatically analyze these images. If the AI doesn't have enough examples to learn from, it's like trying to teach a dog tricks with no treats or guidance.

So, what's the solution? Well, these researchers came up with something pretty ingenious: they built a system called F-ANcGAN (try saying that five times fast!), which is a fancy acronym, but the key is that it creates realistic fake images of nanoparticles.

Think of it like this: imagine you're trying to learn how to draw a cat. You could spend years trying to find the perfect cat to model. Or, you could use a special computer program that understands what cats are supposed to look like and then generates endless variations. That's essentially what F-ANcGAN does, but for nanoparticles.

Here's how it works (in a nutshell, of course!):

They even use "augmentation methods" – like stretching, rotating, and slightly distorting the few real images they do have – to create even more variety in the training data. It's like showing the cat artist pictures of cats in different poses and lighting conditions.

The results? Pretty impressive! They tested their system on images of titanium dioxide (TiO$_2$) nanoparticles (commonly used in sunscreen and pigments). They used a metric called the FID score to evaluate how realistic the generated images were. A lower score is better, and they achieved a score of nearly 10, which is a significant improvement over previous methods.

Basically, they're making it easier for researchers, especially those in labs with limited resources, to study these important nanomaterials.

So, why should you care? Well, if you're in materials science, this could seriously speed up your research. If you're interested in medicine, it could lead to better drug delivery systems. And if you're just curious about the world around you, it's a fascinating example of how AI can help us understand even the tiniest things.

Now, a few questions that popped into my head while reading this:

That's all for this episode! Until next time, keep learning!

Hey learning crew, Ernis here, ready to dive into some fascinating research! Today, we're talking about how computers recognize you just by the way you walk – that's gait recognition!

Now, you might think this is straight out of a spy movie, and in some ways, it is! But gait recognition has serious real-world applications, from security systems that can identify individuals in crowds to helping doctors diagnose neurological conditions by analyzing subtle changes in someone's walk.

The paper we're unpacking today is all about using large vision models, or LVMs, for gait recognition. Think of LVMs as super-smart computers that have been trained on massive amounts of visual data, allowing them to "see" and understand images in incredible detail. They're like having a super-powered art critic analyzing every step you take!

So, what's the buzz? Well, researchers have already been using these LVMs to recognize people's gaits, and they've been getting pretty good results. But the authors of this paper thought something was missing. They felt that existing methods were too focused on pre-programmed ideas about what makes a gait unique – things like stride length or arm swing. It's like forcing the art critic to only focus on brushstrokes and ignoring the overall composition of the painting.

The real power, they argued, lies within the LVM itself! These models have tons of "layers," each capturing different aspects of the visual information. Imagine it like peeling an onion – each layer reveals a different level of detail, from the overall shape to the tiniest textures.

This research found that different layers of the LVM are good at different things when it comes to gait recognition. Some layers might be better at identifying overall body movement, while others might be better at spotting subtle differences in how your feet hit the ground. And get this: combining information from multiple layers gives you a much better result than relying on any single layer alone!

Think of it like this: you're trying to identify a friend in a crowd. One person tells you they're wearing a blue shirt. Another person tells you they have curly hair. Neither piece of information alone is enough, but put them together, and you can pinpoint your friend much more easily.

Based on this insight, the researchers developed a new approach called BiggerGait. It's a simple but effective way to combine the information from different layers of the LVM to achieve state-of-the-art gait recognition. The cool thing is that it works well even when the LVM hasn't been specifically trained on gait data. This makes it a really universal baseline for future research.

They tested BiggerGait on several datasets, including CCPG, CAISA-B, SUSTech1K, and CCGR_MINI, and it consistently outperformed existing methods, both in situations where the LVM had seen similar data before and in situations where it hadn't. It's like showing that your friend-finding strategy works just as well at a concert as it does at a football game.

The authors are even making their models and code publicly available, so other researchers can build upon their work! That's what we love to see - open and collaborative science!

So, why does this matter? Well, for security companies, it could mean more accurate and reliable surveillance systems. For healthcare providers, it could mean new tools for diagnosing and monitoring neurological disorders. And for AI researchers, it could mean a better understanding of how LVMs work and how to unlock their full potential.

It also raises some interesting questions:

That's all for today, learning crew! I hope you found this exploration of BiggerGait as fascinating as I did. Until next time, keep learning and keep questioning!