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

Hey learning crew, Ernis here, ready to dive into some seriously cool robotics research! Today, we're unpacking a paper about how robots can get really good at manipulating objects in the real world – think threading a needle, but robot-style.
Now, the existing approaches to teaching robots these skills have some pretty big limitations. Some methods rely heavily on data, but struggle with precision. Others, like imitation learning, need tons of demonstrations – imagine trying to teach a robot to flip a pancake by showing it thousands of videos! And reinforcement learning? Well, that can lead to robots that are only good at one specific pancake, in one specific pan, on one specific stove. Not very useful, right?
That's where ViTaL, short for VisuoTactile Local policy learning, comes in! The researchers behind this paper have come up with a clever two-phase approach. Think of it like this: imagine you're trying to find your keys on a cluttered table.

Phase 1: Find the Keys (Reaching). First, you use your vision to scan the scene and identify your keys. ViTaL uses a fancy vision-language model (VLM) – basically, a smart AI that understands both images and language – to locate the object of interest, even in a messy environment. It's like having a super-powered "find my keys" app built into the robot's brain!


Phase 2: Grab and Go (Local Interaction). Once the robot knows where the keys are, it switches to a different strategy for the actual grabbing part. This is where the "local" part of ViTaL comes in. Instead of trying to learn a whole new grabbing strategy for every single scenario, it uses a pre-trained, reusable skill specifically designed for close-up interaction. It's like having a highly specialized hand that knows exactly how to grip and manipulate objects, regardless of the surrounding clutter.

The magic of ViTaL is that it recognizes that while the scene might change drastically (different table, different clutter), the low-level interaction – the actual act of grabbing – remains pretty consistent. By training these local skills separately, the robot can learn them once and then apply them to a wide variety of situations. It's like learning to ride a bike; once you've got the balance and pedaling down, you can ride on different roads, even with a bit of traffic!
The results are impressive! ViTaL achieved around 90% success on contact-rich tasks in unseen environments, even with distractions. The researchers highlight three key ingredients for ViTaL's success:

Foundation Models: Using powerful segmentation models to understand what the robot is seeing makes the visual part super reliable.


Smarter Learning: A special kind of reinforcement learning called "residual RL" helps make the learned skills more adaptable.


Touch Matters: Tactile sensing – literally, giving the robot a sense of touch – significantly improves performance, especially for those delicate, contact-rich tasks.

They even did some experiments to prove that each of these pieces is important. And, get this, ViTaL works well with those high-level VLMs we talked about, creating a system that's both smart and capable.
"ViTaL integrates well with high-level VLMs, enabling robust, reusable low-level skills."
So, why does this matter to you, the learning crew? Well...

For the Robotics Enthusiast: ViTaL represents a significant step forward in creating robots that can truly interact with the world in a useful and reliable way. It's about moving beyond simple tasks and tackling real-world challenges.


For the AI Curious: This research highlights the power of combining different AI techniques – vision, language, and reinforcement learning – to create something greater than the sum of its parts. It's a fascinating example of how AI is evolving.


For Everyone: Imagine robots that can assist with complex tasks in manufacturing, healthcare, or even in your own home. ViTaL is paving the way for a future where robots are more capable and adaptable, making our lives easier and more efficient.

Now, a few things I'm pondering...

Could ViTaL be adapted to work with different types of sensors, like sound or smell, to further enhance its capabilities?


What are the ethical considerations of creating robots that are so adept at manipulating objects, and how can we ensure that this technology is used responsibly?


How far away are we from seeing ViTaL-like systems deployed in real-world applications, and what are the biggest hurdles to overcome?

Definitely some food for thought! You can find the original paper and videos demonstrating ViTaL's capabilities at vitalprecise.github.io. Until next time, keep learning, crew!Credit to Paper authors: Zifan Zhao, Siddhant Haldar, Jinda Cui, Lerrel Pinto, Raunaq Bhirangi

Hey PaperLedge learning crew, Ernis here, ready to dive into some fascinating research! Today, we're tackling a paper that helps us understand how well those amazing AI image generators, like the ones that create pictures from text, are really working.
Think of it like this: you're baking a cake, and the recipe says to bake it until it's "done." But how do you know when it's really done? Is it when the timer goes off, or when a toothpick comes out clean? The authors of this paper are trying to give us a better "toothpick test" for AI image generators, specifically diffusion models.
Diffusion models are a type of AI that learns to generate images by gradually adding noise to a real image until it becomes pure static, and then learning to reverse that process, going from noise back to a clear image. It's like watching a picture slowly dissolve into snow on a TV screen, and then figuring out how to rewind and sharpen it back up.
Now, here’s the problem: these models have a "loss" value, which is supposed to tell us how well they're learning. But unlike other AI models, the lowest possible loss value for diffusion models isn't zero. It's some mystery number! So, we don't know if a high loss means the model is bad, or just that it's reached its limit. It's like baking that cake and not knowing if the oven temperature is off, or if the recipe just isn't very good.
This paper tackles this head-on. The researchers came up with a clever way to estimate what that "ideal loss" value should be. They even figured out how to do it without needing a ton of computing power, which is awesome.
So, what did they find?

First, they can now accurately diagnose how well these models are training. This is huge! It means we can fine-tune the training process to get even better results.


Second, they figured out a better training schedule. Think of it as a new baking recipe that's guaranteed to give you a fluffier cake!


Third, they looked at something called "scaling laws." These laws describe how much better AI models get as you make them bigger. The researchers found that after subtracting their "ideal loss" value, these scaling laws become much clearer. It's like finally seeing the true potential of those giant AI models!

Why does this matter?

For AI researchers: This gives them a more accurate way to evaluate and improve diffusion models, which could lead to even more realistic and creative AI-generated images.


For artists and designers: Better AI image generators mean more powerful tools for creating art and design.


For everyone: It helps us understand the fundamental limits and potential of AI, which is important as AI becomes more and more integrated into our lives.

In short, this paper provides a crucial tool for understanding and improving diffusion models, opening the door to even more incredible AI-generated images.
Here are a couple of questions that popped into my head:

Could this "ideal loss" estimation technique be applied to other types of AI models besides diffusion models?


How will these improved training schedules impact the computational resources needed to train state-of-the-art diffusion models? Will they become more efficient?

Alright learning crew, that’s all for this paper! Let me know what you think, and keep on learning!Credit to Paper authors: Yixian Xu, Shengjie Luo, Liwei Wang, Di He, Chang Liu

Hey PaperLedge crew, Ernis here! Get ready to dive into some brain-tickling research that helps computers understand our questions when we're asking about databases. Think of it like this: you're asking a super-smart computer to find information, but instead of typing code, you're just using plain English. The magic behind understanding your request? It's called schema linking.
Now, imagine a librarian who knows every book and author in the library. Schema linking is like that librarian for databases. It helps the computer figure out which tables (like book categories) and columns (like author names) are relevant to your question. It's a crucial step in something called "Text-to-SQL," which is basically translating your everyday questions into the computer language (SQL) needed to pull the right info from the database.
So, what's the problem? Well, the current way these "librarians" are trained is a bit like rote memorization. They're really good at remembering the exact right answer, but not so great at figuring things out when the question is a little different or tricky. It's like they've memorized the location of every book instead of understanding how the library is organized. The paper highlights this as a rote-learning paradigm that "compromises reasoning ability."
"Current fine-tuning approaches...employ a rote-learning paradigm, excessively optimizing for ground truth schema linking outcomes while compromising reasoning ability."
The researchers found that it's hard to teach the computer to reason because it's difficult to find good examples for it to learn from. Imagine trying to teach someone chess by only showing them winning moves – they'd never learn strategy!
That's where this paper comes in! They've developed a new method called Schema-R1, which is all about teaching the computer to think instead of just memorize. The key is using reinforcement learning, which is like training a dog with rewards. The computer gets rewarded for making smart choices in linking up the question to the right database parts.
Here’s how it works in three steps:
First, they carefully create small groups of good examples that highlight the reasoning process. Think of it as teaching the computer the basic rules of the database library.
Next, they give the computer a head start with some basic memorization, so it's not starting from scratch. This is called supervised fine-tuning for cold-start initialization.
Finally, they use reinforcement learning, guided by some pre-defined rules, to help the computer learn how to make the best decisions on its own. This is where the computer starts to develop its own "database librarian" instincts.
The results? Pretty impressive! The researchers found that Schema-R1 significantly improved the computer's ability to correctly filter information, boosting accuracy by 10% compared to previous methods.
So, why does this matter? Well, imagine:
For developers, this means building more reliable and user-friendly applications that can access data more efficiently.
For businesses, it means being able to ask questions about their data in plain English and get accurate answers faster, leading to better decision-making.
And for everyone else, it means easier access to information and a more intuitive way to interact with complex databases.
This research is a step towards making technology more accessible and empowering us to get the information we need, without needing to be coding whizzes!
Now, thinking about this research, a couple of questions popped into my head:
How might this technology change the way we teach database management and SQL to new programmers? Could it make it easier to learn by focusing on the why instead of just the how?
What are the ethical implications of making data access so easy? Could it lead to misuse or privacy concerns if not implemented carefully?
Let me know what you think in the comments, PaperLedge crew! Until next time, keep those neurons firing!Credit to Paper authors: Wuzhenghong Wen, Su Pan, yuwei Sun

Hey PaperLedge crew, Ernis here, ready to dive into another fascinating piece of research! Today, we're tackling a paper that's all about making big calculations way, way faster. Imagine trying to solve a massive jigsaw puzzle with millions of pieces. That's kind of like what these researchers are dealing with, but instead of puzzle pieces, it's complex mathematical operations.
The core problem they're addressing is how to efficiently handle integral operations. Now, that might sound intimidating, but think of it like this: imagine you want to calculate the total area of a map with lots of irregular shapes. Integrals help you do that precisely, but with enormous datasets, the calculations can take forever!
So, what's their solution? They've developed a clever framework that automatically uncovers hidden patterns, or geometries, within the data. It's like finding secret shortcuts in that giant jigsaw puzzle. Instead of looking at each piece individually, they find groups of pieces that fit together easily. They do this using an iterative process, meaning they refine their approach step-by-step to find the best patterns.
Think of it like organizing your closet. You might start by grouping shirts and pants, but then you realize you can further group them by color, then by season. Each level of organization reveals a new layer of understanding. That's similar to how their system works, building a hierarchical partition tree that reveals organization at different scales.
Now, here's where it gets really cool. Using this discovered "geometry," they employ two powerful techniques:

First, the butterfly algorithm. Imagine a butterfly's wings, each side mirroring the other. This algorithm exploits the low-rank structure they found. Think of it as finding redundant information. Instead of storing everything, they only store the essential bits, drastically reducing the memory needed.


Second, adaptive best tilings. Remember those tile puzzles where you have to fit different shapes together? This is similar! They intelligently "tile" the data in both space and frequency domains using something called a Haar-Walsh wavelet packet tree. It's like finding the perfect arrangement of tiles to represent the data most efficiently.

The beauty of this approach is that it's data-driven. It doesn't rely on pre-existing knowledge about the data's structure. It figures it out on its own! This is super useful when dealing with complex datasets where the underlying patterns are irregular or completely unknown.
They tested their method on two challenging types of problems:
Matrices related to acoustic heterogeneous potential operators. Imagine simulating how sound travels through different materials, like air, water, and rock.
Families of orthogonal polynomials. These are special mathematical functions that pop up in many scientific fields.
And the results? They were able to compress the data, reducing storage complexity from something proportional to N-squared (O(N2)) down to something proportional to N log N (O(N log N)). That's a HUGE improvement! It's like going from needing a giant warehouse to store your files to being able to fit them on a USB drive. This allows for fast computation and scalable implementation.
"Unlike classical approaches that rely on prior knowledge of the underlying geometry, our method is fully data-driven..."
So, why does this matter? Well, for scientists and engineers, this means they can tackle simulations and calculations that were previously impossible due to computational limitations. Think faster weather forecasting, improved medical imaging, or more accurate simulations of material properties.
But even if you're not a scientist, this research impacts you. Faster and more efficient computation leads to advancements in all sorts of technologies we use every day, from the algorithms that power search engines to the AI that drives self-driving cars.
Here are a few questions that popped into my head while reading this:

Could this approach be applied to other types of data, like image or video processing, to improve compression and analysis?


What are the limitations of this method? Are there certain types of datasets where it doesn't perform as well?


How might this research influence the development of new machine learning algorithms?

Alright, that's the paper for today! I hope you found that as fascinating as I did. Until next time, keep exploring the PaperLedge, and stay curious!Credit to Paper authors: Pei-Chun Su, Ronald R. Coifman

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool research! Today, we're tackling a paper that's all about making AI better at seeing and understanding the world around it, not just reading about it.
So, you know how some AI can solve math problems or answer science questions by thinking step-by-step? That's called "chain-of-thought" reasoning. But most of these AI brains are stuck in a purely language-based world. Think of it like trying to describe a painting only using words – you're bound to miss a lot of the detail, right?
This paper says, "Enough of that!" It introduces a new kind of AI called VGR, which stands for something fancy, but think of it as "Visual Grounded Reasoner." The cool thing about VGR is that it's specifically designed to really see the important details in images before it starts thinking.
Imagine you're trying to find your keys in a messy room. Do you just scan the whole room at once? No! You probably focus on specific areas, like the table, the couch, maybe under a pile of clothes (we've all been there!). VGR does something similar. It first detects the relevant parts of the image – those areas that are most likely to help it answer the question.
Here's where it gets really neat. Instead of just vaguely "knowing" those areas are important, VGR actually "zooms in" and replays those specific image regions to itself. It's like taking a closer look at those areas where you think your keys might be. This helps VGR get a much more detailed understanding of what's going on in the picture.
To make VGR this good, the researchers created a massive training dataset called VGR-SFT. This dataset is like a schoolbook filled with examples of how to reason about images, combining both visual clues and language deduction. It teaches the AI to connect what it sees with what it knows.
Now, the researchers put VGR to the test using a LLaVA-NeXT-7B model as a baseline. This model is already pretty smart, but VGR blew it out of the water on tasks that require really detailed image understanding. For example, on a benchmark called ChartQA (which tests how well an AI can understand charts), VGR improved the score by almost 13 points! And the best part? It did it using only 30% of the image information compared to the baseline. Talk about efficiency!
Why does this matter?
For AI Researchers: This shows a promising new direction for building AI that can truly understand the world like we do, not just read about it.
For Educators: Imagine AI that can help students understand complex diagrams or analyze visual data in a much more intuitive way.
For Everyone: This could lead to better image search, more accurate medical diagnoses from X-rays, and even more helpful assistive technologies for people with visual impairments.

Here are a couple of questions that popped into my head:
Could this approach be used to help AI understand video as well as still images? Imagine AI that could understand the nuances of human interaction from video footage!
What are the potential ethical concerns of having AI that can so precisely analyze images? How do we ensure this technology is used responsibly?
What do you guys think? Let me know your thoughts in the comments below!Credit to Paper authors: Jiacong Wang, Zijiang Kang, Haochen Wang, Haiyong Jiang, Jiawen Li, Bohong Wu, Ya Wang, Jiao Ran, Xiao Liang, Chao Feng, Jun Xiao

Hey PaperLedge crew, Ernis here, ready to dive into something really mind-bending today! We're talking about the future of the internet, but not just cat videos and online shopping. Imagine an internet populated by millions, maybe billions, of AI agents – little software robots doing everything from managing your smart home to optimizing global supply chains. Sounds cool, right? But there's a catch...
This paper asks a crucial question: Can the current internet handle this AI agent invasion? Think of it like this: our existing internet infrastructure is like a cozy small town designed for a few thousand residents. Now, suddenly, a million people move in, all needing immediate services. The existing roads, water pipes, and electricity grids are going to be seriously strained.
These AI agents aren't like your average website. They’re not just sitting there waiting for you to click a button. They're autonomous, meaning they make their own decisions. They can initiate actions, remember past interactions (persistent state), create even more agents (spawn sub-agents), and even negotiate with each other. This creates a whole new set of demands on the internet.
The paper highlights a few critical bottlenecks:
Speed: Right now, updating website addresses (using the Domain Name System or DNS) can take 24-48 hours. AI agents need updates in milliseconds! That's like waiting two days for Google Maps to reroute you when you miss a turn – totally unacceptable.
Security: Imagine needing to revoke a security certificate (like a digital ID) for trillions of these agents instantly. Our current system just isn't built for that scale.
Addressing: The way we currently address devices on the internet (IPv4 and IPv6) simply isn't designed to handle the sheer number of AI agents we're talking about. It's like trying to fit all the world's population into a single apartment building.
So, what's the solution? The researchers looked at three main options:
Upgrading the existing system: Think of this as adding extra lanes to the highway and upgrading the power grid. It's easier and faster to implement, but might not be enough in the long run.
Switching to a completely new system: This is like building a brand-new city from scratch, designed specifically for the needs of these AI agents. It offers better performance but takes much longer to build and get everyone to move in.
A hybrid approach: This is a mix of both – upgrading some parts of the existing infrastructure while building new, specialized systems for critical applications.
"Drawing parallels to dialup-to-broadband transitions, we find that agent requirements constitute qualitative, and not incremental, changes."
The researchers argue that the changes needed for AI agents are qualitative, not just incremental. It's not just about making things a little faster; it's about fundamentally changing how the internet works. They conclude that a hybrid approach is most likely to emerge, with some centralized registries for critical agents and more decentralized systems for specific tasks.
So, why does this research matter? Well:
For developers: This is about understanding the limitations of current infrastructure and designing AI agents that can work within those constraints or help push for better solutions.
For policymakers: This is about preparing for the future and making informed decisions about infrastructure investments and regulations.
For everyone: This is about understanding the potential impact of AI on our lives and ensuring that the internet remains a reliable and secure platform for everyone.
Here are a few things that popped into my head while reading this paper:
If we move to a hybrid approach, how do we ensure interoperability between the old and new systems?
Who gets to decide which AI agents are "critical" and therefore get access to the centralized registries?
Could a completely new, purpose-built internet for AI agents eventually replace the current internet altogether?
Let me know your thoughts, learning crew! This is a brave new world, and we're all figuring it out together. Until next time!Credit to Paper authors: Ramesh Raskar, Pradyumna Chari, Jared James Grogan, Mahesh Lambe, Robert Lincourt, Raghu Bala, Abhishek Singh, Ayush Chopra, Rajesh Ranjan, Shailja Gupta, Dimitris Stripelis, Maria Gorskikh, Sichao Wang