Hey PaperLedge learning crew, Ernis here, ready to dive into some fascinating research! Today, we're tackling a paper about making machine learning even smarter, specifically when it comes to understanding data that’s organized in tables – think spreadsheets or databases. You know, the kind of data that powers so much of our world!
So, imagine you're trying to predict something, like whether a customer will click on an ad or if a loan applicant will default. You feed a machine learning model a bunch of data – age, income, past behavior, etc. But the raw data isn't always enough. Sometimes, you need to engineer new features, which is like creating new columns in your spreadsheet that combine or transform the existing ones to highlight important patterns. Think of it like this: instead of just knowing someone's age and income separately, you might create a new feature that calculates their income-to-age ratio. This new feature could be a stronger predictor than either age or income alone.
That's where feature engineering comes in. It's crucial, but it can be a real headache. It usually requires a lot of human expertise and trial-and-error.
Now, here's where things get interesting. Enter the big guns: Large Language Models, or LLMs. These are the same AI models that power tools like ChatGPT. Researchers have been experimenting with using LLMs to automatically generate these new features. The idea is that LLMs have so much knowledge, they can come up with clever combinations and transformations that we humans might miss.
But there's a catch! According to the paper we're looking at today, these LLM-based approaches often create features that are, well, a bit... boring. They might be too simple or too similar to each other. It's like asking an LLM to write a poem and it keeps giving you variations of the same haiku. The researchers argue this is partly because LLMs have biases in the kinds of transformations they naturally choose, and partly because they lack a structured way to think through the feature generation process.
That brings us to the core of this paper. The researchers have developed a new method called REFeat. Think of it as giving the LLM a smarter set of instructions and a more structured way to brainstorm new features.
The key idea behind REFeat is to guide the LLM using multiple types of reasoning. Instead of just saying, "Hey LLM, make some new features!", REFeat encourages the LLM to think about the problem from different angles. It's like having a team of experts with different perspectives advising the LLM. For example:
Maybe one type of reasoning focuses on identifying combinations of features that are logically related.
Another might focus on transforming features to make them more suitable for the machine learning model.
A third might look for features that are known to be important in similar problems.
By steering the LLM with these different reasoning strategies, REFeat helps it discover more diverse and informative features. It's like guiding a student to explore different approaches to solving a problem, rather than just letting them blindly stumble around.
So, what did the researchers find? They tested REFeat on a whopping 59 different datasets, and the results were impressive. Not only did REFeat lead to higher predictive accuracy on average, but it also discovered features that were more diverse and meaningful. In other words, it not only made the machine learning models better at making predictions, but it also helped us understand the data better.
"These results highlight the promise of incorporating rich reasoning paradigms and adaptive strategy selection into LLM-driven feature discovery for tabular data."
In essence, this paper shows that we can leverage the power of LLMs to automate feature engineering, but only if we guide them effectively. By providing structured reasoning and encouraging diverse exploration, we can unlock the full potential of these models to discover hidden patterns in our data.
Why does this matter to you, the PaperLedge learning crew?
For data scientists and machine learning engineers, this research offers a promising new approach to automating a time-consuming and often frustrating task.
For business professionals, this research could lead to better predictive models and insights, ultimately improving decision-making in areas like marketing, finance, and operations.
For anyone interested in AI, this research highlights the importance of combining large language models with structured reasoning to solve complex problems.
So, as we wrap up, I have a couple of thought-provoking questions swirling in my mind:
How far can we push this concept of guided reasoning? Could we eventually create AI systems that can not only generate features but also explain why those features are important?
What are the ethical implications of automating feature engineering? Could it lead to the discovery of features that perpetuate biases or discriminate against certain groups?
That's all for today's dive into the PaperLedge. Keep learning, keep questioning, and I'll catch you on the next episode!Credit to Paper authors: Sungwon Han, Sungkyu Park, Seungeon Lee

Hey PaperLedge crew, Ernis here, ready to dive into some fascinating research! Today, we're tackling a paper that's all about using the power of AI to crack one of the toughest nuts in medicine: diagnosing rare diseases.
Now, you might be thinking, "Rare diseases? That doesn't affect me." But hold on! Collectively, these conditions impact over 300 million people worldwide. The problem is, each individual disease is, well, rare, and they can show up in all sorts of different ways. This makes it incredibly difficult for doctors to pinpoint what's going on.
Think of it like trying to find a specific grain of sand on a massive beach, and each grain looks slightly different. It's a needle-in-a-haystack situation, and doctors often don't have the specialized knowledge to identify every single "needle."
That's where DeepRare comes in. It's a brand-new AI system designed to act like a super-smart diagnostic assistant, powered by a large language model, kind of like a souped-up version of those chatbots you might have used.
So, how does DeepRare work its magic?

First, it takes in all sorts of clinical information – symptoms, test results, medical history – basically anything a doctor would use to make a diagnosis.


Then, instead of just spitting out an answer, it generates a list of possible rare diseases, ranked from most to least likely. But here's the really cool part: it also shows its work! It provides a clear chain of reasoning, explaining why it thinks each disease is a possibility and backing it up with medical evidence.

It’s like having a super-experienced doctor explain their thought process step-by-step, pointing to all the evidence that supports their conclusion. This transparency is crucial because it allows doctors to understand and trust the AI's recommendations.
The system is built with three core components:

A central host with a memory that doesn't quit.


Specialized agent servers, like mini-experts for different areas. They integrate tons of tools and up-to-date medical knowledge from the web.


"DeepRare comprises three key components: a central host with a long-term memory module; specialized agent servers responsible for domain-specific analytical tasks integrating over 40 specialized tools and web-scale, up-to-date medical knowledge sources, ensuring access to the most current clinical information."
Think of it as a team of specialists, each with their own area of expertise, working together to solve the diagnostic puzzle.
Now, for the numbers! The researchers tested DeepRare on a bunch of different datasets, covering almost 3,000 diseases. And the results were impressive.
In some tests, it achieved 100% accuracy for over 1,000 diseases! Even when compared to other AI systems and traditional diagnostic tools, DeepRare came out on top, significantly improving diagnostic accuracy.
Specifically, one of the tests was "Recall@1". This means if the AI lists the correct diagnosis as its top guess, it gets a point. DeepRare achieved an average Recall@1 score of 57.18% outperforming the next best method by a massive 23.79%!
To top it all off, when medical experts manually checked DeepRare's reasoning, they agreed with it over 95% of the time. This shows that the AI isn't just getting the right answers; it's also thinking like a doctor!
The team even created a website where doctors can use DeepRare: raredx.cn/doctor
Why does this matter?

For patients: Faster and more accurate diagnoses can lead to earlier treatment and better outcomes.


For doctors: DeepRare can serve as a valuable tool, helping them to consider rare diseases they might otherwise overlook.


For researchers: This work shows the incredible potential of AI to transform healthcare and improve the lives of millions.

This research could have a huge impact on the lives of individuals and families affected by rare diseases, potentially saving time, money, and, most importantly, improving health outcomes.
Here are a couple of questions that popped into my head while reading this paper:

How can we ensure that AI systems like DeepRare are used ethically and responsibly, especially when dealing with sensitive patient information?


How can we make these advanced technologies more accessible to doctors and patients in resource-limited settings?

That's all for this episode! I hope you found this paper as interesting and inspiring as I did. Until next time, keep exploring, keep learning, and keep pushing the boundaries of what's possible!Credit to Paper authors: Weike Zhao, Chaoyi Wu, Yanjie Fan, Xiaoman Zhang, Pengcheng Qiu, Yuze Sun, Xiao Zhou, Yanfeng Wang, Ya Zhang, Yongguo Yu, Kun Sun, Weidi Xie

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool tech! Today, we're cracking open a fascinating paper about how AI is learning to write code, not just line-by-line, but with a whole new level of planning and refinement.
Now, you've probably heard of those AI models that predict the next word in a sentence, right? That's like writing a story one word at a time. But what if we could give the AI the whole story idea and let it fill in the blanks, refining it bit by bit? That's where this paper comes in, exploring something called diffusion large language models, or dLLMs, for coding.
Think of it like this: imagine you have a blurry photo of a cat. A diffusion model is like an AI that starts with pure noise and gradually denoises it, step-by-step, until a clear picture of the cat emerges. In this case, instead of a cat, we're talking about code!
The researchers trained a dLLM, which they've cleverly named DiffuCoder, on a massive amount of code – like, 130 billion pieces! They then used DiffuCoder as a testbed to understand how dLLMs actually think when generating code.
"Our work provides deeper insight into the machinery of dLLM generation and offers an effective, diffusion-native RL training framework."
What they found is pretty mind-blowing. Unlike traditional AI models that have to generate code in a strict, sequential order (like building a Lego tower one brick at a time), dLLMs can be more flexible. They can essentially decide how much to think ahead and how much to focus on the immediate next step.
They also discovered that tweaking the "temperature" of the model (think of it like adjusting the sensitivity of a camera) does something very interesting. It doesn’t just change the specific words (or code tokens) chosen, but also the order in which the code is generated. This creates a much richer and more diverse playground for the AI to learn and improve.
And that leads us to the next big thing: reinforcement learning, or RL. Imagine training a dog. You reward it for good behavior (like sitting) and discourage bad behavior (like chewing your shoes). Similarly, these researchers used RL to fine-tune DiffuCoder. But here's the kicker: they developed a new technique called coupled-GRPO to make the RL training process more efficient and effective.
The coupled-GRPO method is like giving the AI two slightly different versions of the coding problem at the same time, allowing it to learn from both and improve faster. The researchers found that this new technique significantly boosted DiffuCoder's performance on coding challenges.
So, why does all this matter? Well, for:
Developers: This research could lead to AI tools that can help you write code faster and more efficiently, handle complex problems with smarter planning, and even suggest creative solutions you might not have thought of.
AI Researchers: This paper provides valuable insights into the inner workings of dLLMs, paving the way for even more powerful and versatile AI models in the future.
Anyone interested in the future of work: It shows how AI is evolving beyond simple automation to become a true partner in creative and complex tasks.
This is a big step towards AI that can not only write code but also understand the bigger picture and adapt to different coding styles and challenges.
Now, this all raises some interesting questions, right?
Could dLLMs eventually surpass human programmers in certain tasks?
How can we ensure that these AI coding tools are used responsibly and ethically?
What are the implications for code security and reliability when relying on AI-generated code?
Food for thought, learning crew! You can check out their code and experiments on Github at https://github.com/apple/ml-diffucoder. Until next time, keep exploring!Credit to Paper authors: Shansan Gong, Ruixiang Zhang, Huangjie Zheng, Jiatao Gu, Navdeep Jaitly, Lingpeng Kong, Yizhe Zhang

Alright learning crew, welcome back to PaperLedge! Ernis here, ready to dive into some seriously fascinating stuff. Today, we're tackling a paper that asks: do AI chatbots think about being polite, or are they just blurting things out?
Think about it. Every day, we're walking a tightrope. We need to be honest, but we also don't want to hurt anyone's feelings. Like when your friend asks if you like their new haircut… and it's… well, let's just say it's bold. You're weighing the value of honesty versus the value of maintaining a good relationship. That's a value trade-off, and humans are experts at it.
This paper looks at whether large language models (LLMs) – the brains behind chatbots like ChatGPT – are also making these kinds of calculations. Are they considering not just what to say, but how to say it?
The researchers used something called a "cognitive model." Think of it like a special decoder ring for understanding how humans balance different goals when they speak. This model helps us understand what someone values in a conversation – things like being informative, being polite, and avoiding conflict.
They then used this decoder ring to analyze how LLMs respond in different situations. They wanted to see if the models were prioritizing being informative over being polite, or vice versa. It's like checking if the chatbot is a blunt friend who always tells you the truth, or a master diplomat who always finds a nice way to say things.
So, what did they find? The researchers discovered that current LLMs generally prioritize being informative over being polite. They're more likely to give you the straight facts, even if it might sting a little. This was especially true for models that are really good at reasoning, like solving math problems.
"Our results highlight patterns of higher informational utility than social utility in reasoning models..."
Imagine asking a chatbot for directions. It might tell you the fastest route, even if it involves a detour through a less-than-savory neighborhood. A human might suggest a slightly longer, safer route instead.
The paper also looked at how these priorities change as the models are being trained. They found that the basic model the AI starts with and the initial data it learns from has a big impact on how it balances these values later on. It seems that even early in training, LLMs develop habits that are hard to shake!
Why does this matter? Well, for starters, it helps us understand the inner workings of these complex AI systems. But more practically, it could help us build better chatbots. Chatbots that are not just informative, but also considerate and empathetic. Chatbots that can navigate those tricky social situations just like we do.
This research is relevant for:
AI developers: Helps them fine-tune training methods to create more balanced and human-like AI.
Businesses using chatbots: Provides insights into how to design chatbots that provide better customer service.
Anyone who interacts with AI: Gives us a better understanding of the limitations and biases of current AI systems.
Here are a couple of questions that popped into my head while reading this paper:
Could we train LLMs to be too polite? What would the downsides of that be? Would they become useless because they never provide real answers?
How can we ensure that AI models reflect the values of diverse cultures and communities, not just the values of the people who trained them?
This research really opens up a new avenue for understanding and shaping the behavior of AI. It's not just about making them smarter, it's about making them wiser.
That's all for this episode of PaperLedge. Until next time, keep learning and keep questioning!Credit to Paper authors: Sonia K. Murthy, Rosie Zhao, Jennifer Hu, Sham Kakade, Markus Wulfmeier, Peng Qian, Tomer Ullman

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool research that's all about AI, teamwork, and even a little bit of friendly competition!
Today, we're talking about a new study that's tackling a big question: Can AI be a good teammate when it comes to solving complex machine learning problems? We've seen AI do amazing things solo, like writing articles or even generating art, but what happens when you put it in a group and ask it to collaborate?
Think of it like this: imagine you're trying to build the ultimate LEGO castle. You could do it all yourself, following the instructions step-by-step. But wouldn't it be awesome if you could team up with other LEGO enthusiasts, share building tips, and maybe even discover new ways to connect the bricks? That's the idea behind this research.
The researchers noticed that most AI agents working on machine learning problems usually work alone. They don't really talk to each other or learn from the broader community of researchers. But human researchers always collaborate, sharing ideas and building on each other's work. So, the scientists asked: how can we get AI to play nice in the sandbox?
That's where MLE-Live comes in. MLE-Live is essentially a simulated world, like a video game, where AI agents can interact with a virtual community of other researchers. It's like a training ground for AI to learn how to collaborate effectively.
"MLE-Live is a live evaluation framework designed to assess an agent's ability to communicate with and leverage collective knowledge from a simulated Kaggle research community."
Now, the researchers didn't just create the playground; they also built a star player! They call it CoMind. CoMind is an AI agent specifically designed to excel at exchanging insights and developing new solutions within this community context. It's not just about solving the problem; it's about learning from others and contributing back to the group.
Think of CoMind as the AI equivalent of that super helpful person in your study group who always has a great idea and is willing to share their notes.
So, how well did CoMind perform? Drumroll, please... It achieved state-of-the-art performance on MLE-Live! But here's the real kicker: CoMind was also tested against real human competitors on Kaggle, a popular platform for machine learning competitions. And guess what? CoMind outperformed, on average, almost 80% of the human participants across four different competitions! That's pretty impressive.
This research matters because it shows that AI can be more than just a solo problem-solver. It has the potential to be a valuable collaborator, accelerating the pace of discovery in machine learning and other fields.
But it also brings up some interesting questions:
If AI can collaborate so effectively, how does this change the role of human researchers? Are we moving towards a future where humans and AI work together as equal partners?
Could this approach be used to solve other complex problems, like climate change or disease research, by fostering collaboration between AI and human experts?
The possibilities are pretty exciting, and it makes you wonder how AI will change the way we learn and innovate in the future.Credit to Paper authors: Sijie Li, Weiwei Sun, Shanda Li, Ameet Talwalkar, Yiming Yang

Hey PaperLedge learning crew, Ernis here, ready to dive into some fascinating research! Today, we're tackling a paper about how well artificial intelligence, specifically those super-smart Large Language Models – you know, like the ones powering chatbots and writing assistants – can understand what other people (or even other AI agents) are thinking.
Think of it like this: imagine you're playing a game of charades. You need to figure out what someone else is trying to act out, right? That requires putting yourself in their shoes and thinking about what clues they're giving you. That's essentially what this paper is about, but for AI.
The researchers noticed a problem: current tests that try to measure this "mind-reading" ability in AI – what scientists call Theory of Mind (ToM) – aren't very good. They're either too simple, give away the answers accidentally (that's the "data leakage" they mention), or the AI has already aced them so many times that they're no longer a challenge (that's the "saturation"). Plus, most tests aren't interactive – the AI just gives a one-time answer and that's it.
So, these researchers created a new game-based test called Decrypto. It's designed to be super clean and focused on just the Theory of Mind aspect, without throwing in a bunch of other confusing factors. They wanted a way to really isolate and measure how well an AI can understand another agent's intentions and beliefs.
"Decrypto addresses a crucial gap in current reasoning and ToM evaluations, and paves the path towards better artificial agents."
Now, here's where it gets interesting. They pitted some of the smartest LLMs against Decrypto, and guess what? They weren't as good as you might think! In fact, they even struggled compared to simpler AI models that just rely on basic word associations. Ouch!
To really put these AI minds to the test, the researchers even recreated classic experiments from cognitive science – the study of how our brains work – within the Decrypto framework. They focused on key Theory of Mind skills. The really surprising result? The newest, fanciest LLMs actually performed worse on these tasks than older models!
Think of it like this: you might expect the newest smartphone to be better at everything than an older model. But what if it turned out the older phone was better at making calls in areas with weak signals? That's kind of what's happening here. The newer AI models are amazing at some things, but they haven't necessarily mastered the art of understanding other minds.
So, why does this matter? Well, as AI becomes more integrated into our lives – from helping us manage our schedules to driving our cars – it's crucial that they can understand our intentions and anticipate our needs. An AI that can't grasp Theory of Mind might make decisions that are confusing, frustrating, or even dangerous.
For example, imagine an AI assistant that's supposed to book a flight for you. If it doesn't understand that you prefer morning flights, even if they're slightly more expensive, it might book an afternoon flight that messes up your whole schedule. Or, in a more serious scenario, think about self-driving cars needing to anticipate the actions of other drivers and pedestrians. Understanding their intentions is vital for safety.
This research shows that we still have a long way to go in developing AI that truly understands the human mind. But, by creating better benchmarks like Decrypto, we can start to identify the gaps and build AI that's not just smart, but also empathetic and insightful.
Here are a few questions that popped into my head while reading this paper:
If older AI models are sometimes better at Theory of Mind tasks, what specific changes in the architecture of newer models might be hindering this ability?
Could playing Decrypto itself be used as a training method to improve Theory of Mind skills in LLMs?
How might cultural differences impact an AI's ability to develop Theory of Mind, and how could Decrypto be adapted to account for these differences?
That's all for this episode, learning crew! Until next time, keep those neurons firing!Credit to Paper authors: Andrei Lupu, Timon Willi, Jakob Foerster

Hey PaperLedge learning crew, Ernis here! Get ready to have your minds blown because today we're diving into some seriously cool robotics research. We're talking about teaching robots to do stuff just by watching us humans once! It's like showing someone a magic trick one time and then they can instantly do it themselves. The paper is called... well, let's just call it "DemoDiffusion" for now. It's easier to say!
So, what's the big deal? Think about all the things you do without even thinking: making a sandwich, sorting laundry, watering plants. Now imagine trying to program a robot to do all that. It's a nightmare, right? Traditionally, you'd need tons of data or hours of robot training. But these researchers have found a clever shortcut.
Their secret sauce is two-fold. First, they realized that even a single human demonstration gives the robot a crucial starting point. Imagine you're showing someone how to throw a dart. Even if they don't hit the bullseye the first time, they at least know the basic motion: raise your arm, aim, release. DemoDiffusion uses a similar idea. It takes the human's hand movements from a single demo and roughly translates it into a path for the robot's arm – what they call the "end-effector trajectory." Think of it like a very rough draft of instructions.
"The hand motion in a human demonstration provides a useful prior for the robot's end-effector trajectory..."
But here's the catch: that rough draft probably won't work perfectly for the robot. Maybe the robot's arm is a bit shorter, or the table is a different height. That's where the second clever part comes in: a pre-trained "generalist diffusion policy." It's like having a robot brain already trained on a whole bunch of different actions. This brain can then tweak the initial rough draft to make it work in the real world. It ensures the robot's movements are both similar to the human demo and physically possible.
Think of it like this: you show a friend how to bake a cake using your oven. Their oven might be slightly different, so they use their baking knowledge to adjust the temperature or cooking time. DemoDiffusion does something similar!
So, how does this compare to other methods? Well, usually, you'd need tons of examples or have the robot learn through trial and error (reinforcement learning). But DemoDiffusion skips all that! It avoids needing paired human-robot data, which can be difficult and expensive to gather. The result? Robots that can adapt to new tasks and environments with very little human intervention.
No need for tons of training data! One demo is enough.
Adapts to different environments! No matter the table is higher or lower.
Saves time and effort! Skip the reinforcement learning.
The researchers tested DemoDiffusion in both simulated and real-world scenarios, and guess what? It worked! It outperformed the basic robot policy and even the rough draft trajectory. In some cases, it enabled the robot to succeed where the pre-trained policy completely failed. That's huge!
Why does this matter? Well, for starters, it could revolutionize manufacturing, logistics, and even healthcare. Imagine robots quickly learning new assembly tasks or assisting with surgery after just watching a human expert. But it also raises some interesting questions:
Could this technology lead to more personalized robots that learn our individual preferences and habits?
What are the ethical considerations of robots learning from potentially imperfect or biased human demonstrations?
Could this approach be extended to even more complex tasks requiring reasoning and planning beyond simple manipulation?
This research is a significant step towards more adaptable and intelligent robots that can truly work alongside us in the real world. I'm super excited to see where this goes! What do you think, PaperLedge crew? Let me know your thoughts in the comments! And don't forget to check out the project page (https://demodiffusion.github.io/) for more details. Until next time, keep learning!Credit to Paper authors: Sungjae Park, Homanga Bharadhwaj, Shubham Tulsiani

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool robotics research! Today, we're talking about robots that can manipulate deformable objects. Think squishy, bendy, things – not rigid blocks or metal parts.
Why is that important? Well, imagine a robot doing surgery, handling delicate fabrics in a factory, or even folding your laundry! All those tasks require a robot to understand how to control something that changes shape. At the heart of this is something called shape servoing – basically, getting a bendy object into the shape you want.
Here's the catch: to do shape servoing, the robot needs to know what the goal shape is. But how do you tell it? Previous methods were, let's just say, a pain. They involved tons of manual tweaking and expert knowledge – not exactly user-friendly!
Now, a cool project called DefGoalNet came along and tried to solve this by learning the goal shape from watching a human do it a few times. Think of it like showing a robot how to fold a towel and letting it figure out the desired final shape.
However, DefGoalNet had a problem: it choked when there were multiple good ways to do something. Imagine folding that towel – you could fold it in thirds, in half, roll it up... all perfectly acceptable outcomes. DefGoalNet, being a deterministic model, would just try to average all those possibilities together, resulting in some weird, unusable, kinda Franken-towel goal shape!
"DefGoalNet collapses these possibilities into a single averaged solution, often resulting in an unusable goal."
That's where our featured paper comes in! These researchers developed DefFusionNet, and it's a game-changer. They used something called a diffusion probabilistic model to learn a distribution over all the possible goal shapes, instead of just trying to predict one single shape. Think of it like this: instead of giving the robot one specific picture of a folded towel, it gives the robot a range of possibilities, a cloud of good options.
This means DefFusionNet can generate diverse goal shapes, avoiding that averaging problem. The researchers showed it worked on simulated and real-world robots doing things like manufacturing tasks and even tasks inspired by surgery!
"Our work is the first generative model capable of producing a diverse, multi-modal set of deformable object goals for real-world robotic applications."
So, what does this mean for you? Well:

For roboticists: This is a huge leap forward in making robots more adaptable and capable of handling real-world, messy situations.


For manufacturers: Imagine robots that can handle delicate materials or assemble complex products with greater precision and flexibility.


For everyone else: This research brings us closer to robots that can assist us in everyday tasks, from healthcare to household chores.

This is truly exciting stuff! It feels like we're on the cusp of robots that can truly understand and interact with the world in a more nuanced way.
But it also leaves me with a few questions:

How far away are we from seeing this technology implemented in practical applications, like in factories or hospitals?


What are the ethical considerations of having robots that can learn and adapt in this way? Could they potentially learn unintended or even harmful behaviors?

What do you think, crew? Let's get the conversation started in the comments! Credit to Paper authors: Bao Thach, Siyeon Kim, Britton Jordan, Mohanraj Shanthi, Tanner Watts, Shing-Hei Ho, James M. Ferguson, Tucker Hermans, Alan Kuntz