Hey PaperLedge crew, Ernis here, ready to dive into some cutting-edge research! Today, we're talking about how robots – or, more accurately, intelligent agents – can work together to keep tabs on things that are constantly on the move. Think of it like this: imagine you’re trying to track a group of endangered animals in a vast forest, or coordinating rescue efforts after a hurricane. It's a tough job, right?
Well, that's exactly the problem this paper tackles. Researchers have developed a system called COMPASS – and no, it doesn't involve literal compasses (although the name is fitting!). It's a multi-agent reinforcement learning framework, which, in plain English, means they've created a way for multiple AI agents to learn how to best monitor moving targets together, even when they don't have a complete picture of what's going on.
Now, how does it work? They've essentially created a map of the environment, represented as a graph, showing different locations and how they're connected. This allows the agents to understand the layout and plan their routes effectively. It's like knowing the roads and shortcuts in a city, which helps you get around faster and more efficiently. The coolest part is that each agent makes its own decisions, in a decentralized manner, but they all share information and learn from each other using a clever spatio-temporal attention network.
But here's the real kicker: these agents don't just blindly follow the targets. They also try to predict where the targets are going to be! To do this, they use something called Gaussian Processes (GPs). Think of GPs as a sophisticated forecasting tool that allows the agents to update their beliefs about the target’s movements based on past observations. It's like a weather forecast that gets more accurate as you get closer to the event.
"The system is designed to reduce uncertainty, maintain good target coverage, and ensure efficient coordination."
The researchers trained COMPASS using a clever reward system that encourages the agents to reduce uncertainty and cover all the targets effectively. They tested it in various scenarios and found that it consistently outperformed other methods. This means COMPASS is better at keeping track of moving targets, even when things get unpredictable.
So, why does this matter? Well, the applications are huge! Imagine:
Better disaster response, with drones autonomously tracking survivors and assessing damage.
More effective environmental monitoring, with robots tracking pollution levels or animal migration patterns.
Improved security systems, with robots patrolling and monitoring critical infrastructure.
This research could really revolutionize how we use robots in dynamic and uncertain environments. It’s about creating intelligent systems that can adapt, learn, and work together to solve real-world problems.
But it also makes you think... What are the ethical considerations of deploying such autonomous monitoring systems? And how do we ensure that these systems are used responsibly and don't infringe on people's privacy? How robust is this system to being "tricked" if the targets behave in unexpected ways to avoid being tracked?
Food for thought, right? Let me know what you think in the comments below!Credit to Paper authors: Xingjian Zhang, Yizhuo Wang, Guillaume Sartoretti

Hey PaperLedge learning crew, Ernis here! Get ready to dive into some seriously cool science that could change how we power our world. Today, we're unpacking a fascinating paper about using AI, specifically those super-smart Large Language Models or LLMs, to discover new and better battery materials.
Now, you've probably heard of LLMs like ChatGPT. They're great at writing, translating, and even answering trivia. But can they invent? This research says: absolutely! The paper focuses on using LLMs to find better materials for lithium-ion batteries – the kind that power our phones, laptops, and electric cars.
The key idea here is something called "Chain-of-Thought" or CoT reasoning. Think of it like this: imagine you're trying to solve a puzzle. Instead of just guessing randomly, you break it down into smaller steps and logically work your way to the solution. CoT allows LLMs to do something similar: they break down complex problems into smaller, more manageable steps, leading to better, more creative solutions.
But here's the catch: LLMs are only as good as the information they have. That's where domain knowledge comes in. Imagine trying to bake a cake without knowing anything about ingredients or baking techniques. You'd probably end up with a disaster! Similarly, to design better batteries, the LLM needs to know about chemistry, materials science, and the specific challenges of battery technology.
That's why the researchers created something called ChatBattery. Think of ChatBattery as a super-smart research assistant that guides the LLM with specialized knowledge about batteries. It’s like having a world-class chemist whispering in the LLM's ear, pointing it in the right direction.
So, what did ChatBattery actually do? Well, it helped the LLM discover three new lithium-ion battery cathode materials that are significantly better than the current standard, NMC811. Specifically, these new materials have higher practical capacity improvements of 28.8%, 25.2%, and 18.5%. That's a HUGE leap!
"This complete AI-driven cycle-from design to synthesis to characterization-demonstrates the transformative potential of AI-driven reasoning in revolutionizing materials discovery."
But it's not just about finding these three specific materials. The real breakthrough is demonstrating that LLMs, guided by domain knowledge, can drive the entire materials discovery process from start to finish. That means designing the materials on a computer, synthesizing them in the lab, and then testing their performance. It's a closed-loop system where the AI learns from its successes and failures and gets better over time.
Why does this matter? Well, better batteries mean longer-lasting phones, more affordable electric cars, and more efficient energy storage for renewable sources like solar and wind. It could literally help us build a more sustainable future!

Here are some things that popped into my head while reading this:
Could this approach be used to discover new materials for other applications, like solar panels, superconductors, or even new types of plastics?
How do we ensure that these AI-driven discoveries are safe and environmentally friendly? We don’t want to create a new miracle material that ends up causing unforeseen problems down the road.
What kind of jobs will this technology create and eliminate in the materials science field? Will human scientists become more like "AI wranglers," guiding and interpreting the results of these powerful tools?

This research opens up a whole new world of possibilities for AI-driven scientific discovery. I'm excited to see where it leads! What do you all think? Let me know in the comments!Credit to Paper authors: Shengchao Liu, Hannan Xu, Yan Ai, Huanxin Li, Yoshua Bengio, Harry Guo

Hey PaperLedge learning crew, Ernis here, ready to dive into some seriously cool AI research! Today, we're tackling a paper about making large language models, or LLMs, even smarter and more efficient at problem-solving. Think of LLMs like really advanced parrots – they can mimic human language based on what they've been trained on.
But, just like a parrot with a limited vocabulary, these models have a major constraint: their context window. It's like their short-term memory; they can only consider so much information at once. This limits their ability to handle complex tasks that require long chains of reasoning.
Now, imagine trying to solve a really complicated puzzle, like figuring out who stole the cookies from the cookie jar. You need to remember all the clues, the suspects, and their alibis. If your memory is limited, you're going to struggle, right? That's the problem these researchers are trying to solve for LLMs.
So, what's their solution? They've created something called the Thread Inference Model (TIM), along with a runtime environment called TIMRUN. Think of TIM as a special kind of LLM that's trained to break down big problems into smaller, more manageable sub-problems, kind of like how a detective investigates a case.
And TIMRUN? Well, that's the detective's office, the place where all the investigation happens. It allows TIM to maintain a virtually unlimited working memory and use tools to gather more information.
"Together, TIM hosted on TIMRUN supports virtually unlimited working memory and multi-hop tool calls within a single language model inference..."
The secret sauce is that TIM and TIMRUN work together to build what they call "reasoning trees." Instead of processing information in a straight line (like reading a book from beginning to end), they organize it like a family tree, with the main problem at the top and smaller sub-problems branching out below. This lets the model explore different avenues of thought and keep track of its progress.
Think of it like planning a road trip. Instead of just plotting a direct route, you might break it down into smaller legs: finding a good place to stop for lunch, figuring out where to stay overnight, and identifying interesting landmarks along the way. Each of these sub-problems can be solved independently, making the overall trip much easier to plan.
But here's the clever part: TIMRUN only keeps track of the most important information in its memory. It's like a detective only keeping the key pieces of evidence in their briefcase, discarding the irrelevant stuff. This saves space and allows the model to focus on what really matters.
The researchers tested their system on tasks that require long-horizon reasoning and multi-hop tool use. Imagine having to solve a complex math problem that requires you to look up formulas online and perform multiple calculations. Or imagine you have to research a topic, going from one website to another, piecing together information from different sources. TIM and TIMRUN can handle these kinds of tasks with surprising accuracy and efficiency.
So, why does this matter?
For researchers: This opens up new possibilities for building AI systems that can tackle more complex and realistic problems.
For developers: This could lead to more powerful and versatile AI tools that can be used in a wide range of applications.
For everyone else: This could ultimately lead to AI systems that are better at helping us solve problems, make decisions, and understand the world around us.

This research is a big step towards overcoming the limitations of current LLMs and building AI systems that are truly capable of complex reasoning. So, what does this mean for the future of AI? Will TIM and TIMRUN become the standard for long-horizon reasoning? And how will this technology impact our daily lives?
That's all for today's episode of PaperLedge. Keep learning, keep questioning, and I'll catch you next time!Credit to Paper authors: Hongyin Luo, Nathaniel Morgan, Tina Li, Derek Zhao, Ai Vy Ngo, Philip Schroeder, Lijie Yang, Assaf Ben-Kish, Jack O'Brien, James Glass

Hey PaperLedge crew, Ernis here, ready to dive into another fascinating study! This time, we're tackling something super relevant to our increasingly AI-driven world: how to make AI characters truly believable.
Think about it: we're seeing AI pop up everywhere, from customer service chatbots to even potentially interactive characters in games and stories. But how do we get these AI to really feel like, say, Sherlock Holmes or your favorite historical figure? That's the puzzle this paper tries to solve.
The core problem is this: simply telling an AI "act like X" often falls flat. It's like asking someone to impersonate a celebrity based only on their name. They might get a few surface-level details right, but they won't capture the essence of the character.
Traditionally, there are two main approaches. The first is just feeding the AI a bunch of information and hoping for the best. This is like giving someone a Wikipedia article about the celebrity and saying, "Now, be them!". It's rarely convincing. The second is "fine-tuning", which involves retraining the AI on a massive dataset of text written in the style of the character. This is like giving someone intensive acting lessons, but it's incredibly expensive and time-consuming, especially if you want to create lots of different characters.
So, what's the solution? Well, these researchers came up with a clever method called Test-Time-Matching (TTM). And the really cool thing is: it doesn't require any additional training. It's all done "on the fly," during the moment the AI is generating text. Think of it like this: instead of building a whole new actor from scratch, they're giving the existing AI actor a really detailed costume and script right before they go on stage.
Here's how it works:

Step 1: Deconstructing the Character. The AI breaks down what makes a character unique into three key ingredients:

Personality: Are they grumpy, cheerful, logical, impulsive?
Memory: What are their key experiences, relationships, and knowledge?
Linguistic Style: Do they use formal language, slang, or a particular accent?



Step 2: Controlled Generation. The AI then uses these ingredients in a structured way to generate text. It's like a chef carefully adding spices to a dish to achieve a specific flavor.


Step 3: Blending and Mixing. The system can then seamlessly mix and match these features. Imagine giving Sherlock Holmes the linguistic style of a pirate or swapping one character's memories with another's!


The researchers found that TTM creates more believable and consistent character dialogues than the other approaches. They even had humans rate the AI-generated text, and TTM consistently scored high marks.
Why does this matter? Well, for gamers, this could mean more immersive and engaging characters in video games. For educators, it could mean creating interactive learning experiences with historical figures. And for writers, it could mean a powerful tool for brainstorming and developing new characters.
This is a huge step forward in making AI characters more than just lines of code. It's about giving them depth, personality, and a voice that truly resonates.
So, here are a couple of questions to ponder:
Could this technology eventually lead to AI companions that feel genuinely real? What are the ethical implications of that?
If AI can so accurately mimic human personalities and memories, how do we ensure that these systems are not used for malicious purposes, like creating convincing fake identities?
That's all for this episode, crew! Let me know your thoughts, and I'll catch you on the next PaperLedge!Credit to Paper authors: Xiaoyu Zhan, Xinyu Fu, Hao Sun, Yuanqi Li, Jie Guo, Yanwen Guo

Hey Learning Crew, Ernis here, ready to dive into some seriously cool tech shaping the future of finance! Today, we're unpacking a fascinating paper about a new breed of AI – specifically, Large Language Models, or LLMs – that are being designed to be super smart and reliable when it comes to handling your money, and big businesses' finances too.
Now, you might have heard about LLMs like ChatGPT. They’re great at generating text, answering questions, and even writing poems! But when it comes to something as crucial as finance, we need more than just clever wordplay. We need rock-solid reasoning, trustworthiness, and the ability to adapt to the unique challenges of the financial world.
That’s where the “Agentar-Fin-R1” series comes in. Think of it as a souped-up LLM specifically trained for finance. The researchers took a powerful existing LLM (Qwen3) and gave it a financial brain boost – creating two versions, one with 8 billion parameters (think of parameters as the size of the AI's knowledge base) and another with a whopping 32 billion!
But how did they make it so good? Well, they didn’t just throw a bunch of random financial data at it. They used a structured approach, kind of like giving it a well-organized textbook instead of a pile of messy notes. They also implemented what they call a "multi-layered trustworthiness assurance framework". Imagine it like a fortress guarding against bad advice or biased decisions. This framework included:
Trustworthy Knowledge: Feeding the AI high-quality, reliable financial information.
Multi-Agent Data Synthesis: Creating realistic scenarios using multiple AI "agents" to simulate real-world financial interactions. This is like practicing a play with different actors to see how everyone interacts.
Rigorous Data Validation: Carefully checking the data to make sure it's accurate and unbiased – like having a team of fact-checkers for everything the AI learns.
They also used some clever techniques to make the training process more efficient. They used 'label-guided automated difficulty-aware optimization', this is a fancy way of saying they gave the model harder questions as it improved, making the learning process faster and more targeted.
So, how do we know if Agentar-Fin-R1 is actually any good? The researchers put it through a series of tests – financial "exams", if you will. They used existing benchmarks like FinEva, FinEval, and FinanceIQ, as well as general reasoning datasets like MATH-500 and GPQA. And it aced them!
But they didn’t stop there. They even created their own super-realistic test, called Finova, that focused on how well the AI could act as a financial agent in the real world and make sure it was following all the rules and regulations. Think of it like a virtual compliance officer, making sure everything is above board.
The results showed that Agentar-Fin-R1 wasn’t just good at answering textbook questions; it was also exceptionally good at reasoning and making sound financial decisions in complex, real-world scenarios. It seems to be a trustworthy tool for high-stakes financial tasks.
Why does this matter?
For individuals: Imagine having an AI assistant that can help you make smarter investment decisions, plan for retirement, or even negotiate a better loan.
For businesses: Think about AI that can automate financial reporting, detect fraud, and manage risk more effectively.
For the financial industry: This could lead to more efficient and accurate financial services, potentially lowering costs and increasing access to financial products for everyone.
This research is a step towards a future where AI can help us make better financial decisions and create a more stable and equitable financial system. It's early days, of course, but the potential is HUGE.
Questions for discussion:
Given the potential for bias in training data, how can we ensure that these financial AIs are truly fair and equitable in their recommendations?
As these AI systems become more sophisticated, how do we maintain transparency and accountability in their decision-making processes? What does the future of financial regulations look like when these AI systems are commonplace?
That's all for today, Learning Crew! Keep those questions coming!Credit to Paper authors: Yanjun Zheng, Xiyang Du, Longfei Liao, Xiaoke Zhao, Zhaowen Zhou, Bo Zhang, Jiawei Liu, Xiang Qi, Zhe Li, Zhiqiang Zhang, Wang Wei, Peng Zhang

Hey PaperLedge crew, Ernis here! Get ready to dive into some seriously cool research that tackles a problem plaguing AI – hallucinations! You know, when a language model confidently spouts something that's just plain wrong.
We're looking at a paper that’s basically trying to teach AI to be not just smart, but also honest about how sure it is of its answers. Think of it like this: imagine asking your friend for directions. You'd prefer someone who says "I'm pretty sure it's this way..." over someone who confidently points you off a cliff!
Now, the way AI usually learns to "reason" is through something called Reinforcement Learning (RL). It's like training a dog – give it a treat (reward) when it does something right. In the AI world, the "treat" is often a simple "yes, you got it right!" or "no, try again."
But here's the catch: this simple reward system doesn't penalize guessing. So, the AI might learn to just throw out answers until it gets lucky, even if it has no real clue. This leads to those confident but completely wrong answers – the hallucinations!
This paper introduces a new approach called RLCR (Reinforcement Learning with Calibration Rewards). The core idea is to give the AI a more nuanced reward. Instead of just saying "right" or "wrong," RLCR also considers how confident the AI is in its answer. It uses something called a Brier score, which is like a penalty for being overly confident when wrong, or not confident enough when right. In other words, it rewards the AI for being well-calibrated.
Think of it like a weather forecast. A well-calibrated forecast doesn't just predict rain; it says "there's an 80% chance of rain," and it's right about 80% of the time when it makes that prediction. RLCR aims to make AI forecasts just as reliable.
The researchers actually proved mathematically that this approach should work, which is pretty cool. But even better, they tested it out on a bunch of different datasets. The results were impressive! RLCR improved the AI's calibration – meaning it became much better at knowing when it was likely to be right or wrong – without sacrificing accuracy.
In fact, it even outperformed other methods that tried to fix the calibration problem after the AI was already trained. It's like fixing a wobbly table by building it right in the first place!
And get this: they found that you could actually use the AI's confidence level to improve its accuracy even further. By giving more weight to answers the AI was really confident about, they could filter out some of the noise and get even better results.
"While ordinary RL hurts calibration, RLCR improves it."
So, why does this matter? Well, imagine using AI in critical applications like medical diagnosis or financial forecasting. You wouldn't want an AI that's confidently wrong! RLCR helps us build more reliable AI systems that we can trust, even when dealing with complex problems.
For researchers: This provides a new direction for training reasoning models, emphasizing the importance of calibration.
For developers: This offers a practical technique for improving the reliability of AI applications.
For everyone: It brings us closer to a future where AI is a trustworthy partner, not just a source of potentially misleading information.
Here are a couple of things I'm wondering about:
How does the complexity of the task affect the benefits of RLCR? Does it work equally well on simple and really complex problems?
Could this approach be combined with other techniques to further improve both accuracy and calibration?
This paper is a big step forward in making AI more reliable and trustworthy. It shows that by explicitly optimizing for calibration, we can build reasoning models that are not only smart but also honest about their limitations.Credit to Paper authors: Mehul Damani, Isha Puri, Stewart Slocum, Idan Shenfeld, Leshem Choshen, Yoon Kim, Jacob Andreas

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool tech! Today, we're cracking open a paper that looks at how we can use AI – specifically those brainy Large Language Models, or LLMs – to make our digital circuits faster and more energy-efficient.
Now, you might be thinking, "Digital circuits? That sounds complicated!" And you're not wrong. Think of them as the tiny building blocks inside your phone, your computer, even your smart fridge. They're what make everything tick. But designing them to be super speedy and not drain your battery is a real challenge. It's like trying to build a super-efficient engine for a race car – every little tweak counts.
Traditionally, engineers have optimized these circuits by hand, tweaking the code that describes how they work. This code is called RTL, which stands for Register Transfer Level. Imagine it like LEGO instructions for building these circuits. The problem is, this manual tweaking takes ages and is prone to errors. It’s like trying to solve a Rubik's Cube blindfolded!
That's where LLMs come in. The idea is to feed these AI models the RTL code and ask them to find ways to make it better – faster, more efficient, the works! These LLMs, which are trained on massive amounts of data, could potentially spit out optimized code snippets automatically. Sounds amazing, right?
This paper asks a crucial question: Can LLMs really handle the complex timing logic in RTL code? See, it's not just about making the circuit work, it's about making it work on time. Timing is everything! Think of it like conducting an orchestra. If the different sections aren't playing in perfect sync, the whole piece falls apart.

To figure this out, the researchers created a new benchmark – a set of challenges specifically designed to test how well LLMs can optimize RTL code. They divided these challenges into different areas, like optimizing basic logic and handling complex timing issues.

Optimizing logic operations (making the basic building blocks more efficient)
Optimizing timing control flow (making sure signals arrive at the right time)
Optimizing clock domain crossings (dealing with different parts of the circuit running at different speeds)

They then used a clever technique called "metamorphic testing." The core idea is that if an optimization is actually good, it should work consistently, even when the code is slightly different but functionally the same. Imagine you have a recipe for a cake. If you double the ingredients, you should still end up with a cake, right? Metamorphic testing applies a similar logic to the circuit optimization.

So, what did they find? The results were mixed. On the one hand, LLMs were pretty good at optimizing basic logic, even outperforming traditional methods in some cases. That's a win!

“LLM-Based RTL optimization methods can effectively optimize logic operations and outperform existing compiler-based methods.”

However, when it came to complex timing logic – the stuff that really matters for high-performance circuits – LLMs didn't do so hot. They struggled, especially when it came to timing control and clock domain optimization. It seems LLMs, at least for now, have a hard time fully grasping the nuances of timing in RTL code.

“LLM-Based RTL optimization methods do not perform better than existing compiler-based methods on RTL code with complex timing logic, particularly in timing control flow optimization and clock domain optimization.”

Think of it like this: the LLM is great at understanding the individual notes in a musical score, but it struggles to understand the rhythm and tempo that bring the music to life.

So, why does this research matter?

For hardware engineers: It shows the potential and limitations of using AI to automate circuit optimization. It highlights where LLMs can help and where traditional methods are still needed.
For AI researchers: It points to the challenges LLMs face when dealing with complex timing relationships and suggests areas for future improvement. How can we train LLMs to better understand timing constraints?
For everyone: It demonstrates how AI is being explored to improve the technology that powers our world, potentially leading to faster, more energy-efficient devices.

Here are a couple of questions this paper raised for me:

How can we better train LLMs to understand the concept of time in code, not just in natural language? Could we use different training data or architectures?
Could we combine LLMs with traditional optimization techniques to get the best of both worlds – the AI's ability to quickly explore possibilities and the engineer's deep understanding of timing constraints?

That's the gist of it, learning crew. It's a fascinating glimpse into the future of circuit design and the role AI will play in shaping it. Until next time, keep those circuits humming!Credit to Paper authors: Zhihao Xu, Bixin Li, Lulu Wang

Hey PaperLedge crew, Ernis here, ready to dive into another fascinating piece of research! Today, we're unpacking a paper about making Large Language Models (LLMs) – think of them as super-smart chatbots – even smarter, especially when it comes to understanding language in all its glorious complexity.
Now, you might be thinking, "LLMs already seem pretty good at chatting, right?" And you'd be right! But this paper points out that most existing tests for these models only check if they get the final answer correct. It's like grading a student solely on whether they got the right answer on a math test, without looking at how they got there. Did they understand the concepts, or just guess?
This research introduces something called LingBench++. Think of it as a super-detailed language obstacle course for LLMs, inspired by the International Linguistics Olympiad – basically, the Olympics of language puzzles! LingBench++ isn't just about getting the answer; it's about showing your work.
Here's what makes LingBench++ special:
It focuses on complex linguistic tasks – things that require real understanding of grammar, meaning, and even cultural context.
It uses a wide range of languages, especially languages that aren't as widely studied or used online. This is crucial because most LLMs are trained mainly on English and a few other major languages. Think about it: if you only learn about cooking from French cuisine, you might miss out on incredible flavors and techniques from around the world!
It provides structured reasoning traces. This means it tracks how the LLM arrives at its answer, step by step. It's like having a recording of the LLM's thought process.
It includes stepwise evaluation, so researchers can see exactly where the LLM excels and where it struggles.
But the researchers didn't just create a new test. They also built a special team of LLMs, a multi-agent architecture, to tackle LingBench++. Imagine you have a group of experts working together on a problem: one knows a lot about grammar, another is great at finding information, and a third is good at testing different ideas. That's essentially what this multi-agent system does.
This system uses a few key strategies:
Grammatical knowledge retrieval: It can access and use information about grammar rules.
Tool-augmented reasoning: It can use external tools (like dictionaries or translation programs) to help solve the problems.
Deliberate hypothesis testing: It can try out different solutions and see which one works best.
The results? Well, the team of LLMs with access to external knowledge and the ability to reason step-by-step did much better than LLMs that just tried to answer the questions directly. This shows that giving LLMs more tools and a more structured way to think makes them both more accurate and easier to understand. It's like giving someone a map and a compass instead of just pointing them in a general direction!
"LingBench++ offers a comprehensive foundation for advancing linguistically grounded, culturally informed, and cognitively plausible reasoning in LLMs."
So, why does all this matter? Well, for a few reasons:
For language enthusiasts: This research helps us understand how well LLMs are really understanding language, especially when it comes to less common languages and cultural nuances.
For AI developers: This provides a better way to build and test LLMs, leading to more reliable and useful AI systems.
For everyone: As LLMs become more integrated into our lives (from chatbots to translation tools), it's important that they can understand and respond accurately to a diverse range of languages and cultures.
This research is a step towards creating LLMs that are not just smart, but also wise – able to understand the complexities of human language and culture.
Here are a few things that popped into my head while reading this paper that we can think about:
If we can create LLMs that truly understand a wider range of languages and cultures, how might this change the way we communicate with each other globally?
Could this type of approach be applied to other areas of AI, like improving how AI understands and responds to emotions?
That's all for this PaperLedge breakdown! Hope you found it insightful. Until next time, keep learning!Credit to Paper authors: Da-Chen Lian, Ri-Sheng Huang, Pin-Er Chen, Chunki Lim, You-Kuan Lin, Guan-Yu Tseng, Zi-Cheng Yang, Shu-Kai Hsieh