Hey PaperLedge crew, Ernis here, ready to dive into some fascinating research that blends robotics, vision, and good ol' human ingenuity! Today, we're talking about a system called Vision in Action, or ViA, and it's all about teaching robots how to see and act more like us, especially when they're using both hands.
Think about it: when you're cooking, you're not just blindly grabbing ingredients. You're constantly adjusting your gaze, focusing on what's important, and even moving your head to get a better view, right? That's active perception - using your vision to actively guide your actions. This paper explores how we can equip robots with that same skill.
So, how did the researchers tackle this? Well, they started with the hardware. They gave their robot a robotic neck, a simple but effective 6-DoF (that's six degrees of freedom, meaning it can move in a lot of ways) system that allows the robot to mimic human-like head movements. It's like giving the robot the ability to tilt, pan, and swivel its head to get the perfect angle!
But simply having the hardware isn't enough. They needed to teach the robot how to use it. This is where the cool part comes in: they used a VR-based teleoperation interface. Imagine putting on a VR headset and controlling the robot's "eyes" and hands as if they were your own. This creates a shared observation space so the robot can learn from our natural head movements.
"ViA learns task-relevant active perceptual strategies (e.g., searching, tracking, and focusing) directly from human demonstrations."
Now, VR can sometimes cause motion sickness because of lag, right? The researchers came up with a clever solution: they used an intermediate 3D scene representation. Basically, the VR headset shows a real-time view of the scene, even if the robot's physical movements are a bit delayed. It's like having a constantly updating map that keeps you oriented even if your GPS is a little slow.
Here's a quick breakdown:
Human demonstrates: A person in VR shows the robot how to perform a task.
Robot learns: The robot observes and learns the active perception strategies.
Robot performs: The robot uses its newfound skills to complete the task autonomously.

The results? Pretty impressive! The researchers tested ViA on three complex, multi-stage bimanual manipulation tasks – think things like assembling objects where parts might be hidden from view. ViA significantly outperformed other systems, proving that learning from human demonstrations can lead to more robust and effective robot performance.
So, why does this matter?
For researchers: ViA provides a new approach to robot learning, focusing on active perception.
For industry: This could lead to more capable robots in manufacturing, logistics, and other industries.
For everyone: Imagine robots that can assist with complex tasks in our homes, helping us with cooking, cleaning, or even caring for loved ones.
This research shows that equipping robots with active perception skills can significantly improve their ability to perform complex tasks. By learning from human demonstrations, robots can become more adaptable, efficient, and helpful in a wide range of applications.
Here are a couple of things I was pondering while reading:
Could this VR training method be adapted to teach robots other skills beyond just vision, like tactile sensing or problem-solving?
What ethical considerations arise as robots become more capable of mimicking human behavior and decision-making?
That's all for this episode, folks! Let me know what you think of ViA and what other questions this research sparks for you. Until next time, keep learning!Credit to Paper authors: Haoyu Xiong, Xiaomeng Xu, Jimmy Wu, Yifan Hou, Jeannette Bohg, Shuran Song

Hey PaperLedge crew, Ernis here! Get ready to dive into some seriously fascinating stuff today. We're talking about AI, specifically those super-smart reasoning models that are starting to feel like personal assistants. You know, the kind that can plan your trip, answer complex questions, and even write emails for you.
Now, we often worry about what these AI assistants say to the world, right? Are they giving out bad advice? Spreading misinformation? But what about what they're thinking? That's where things get really interesting, and maybe a little scary.
This new paper we're looking at is all about privacy leakage in the "reasoning traces" of these models. Think of it like this: imagine you're trying to solve a puzzle. You wouldn't just magically know the answer, would you? You'd try different pieces, think through possibilities, maybe even mutter to yourself along the way. That's the "reasoning trace" – the internal steps the AI takes to arrive at its final answer.
The common assumption has been that these reasoning traces are private, internal, and therefore safe. Like your own private thoughts! But this research challenges that BIG TIME.
The researchers found that these reasoning traces often contain incredibly sensitive user data! We're talking personal details, private preferences, maybe even things you wouldn't want anyone to know.
"Reasoning improves utility but enlarges the privacy attack surface."
So, how does this information leak out? Two main ways:
Prompt Injections: Think of this as tricking the AI into revealing its inner thoughts. It's like asking a loaded question designed to get the AI to spill the beans.
Accidental Leakage: Sometimes, the AI just blurts out sensitive info in its final output without even realizing it. Like accidentally mentioning your friend's surprise party in front of them!
And here's the kicker: the researchers discovered that the more the AI reasons – the more steps it takes to solve a problem – the more likely it is to leak private information! They call this "test-time compute approaches," and it basically means giving the AI more time and resources to think.
It's like this: the more you brainstorm out loud, the higher the chance you'll accidentally say something you shouldn't, right? Same principle!
The researchers found that giving the models more "thinking power" actually made them more cautious in their final answers. They were less likely to give inaccurate or misleading information. BUT, they were also reasoning more verbosely, which paradoxically increased the amount of private data leaked in their reasoning traces.
This is a serious problem because it highlights a fundamental tension: we want AI to be smart and helpful, but the very process of reasoning makes them more vulnerable to privacy breaches. It's like trying to make a car safer by adding more airbags, but the airbags themselves accidentally deploy and cause minor injuries!
The paper concludes that we need to focus on the model's internal thinking, not just its outputs, when it comes to privacy. We can't just slap a censor on the AI's mouth; we need to figure out how to protect its brain!
So, what does this all mean for us, the PaperLedge learning crew?
For the everyday user: Be mindful of the personal information you share with AI assistants. They might be thinking about it in ways you don't expect!
For developers: We need to find ways to make AI reasoning more private, perhaps by developing techniques to sanitize or encrypt reasoning traces.
For policymakers: This research highlights the need for regulations that protect user privacy not just in AI outputs, but also in their internal processes.
This is a really important area of research, and it's only going to become more relevant as AI becomes more integrated into our lives.
And that leads me to a few questions for you all to ponder:
Given this tension between utility and privacy, where do we draw the line? How much privacy are we willing to sacrifice for better AI performance?
What innovative technical solutions might mitigate privacy risks within AI reasoning traces without diminishing performance?
Should we be thinking about "AI rights" in the same way we think about human rights, including a right to privacy?
Let me know your thoughts in the comments below. Until next time, keep learning, keep questioning, and keep those privacy settings locked down!Credit to Paper authors: Tommaso Green, Martin Gubri, Haritz Puerto, Sangdoo Yun, Seong Joon Oh

Hey everyone, Ernis here, and welcome back to PaperLedge! Today, we're diving into some seriously cool research that's trying to build smarter, more helpful AI. Think of it as teaching robots to not just know things, but to actually do things in the real world, using the internet as their ultimate instruction manual.
The paper we're looking at is all about bridging the gap between AI that lives in the digital world and AI that exists in the real, physical world. Right now, most AI is stuck in one or the other. You've got AI that can scour the web for information like a super-powered librarian, and you've got robots that can navigate and manipulate objects. But rarely do you see them working together.
Imagine this: you want a robot to cook you dinner using a recipe it found online. Seems simple, right? But that robot needs to understand the recipe (digital), find the ingredients in your kitchen (physical), and then actually follow the instructions to create something edible (physical + digital). That's the kind of integrated intelligence this paper is tackling.
To make this happen, the researchers created something called Embodied Web Agents. Think of it as a new type of AI that can seamlessly switch between interacting with the physical world and using the vast knowledge available on the internet. To test these agents, they built a special simulation platform – a virtual world that combines realistic 3D environments (like houses and cities) with functional web interfaces.
It's like a giant video game where the AI can not only walk around and see things, but also browse websites, fill out forms, and generally interact with the web just like we do.
Using this platform, they created the Embodied Web Agents Benchmark, a set of challenges designed to test how well these AI agents can solve real-world tasks using both physical and digital skills. These tasks include:
Cooking a meal from an online recipe.
Navigating a city using dynamic map data.
Shopping for groceries online and then finding them in a virtual store.
Planning a tourist trip based on web research and then navigating to the landmarks.
These aren't just simple tasks; they require the AI to reason across different types of information and environments. It's like asking someone to plan a surprise party, but they can only use the internet and robots to do it!
So, what did they find? Well, the results showed that even the best AI systems are still far behind humans when it comes to these integrated tasks. This highlights both the challenges and the huge potential of combining embodied cognition (how we learn through our bodies) with web-scale knowledge access.
Why does this matter? Well, imagine a future where robots can help us with all sorts of complex tasks, from managing our homes to assisting us at work. Think about:
Robots helping elderly people stay independent by assisting with cooking, medication reminders, and navigation.
AI assistants that can plan complex travel itineraries, taking into account real-time traffic, weather, and user preferences.
Robots assisting in disaster relief efforts by quickly gathering information online and then navigating to affected areas to provide aid.
This research is a crucial step toward creating truly intelligent AI that can understand and interact with the world around us in a meaningful way. It's about moving beyond simple automation and towards AI that can truly collaborate with us.
Now, here are a couple of things that really got me thinking:
If AI agents become so reliant on the internet for information, how do we ensure they're accessing reliable and trustworthy sources? Could we end up with robots that are misinformed or even biased?
What are the ethical implications of having robots that can perform complex tasks in the real world using web-based knowledge? How do we ensure they're acting responsibly and in our best interests?
These are big questions, and I'd love to hear your thoughts! You can find links to the paper and the project website at https://embodied-web-agent.github.io/. Let me know what you think in the comments. Until next time, keep learning!Credit to Paper authors: Yining Hong, Rui Sun, Bingxuan Li, Xingcheng Yao, Maxine Wu, Alexander Chien, Da Yin, Ying Nian Wu, Zhecan James Wang, Kai-Wei Chang

Alright learning crew, Ernis here, ready to dive into another fascinating paper! Today, we're tackling a challenge in the world of AI image generation: speed. You know those amazing AI tools that can conjure up photorealistic images from just a text prompt? They're powered by something called diffusion models, and while the results are stunning, they can be s-l-o-w.
Think of it like this: imagine you're a chef trying to bake the perfect cake. Diffusion models are like chefs who meticulously check the cake's progress every single minute, adjusting the oven, adding a sprinkle of this, a dash of that. It's precise, but it takes forever.
This paper introduces a clever technique called Evolutionary Caching to Accelerate Diffusion models, or ECAD for short. The key concept here is "caching," kind of like a chef pre-making certain ingredients or steps ahead of time.
But here's the twist: instead of just guessing which steps to pre-make, ECAD uses a genetic algorithm. Think of it like an evolutionary process. It starts with a bunch of different caching strategies, tests them out, and then "breeds" the best ones together, gradually improving the caching schedule over time. It's like Darwinian evolution, but for image generation!
Here's what makes ECAD particularly cool:
It doesn't require changing the underlying AI model itself. It’s like adding a turbocharger to a car without having to rebuild the engine.
It learns a custom caching schedule for each AI model. So, no one-size-fits-all approach. It's like tailoring a suit to perfectly fit each individual.
It finds the sweet spot between image quality and speed. Want the absolute best image? Go slow. Need a quick result? ECAD can adjust accordingly, giving you fine-grained control.
It generalizes well. Even if it learns on smaller images, it can still speed up the generation of larger, more complex ones.
The researchers tested ECAD on some popular image generation models (PixArt-alpha, PixArt-Sigma, and FLUX-1.dev) and showed significant speed improvements compared to previous techniques. They even managed to improve both speed and image quality at the same time, which is like finding a magical ingredient that makes your cake taste better and bake faster!
So, why does this matter? Well:
For developers, ECAD offers a way to make their AI image generation tools faster and more efficient without needing to retrain the models.
For users, this means faster generation times and access to higher-quality images sooner.
For the environment, it means less energy consumption, as these models require a lot of computational power.
"ECAD offers significant inference speedups, enables fine-grained control over the quality-latency trade-off, and adapts seamlessly to different diffusion models."
Pretty neat, right?
This research opens up some interesting questions:
Could this evolutionary caching approach be applied to other types of AI models beyond image generation?
How far can we push the speed-quality trade-off? Is there a theoretical limit to how fast we can generate high-quality images?
Could we use ECAD to help us better understand how diffusion models actually work? By observing the caching schedules that evolve, could we gain insights into the most important steps in the generation process?
You can find the project website at https://aniaggarwal.github.io/ecad and the code at https://github.com/aniaggarwal/ecad. Dive in, experiment, and let me know what you think!
That's all for this episode. Keep learning, everyone!Credit to Paper authors: Anirud Aggarwal, Abhinav Shrivastava, Matthew Gwilliam

Hey Learning Crew, Ernis here, ready to dive into some fascinating research! Today, we're talking about something super relevant in our increasingly AI-driven world: detecting text written by AI, specifically those sneaky, privately-tuned large language models (LLMs).
Think of it like this: you've got a popular recipe, say for chocolate chip cookies. That's your open-source LLM. Now, someone takes that recipe and tweaks it, adding a secret ingredient or changing the baking time. That's a privately-tuned LLM. It's still technically a chocolate chip cookie, but it's unique. And figuring out if this particular cookie came from the original recipe, or this altered version, is what this research is all about.
Why is this important? Well, as LLMs become more powerful, they're also being used for not-so-great things. Like spreading misinformation or even cheating on schoolwork. So, we need ways to tell if text was written by a human or an AI. Existing detectors are pretty good at spotting text from the standard AI models. But what happens when someone uses a privately-tuned LLM? That's where things get tricky.
This is the problem that researchers tackled head-on. They noticed that existing detection methods tend to focus on memorizing the specific quirks of individual AI models. But when an LLM is fine-tuned with private data, it develops new quirks, throwing off those detectors. It's like trying to identify a breed of dog based on its fur color, but then someone dyes the dog's fur – you're back to square one!
So, these researchers came up with a clever solution called PhantomHunter. The core idea of PhantomHunter is to look for what they call "family-level traits." Instead of focusing on the individual quirks of each model (the specific "dye" job), it looks for the underlying characteristics that are shared across the entire family of models, like the original recipe. It's like recognizing that both the original cookie and the tweaked cookie share certain fundamental baking techniques.
"Its family-aware learning framework captures family-level traits shared across the base models and their derivatives, instead of memorizing individual characteristics."
To put it simply, it's like recognizing that all chocolate chip cookies, no matter how they're tweaked, still have flour, butter, and sugar as key ingredients!
Now, here's the really cool part. The researchers tested PhantomHunter on data from some popular LLM families like LLaMA, Gemma, and Mistral. And guess what? It blew the competition out of the water! It outperformed seven other detectors and even beat out three industrial services, achieving impressive accuracy, with F1 scores over 96%.
So, why should you care about this research?
Students and Educators: This could help ensure academic integrity and identify AI-generated content in assignments.
Journalists and News Consumers: This could help combat the spread of AI-generated misinformation and ensure the authenticity of news sources.
Businesses: This could help protect intellectual property and prevent the misuse of AI in content creation.
Anyone who consumes information online: Understanding how to detect AI-generated text is becoming an essential skill in navigating the digital world.
This research is a step in the right direction in the ongoing battle against AI-generated misinformation and academic misconduct. But it also raises some interesting questions:
As LLMs continue to evolve, how can we ensure that detectors like PhantomHunter stay ahead of the curve?
Could this technology be misused to stifle creativity or unfairly accuse people of using AI when they haven't?
What ethical considerations should we keep in mind as we develop and deploy AI detection technologies?
Food for thought, Learning Crew! Thanks for joining me on this exploration of PhantomHunter. Until next time, stay curious and keep learning!Credit to Paper authors: Yuhui Shi, Yehan Yang, Qiang Sheng, Hao Mi, Beizhe Hu, Chaoxi Xu, Juan Cao

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool 3D stuff! Today, we're tackling a paper that's all about making computer-generated 3D objects look amazing – like, indistinguishable from the real deal.
For years, creating super realistic 3D models has been a huge hurdle. Think about video games, movies, or even designing new products. We want these digital objects to look and feel authentic, but it's surprisingly tough to pull off. The current technology, while impressive, often misses the mark. They struggle to create textures that pop, shapes that feel natural, and overall realism that fools the eye.
Now, there's this exciting new technique called diffusion models. Imagine taking a blurry photo and slowly, carefully, adding details until it becomes crystal clear. That's kind of how diffusion models work in 3D. They start with a basic shape and then refine it step-by-step to create something complex. But even these models can fall short when it comes to truly matching what a human designer would create. They might not quite get the instructions right, or the textures might look a little…off.
That's where today's paper comes in! It introduces a new system called Nabla-R2D3. Think of it like giving these 3D diffusion models a really good coach. This "coach" uses something called reinforcement learning, which is like training a dog with treats. You give the model "rewards" when it does something right, and it learns to do more of that thing.
What makes Nabla-R2D3 special is that it uses 2D rewards to guide the 3D model. Sounds weird, right? Imagine you're trying to teach a robot to sculpt a vase. Instead of directly telling it how to move its tools in 3D, you show it pictures of beautiful vases from different angles (2D images). The robot then figures out how to adjust the 3D shape to match those pictures. It's a much more efficient way to train the model!
The cool thing is, Nabla-R2D3 builds upon another smart method called Nabla-GFlowNet. It's like having a really precise compass that points the model in the right direction, ensuring it improves step by step, instead of wandering off course.
As the paper states, Nabla-R2D3 enables "effective adaptation of 3D diffusion models using only 2D reward signals."
So, why should you care about this? Well:

Gamers and movie buffs: More realistic characters, environments, and special effects!


Designers and engineers: Faster and better prototyping of new products. Imagine designing a car and seeing a photorealistic 3D model in minutes!


Anyone interested in AI: This is a big step towards AI that can create, not just analyze. It shows us how to train AI to understand and create complex, realistic things.

The researchers showed that Nabla-R2D3 is much better at learning and improving than other methods. Those other methods either didn't learn much or found sneaky ways to "cheat" the reward system without actually creating better models. Nabla-R2D3, on the other hand, consistently improved the models with just a few training steps.
This is like the difference between a student who crams for a test and a student who truly understands the material. Nabla-R2D3 helps the model truly understand what makes a good 3D object, rather than just finding a quick fix.
So, here are a couple of questions that popped into my head while reading this:

How far away are we from AI being able to generate entire virtual worlds, complete with realistic physics and interactions? Could Nabla-R2D3 be a piece of that puzzle?


Could this technique be used to create personalized 3D models? Imagine entering a few preferences and having the AI generate a unique object just for you!

I'm excited to see where this research leads! It's a big step towards a future where AI can help us create amazing and realistic 3D experiences. What do you think, crew? Let's hear your thoughts!Credit to Paper authors: Qingming Liu, Zhen Liu, Dinghuai Zhang, Kui Jia

Alright learning crew, Ernis here, ready to dive into some fascinating research that's all about making our AI overlords... I mean, helpful assistants... think smarter, not necessarily longer.
We're talking about Large Language Models, or LLMs – those powerful AIs that can write essays, answer questions, and even code. Think of them as super-smart students, but sometimes, they get a little too caught up in their own thought processes. Imagine giving a student a simple math problem, and they fill up pages and pages with calculations, even though a shorter, more direct approach would have worked just as well. That’s the problem this paper tackles.
The researchers found that these LLMs often spend a lot of time reasoning, trying to improve their answers. But here's the thing: all that extra thinking doesn't always lead to a significant improvement in performance. It’s like diminishing returns – you're spending more resources (time, energy, processing power) for only a tiny boost in accuracy. And that extra processing power costs money! So, how do we get these LLMs to be more efficient, especially when we're on a tight budget for computational resources?
That's where "Budget Guidance" comes in. This research introduces a clever technique to control how long an LLM "thinks" before giving an answer, without sacrificing accuracy. Think of it like giving that overthinking student a gentle nudge: "Hey, you're on the right track, but you only have five minutes to solve this problem."
Here's the gist: they created a little "predictor" that keeps track of how much "thinking time" is left as the LLM generates its response. This predictor uses something called a Gamma distribution to estimate the remaining "thinking length". Don't worry about the math – just think of it as a way to gauge how much time is left. This information is then used to subtly guide the LLM's response, ensuring it stays within the specified "thinking budget." It's like a GPS for the LLM's thought process.
To put it another way, imagine you're baking a cake. You have a recipe (the problem), and you need to follow it to get the best result. But you only have a limited amount of ingredients (the budget). Budget Guidance is like a kitchen timer that tells you how much time you have left to mix, bake, and decorate, so you don't run out of ingredients before you finish the cake.
The results are pretty impressive! In some cases, they saw a 26% improvement in accuracy on tricky math problems when using Budget Guidance, compared to letting the LLM think as long as it wanted. And get this: they achieved this while using only 63% of the "thinking tokens" (think of "tokens" as units of thought) compared to the full-thinking model. That's a huge efficiency gain!
But here's the really cool part: Budget Guidance seems to work well across different kinds of tasks, not just math. The researchers even found that it could estimate how difficult a question is. It's like the LLM is saying, "Whoa, this is a tough one, I need to allocate a bit more of my budget here."
"Budget guidance enables natural control of the thinking length, along with significant token efficiency improvements."
Why does this matter?
For developers: This could lead to more efficient and cost-effective AI applications. You can get better performance without breaking the bank on processing power.
For end-users: Faster and more responsive AI assistants that don't waste your time or resources. Imagine getting quicker answers from your favorite search engine or chatbot.
For researchers: This opens up new avenues for understanding and controlling the reasoning processes of LLMs, potentially leading to even more intelligent and efficient AI systems.
The code for this research is available on GitHub: https://github.com/UMass-Embodied-AGI/BudgetGuidance, so you can check it out for yourselves!
So, after hearing all that, what are your thoughts, learning crew?
Could this approach be applied to other areas besides language models, like robotics or game playing, where resource management is crucial?
How might Budget Guidance be combined with other techniques to further improve the efficiency and accuracy of LLMs?
I'm curious to hear your ideas! Until next time, keep learning, keep questioning, and keep pushing the boundaries of what's possible!Credit to Paper authors: Junyan Li, Wenshuo Zhao, Yang Zhang, Chuang Gan

Hey everyone, Ernis here, and welcome back to PaperLedge! Today, we're diving into some fascinating research that's all about making AI smarter and smaller, so it can run efficiently on our phones, smartwatches, and other edge devices.
The paper is titled "MARCO: Multi-Agent Reinforcement learning with Conformal Optimization," and it tackles a big problem: How do we design AI models that are both accurate and fast enough to work well on devices with limited power and memory? Think of it like trying to fit a powerful gaming PC into a tiny Raspberry Pi box – it's a challenge!
Now, traditionally, building AI for these devices involves a lot of trial and error – tweaking the model's architecture and settings until you find something that works. It's a bit like guessing the right combination lock code through random tries. That takes a long time.
This is where MARCO comes in. The researchers have created a clever system that uses AI to design AI! It's like having a robot architect that can automatically generate blueprints for tiny, efficient AI models.
Here's the cool part: MARCO uses something called multi-agent reinforcement learning. Imagine you have two expert AI agents working together. One is the "hardware configuration agent" (HCA), and it's responsible for the big-picture design, deciding on things like the overall structure of the model. The other is the "quantization agent" (QA), and it's a master of fine-tuning. It decides how much precision each part of the model needs, kind of like choosing the right size wrench for each bolt.
Think of it like this: You're building a house. One contractor (HCA) decides on the number of rooms and the overall layout, while another (QA) decides on the specific materials and finishes for each room to optimize cost and efficiency.
These two agents work together, learning from each other and from a shared goal: to create an AI model that's both accurate and fits within the device's limited resources. They get a reward when they find a good design, encouraging them to explore even better options.
But here’s the real secret sauce: MARCO also uses something called Conformal Prediction (CP). This is like having a built-in risk assessment tool. Before the system spends a lot of time training a particular AI model design, the CP tool provides statistical guarantees about how well it's likely to perform. If the CP tool predicts that a design is unlikely to be successful, it gets filtered out early on, saving a ton of time and energy. It's like having a quality control inspector that catches flaws before you invest heavily in a faulty product.
"MARCO achieves a 3-4x reduction in total search time compared to an OFA baseline while maintaining near-baseline accuracy (within 0.3%)."
The result? MARCO can find good AI model designs much faster than traditional methods. The researchers found a 3-4x speedup compared to other approaches, without sacrificing accuracy!
Why does this matter?
For developers: This means faster development cycles and the ability to deploy AI on a wider range of devices.
For consumers: This could lead to smarter, more responsive devices that consume less battery power.
For the planet: More efficient AI on edge devices means less data needs to be sent to the cloud for processing, which can reduce energy consumption.
This research is a significant step towards bridging the gap between cutting-edge AI and the real-world limitations of edge devices. It's exciting to think about the possibilities that this technology could unlock!
Here are a couple of questions that come to mind:
How adaptable is MARCO to completely new types of hardware or AI tasks? Could it design AI for medical devices or even space exploration?
What are the ethical implications of having AI design AI? How do we ensure that these automatically designed models are fair and unbiased?
I'd love to hear your thoughts on this, crew! Let me know what you think in the comments. Until next time, keep learning!Credit to Paper authors: Arya Fayyazi, Mehdi Kamal, Massoud Pedram