text string | source string |
|---|---|
state traversal, sub- problem decomposition, trial-and-error, visited-set maintenance, and conditional backtracking. Sec- ond, many real-world tasks can be reduced to these abstract problems, and such applications are either already being, or are likely to be, automated by intelligent agents powered by RLLMs or other r... | https://arxiv.org/abs/2505.20296v1 |
one by one, keeping track of each occurrence of ‘h’. I’ll start from the beginning and check each character to see if it’s ‘h’. Let me write down each position and note if it’s a match. Starting from index 0: ‘t’– not ‘h’. Index 1: ‘a’– nope. Index 2: ‘i’– not ‘h’. Index 3: ‘g’– no. Index 4: ‘w’– not ‘h’. Index 5: ‘u’–... | https://arxiv.org/abs/2505.20296v1 |
A full case example for boundary violation. The reasoning model is Deepseek-R1-Distill-Llama-8B . 18 D.2 Procedure Omission ?Task: Sliding Window Maximum Problem description: Given an array of integers and a sliding window width k, compute the maximum value in each window as it moves from left to right. You should repo... | https://arxiv.org/abs/2505.20296v1 |
7. Elements are 94, 35, 31, 28, 17. Max is 94. Fifth window: index 4 to 8. 35, 31, 28, 17, 94. Max is 94. Wait, that’s interesting. So far, the maximum has been 94 in each window. Let’s see if that continues. Sixth window: 5 to 9. 31, 28, 17, 94, 13. Max is 94. Seventh window: 6 to 10. 28, 17, 94, 13, 86. Max is 94. Ei... | https://arxiv.org/abs/2505.20296v1 |
75 15. 75 16. 54 17. 29 18. 64 19. 77 20. 77 21. 77 22. 77 23. 91 24. 91 25. 91 Yes, that’s 25 elements. I think that’s correct. ♂lightbulbFinal Answer <answer> CHECK(0,5)==94; CHECK(1,6)==94; 20 CHECK(2,7)==94; CHECK(3,8)==94; CHECK(4,9)==94; CHECK(5,10)==94; CHECK(6,11)==94; CHECK(7,12)==94; CHECK(8,13)==94; CHECK(9,... | https://arxiv.org/abs/2505.20296v1 |
search trace, not just the answer. The trace needs to follow the example format, using the specific commands. Let me look at the example given. For input [1,3,1], the output traces the search path step by step, with CHECK and BACKTRACK commands, ending with END(). Each CHECK command continues until a complete permutati... | https://arxiv.org/abs/2505.20296v1 |
see. Let me try to simulate the search trace step by step. The sorted list is [1,1,1,1,1,1,1,1,2]. Let me denote the elements as positions 0 to 8. We start with an empty path. The search starts with path = []. First step: choose the first element (element 0, which is 1). But since there are multiple 1s, we have to cons... | https://arxiv.org/abs/2505.20296v1 |
permutation. The candidates are all elements, but we can only choose each number once, but duplicates must be handled. The first element can be any of the 1’s or the 2. But since there are 8 1’s and one 2, but when sorted, all 1’s come first. So, the first candidate is element 0 (1). We can choose it. But before procee... | https://arxiv.org/abs/2505.20296v1 |
we reach i=8 (the 2), we can choose it. Wait, so the first choice is element 0, then after backtracking, the next candidate is element 8 (the 2). So the first path would be [1], then [1,1], etc., but eventually when backtracking all the way, the second top-level choice is element 8 (the 2). Wait but the total permutati... | https://arxiv.org/abs/2505.20296v1 |
1 (element 0) or 2 (element 8). First path: choose 1 (element 0). So: CHECK([])==continue; Then, after choosing element 0 (1), path becomes [1], so: CHECK([1]) == continue. Now, moving to next level (depth 2), trying to choose the second element. The available elements are elements 1-8 (since 0 is used). Now, for the s... | https://arxiv.org/abs/2505.20296v1 |
8th element, then the 2 is added as the last element. So after 8 steps of adding 1’s, the path would be [1,1,1,1,1,1,1,1,2], which is a valid permutation. 25 Then, backtrack from there. But when backtracking, the algorithm would have to go back and try placing the 2 in earlier positions. For example, when backtracking ... | https://arxiv.org/abs/2505.20296v1 |
is placed at position 2 (the third element): To do that, the first two elements must be 1’s, then the third is the 2. So the path would be: Start with [1], then next element 1, then choose the 2 at the third position. But how does the algorithm choose the 2 here? Let me try to simulate this. Suppose after the first two... | https://arxiv.org/abs/2505.20296v1 |
giving [2,1,1,...1], which is done. But between these two, there are other permutations where the 2 is placed in between. Wait, but according to the algorithm’s backtracking, after the first done (2 at end), backtracking will go back step by step, allowing the 2 to be placed in earlier positions. For instance, after th... | https://arxiv.org/abs/2505.20296v1 |
For example, after the first done, backtracking: BACKTRACK([1,1,...1,2]); (the full path) BACKTRACK(...), continuing until back to the first element’s choice. Then choose the 2 first. 27 So the trace would have: CHECK([])==continue; CHECK([1])... continue until the end, then backtrack. Then, after backtracking all the ... | https://arxiv.org/abs/2505.20296v1 |
second position (i=8), which is different from previous (element 7 is 1). Wait, but to choose the 2 at the second position, the algorithm must reach that point. Let me try to outline the steps for placing the 2 in the second position: Path starts as [1] (first element is element 0). Now, second element can be any of th... | https://arxiv.org/abs/2505.20296v1 |
where the 2 is placed in earlier positions require backtracking further. Alternatively, perhaps the first path is the 2 at the end. Then, after backtracking to the penultimate step (the 8th element, which was a 1), the algorithm tries to choose the 2 there instead, leading to the 2 in the 8th position, then the last el... | https://arxiv.org/abs/2505.20296v1 |
pattern, where each permutation is built step by step and backtracked. Given the problem’s input has 9 elements, the trace would be very long, but the example with 3 elements had 14 lines (including END). For 9 elements, it would be much longer. Alternatively, perhaps the algorithm’s trace for the input [1,1,1,1,2,1,1,... | https://arxiv.org/abs/2505.20296v1 |
one 2. So after 8 1’s, the next element must be the 2. Wait, the path after 8 elements would be 8 1’s, then the 9th element is the 2. Thus: CHECK([1,1,1,1,1,1,1,1]) == continue; Then, the next step chooses the 2: CHECK([1,1,1,1,1,1,1,1,2]) == done; BACKTRACK([1,1,1,1,1,1,1,1,2]); BACKTRACK([1,1,1,1,1,1,1,1]); // Backtr... | https://arxiv.org/abs/2505.20296v1 |
steps? Wait no, in the example, the output has 3 done steps: Looking back at the example: Input [1,3,1] outputs 3 permutations: [1,1,3], [1,3,1], [3,1,1]. The trace shows three done entries: CHECK([1,1,3])==done; CHECK([1,3,1])==done; CHECK([3,1,1])==done; So for the current problem with 9 elements and 9 permutations, ... | https://arxiv.org/abs/2505.20296v1 |
e.g.,12from1and2). Output one expression that equals 24plus a exploration trace to explain the process of your trials to find the final solution. You should report the exploration trace (in this case, the whole trial-and-error history) using the following format: ATTEMPT(candidate_expression)==<computed_result>; You ca... | https://arxiv.org/abs/2505.20296v1 |
2)))==64; (not 24) ATTEMPT(12 - (13 - (8 * 2)))==23; (not 24) ATTEMPT(12 / (13 / (8 * 2)))==14.77...; (not 24) ATTEMPT(12 * (13 / (8 + 2)))==15.6; (not 24) Let’s try to use division more: ATTEMPT(12 / (2 / 8) + 13)==61; (not 24) ATTEMPT(12 / (2 / 8) - 13)==35; (not 24) ATTEMPT(13 / (2 / 8) + 12)==64; (not 24) ATTEMPT(1... | https://arxiv.org/abs/2505.20296v1 |
2 + 13 - 8 - 5)==24; (using 12, 2, 13, 8, 5 - incorrect) Let me think more deeply about this. We have 12, 13, 2, and 8. If we look at 24 = 12 * 2, that uses two of our numbers. We need to find a way to incorporate 13 and 8 such that they don’t change the value. One way would be to have (13 - 8) / (13 - 8) = 1, and then... | https://arxiv.org/abs/2505.20296v1 |
(12 * 13) + (2 * 8) = 156 + 16 = 172 (not 24) (12 * 13) - (2 * 8) = 156 - 16 = 140 (not 24) (12 / 13) + (2 / 8) = 0.923... + 0.25 = 1.173... (not 24) (12 / 13) - (2 / 8) = 0.923... - 0.25 = 0.673... (not 24) (12, 2) and (13, 8): (12 + 2) * (13 + 8) = 14 * 21 = 294 (not 24) (12 + 2) / (13 + 8) = 14 / 21 = 0.666... (not ... | https://arxiv.org/abs/2505.20296v1 |
yet another approach, focusing on 8: 8 * 3 = 24, but we don’t have 3 directly. But, what if 3 = 13 - 10, and 10 = 12 - 2? Then, 8 * (13 - (12 - 2)) = 8 * (13 - 12 + 2) = 8 * 3 = 24. ATTEMPT(8 * (13 - 12 + 2))==24; Great! We can verify this: 8 * (13 - 12 + 2) = 8 * (1 + 2) = 8 * 3 = 24. This uses all four numbers: 8, 13... | https://arxiv.org/abs/2505.20296v1 |
+ 2), simplifies to 24 and uses all four numbers correctly and without redundancy. Let’s reconsider the other approach I was trying: 24 = 8 * 3, and trying to derive 3 from 13, 12, and 2. We have 3 = 13 - 10, and 10 = 12 - 2, which gives us 3 = 13 - (12 - 2) = 13 - 12 + 2. So, 8 * (13 - 12 + 2) = 8 * 3 = 24, which chec... | https://arxiv.org/abs/2505.20296v1 |
Let’s try: ATTEMPT(12 + (13 * 8 / 2))==64; Not 24. Let’s try: ATTEMPT(12 - (13 - 8 * 2))==23; Not 24. Let’s try: ATTEMPT(12 - (13 - 8 - 2))==9; Not 24. Let’s try: ATTEMPT(12 - (13 - 8 / 2))==3; Not 24. Let’s try: ATTEMPT(12 - (13 - (8 / 2)))==3; Not 24. Let’s try: ATTEMPT(12 - (13 / (8 - 2)))==9; Not 24. Let’s try: ATT... | https://arxiv.org/abs/2505.20296v1 |
12 / 8 + 2)==21.5; Not 24. Let’s try: ATTEMPT(13 * 12 / 8 - 2)==17.5; Not 24. Let’s try: ATTEMPT(13 * 12 / 8 * 2)==39; Not 24. Let’s try: ATTEMPT(13 * 12 / 8 / 2)==9.75; Not 24. Let’s try: ATTEMPT(13 * 12 - 8 * 2)==140; Not 24. Let’s try: ATTEMPT(13 * 12 - 8 - 2)==146; Not 24. Let’s try: ATTEMPT(13 * 12 - 8 / 2)==152; ... | https://arxiv.org/abs/2505.20296v1 |
+ 12 * 8))==218; Not 24. Let’s try: ATTEMPT(2 * (13 - 12 / 8))==24.5; Not 24. Let’s try: ATTEMPT(2 * (13 - 12 * 8))==-186; Not 24. Let’s try: ATTEMPT(2 * (13 * 12 / 8))==39; Not 24. Let’s try: ATTEMPT(2 * (13 * 12 - 8))==304; Not 24. Let’s try: ATTEMPT(2 * (13 * 12 + 8))==320; Not 24. Let’s try: ATTEMPT(2 * (13 / 12 * ... | https://arxiv.org/abs/2505.20296v1 |
ATTEMPT(12 + 12)==24; But this doesn’t use 13 and 8, and uses 12 twice. Let’s check: ATTEMPT(12 + 13 - 8 + 2)==19; [Author’s note: Fourth trial for this expression] Not 24. Let’s try: ATTEMPT(12 + 13 + 8 - 2)==31; Not 24. Let’s try: ATTEMPT(12 * 2 == 24); This is 24, but doesn’t use 13 and 8. Let’s try a different appr... | https://arxiv.org/abs/2505.20296v1 |
* (12 / 2))==30; Not 24. Let’s try: ATTEMPT((13 - 8) * (12 + 2))==70; Not 24. Let’s try: ATTEMPT((13 - 8) * 12 / 2)==30; Not 24. Let’s try: ATTEMPT((13 - 8) * 12 * 2)==120; Not 24. Let’s try: ATTEMPT((13 - 8) * 12 + 2)==62; Not 24. Let’s try: ATTEMPT((13 - 8) * 12 - 2)==58; Not 24. Let’s try: ATTEMPT((13 - 8) / (12 - 8... | https://arxiv.org/abs/2505.20296v1 |
try: ATTEMPT(8 * 2 + 13 * 12 / 13)==24; This is 24! Let’s verify: 8 * 2 = 16, 13 * 12 / 13 = 12, 16 + 12 = 28. Wait, that’s not 24. Let me recalculate. ATTEMPT(8 * 2 + 13 * 12 / 13)==16 + 12 = 28; Not 24. Let’s try: ATTEMPT(8 * 2 + (13 - 12 - 1))==16 + 0 = 16; Not 24. Let’s try: ATTEMPT(8 * 2 + (13 - 12) + (13 - 12)))=... | https://arxiv.org/abs/2505.20296v1 |
ATTEMPT(8 * (13 - 12 + 2))==8 * 3 = 24; I believe this is the final and correct solution. Actually let me check once more by testing the solution with a different parsing: 8 * (13 - 12 + 2) Let’s evaluate step by step: 13 - 12 = 1 1 + 2 = 3 8 * 3 = 24 Yes, this evaluates to 24, and we’ve used all four numbers (8, 13, 1... | https://arxiv.org/abs/2505.20296v1 |
history) using the following format: ATTEMPT(candidate_expression)==<computed_result>; You cannot write code or use any external tools. You should only solve the search problem and format the search trace in natural language. You can think as long as you want, but you have to conclude your search trace and final answer... | https://arxiv.org/abs/2505.20296v1 |
see if I can get 4 and 6. 8 divided by 2 is 4. Then 13 - 12 =1. Not helpful. Or 12 - (13 - something). Hmm. Wait, maybe (12 - (13 - 8)) *2. Let’s compute that: 13-8=5, 12-5=7, 7*2=14. Not 24. Alternatively, (13 - 2) * (8 -12). But 13-2=11, 8-12=-4, so 11*-4= -44. No. Hmm, maybe using division. Let’s think of fractions.... | https://arxiv.org/abs/2505.20296v1 |
using 8,2,13,12. So the total is 4, but I need 24. So that’s not it. Hmm, maybe (12 * 2) * (8 /13). That’s 24*(8/13) ≈14.3. Not 24. Wait, maybe (13 - 8) * (12 - 2). 5 *10=50. No. Alternatively, (12 + 8) * (13 - 2)/something. 20 *11=220. 220 divided by something to get 24? 220/24≈9.166. Not possible. Hmm, maybe trying t... | https://arxiv.org/abs/2505.20296v1 |
(2* something). Wait, 13-8=5, 12*5=60. 60 - (2* something)=24 →2* something=36 →something=18. Not possible. Alternatively, ( (12 + 13) * (8 -2) ). 25*6=150. Hmm, this is tough. Let me think of another angle. Since 24 is a multiple of 12, maybe 12 multiplied by something. Let’s see, 12*(something)=24 →something=2. So ho... | https://arxiv.org/abs/2505.20296v1 |
trying to use 13 and8 first. 13-8=5. Then 5 * (something with 12 and2). 5* (something)=24 →4.8. 12 and2 can make 4.8? 12/2.5=4.8, but how to get 2.5 from 12 and2? Not sure. Alternatively, 13+8=21. 21 + (something with 12 and2). 21+3=24. So 12 and2 need to make 3. 12/ (something)=3 →something=4. 2+2=4 but can’t repeat. ... | https://arxiv.org/abs/2505.20296v1 |
maybe I missed something. Let me try to think of the example given. In the example, they had 4,8,8,6 and the solution was 4*6*(8/8). So using division to get 1, then multiplying. Maybe in this case, can I do something similar? Let’s see. Suppose I do 12 * (something) * (something else). Let’s see, 12 * 2 =24. Then I ne... | https://arxiv.org/abs/2505.20296v1 |
8 divided by 2 is 4. Then 12 and13 left. 12+13=25, which is close to 24. But 25-1=24. But how to get 1 from 4? 4-3=1, but no. Alternatively, 12 * (something) =24. So something=2. To get 2 from 13,8,2. Wait, 2 is already there. So maybe 13 - (8 +2)=3. Not 2. Alternatively, (13 -8)/something=2. (5)/something=2 →something... | https://arxiv.org/abs/2505.20296v1 |
what? The remaining number is 12? No, already used. Hmm. Wait, maybe ( ( (12 * ( (13 - (8/2)) )) / (something) ). 8/2=4, 13-4=9. 12*9=108. 108 divided by 4.5=24. 52 But 4.5 isn’t a number here. Hmm. Wait, maybe ( ( (12 * 2) * ( (13 -8) ) ) / (something) ). 24*5=120. 120 divided by 5=24. But the 5 is from 13-8, which is... | https://arxiv.org/abs/2505.20296v1 |
But that gives 24*(8/13) which is less than 24. Alternatively, (12*2) + (13-8)=24+5=29. Not 24. Alternatively, (12*2) - (13-8)=24-5=19. Hmm. Alternatively, (12*2) divided by (something with 13 and8). Let’s see, 24 divided by (something)=24 → something=1. So (13-8)/something=1. 5/something=1 →something=5. So (13-8)=5. S... | https://arxiv.org/abs/2505.20296v1 |
by 4.5=24. But 4.5 isn’t a number. Hmm. Wait, maybe I’m missing a simple combination. Let me try to think of all possible groupings where division is used to get an exact result. For example, 8 divided by 2 is 4. Then 12 and13. If I have 4, then 12 and13. Maybe 12 + (13 -4)=21. Not 24. 54 Alternatively, 12 * (something... | https://arxiv.org/abs/2505.20296v1 |
CHECK(cluster_a,cluster_b)==d; ... MERGE(cluster_u,cluster_v)=={new_cluster,...}; END()=={cluster_x,cluster_y,d} where you should start each point in its own cluster, and repeatedly merge the two clusters whose closest pair of points are the nearest among all cluster pairs. The name of new cluster is the concatenation ... | https://arxiv.org/abs/2505.20296v1 |
first merge will be C and E, forming cluster {CE}. Now, after merging, the clusters are {A}, {B}, {CE}, {D}, {F}, {G}. Next, I need to find the next smallest distance among these clusters. The distances between the new cluster {CE} and others will be considered based on the minimum distance within {CE} to any point in ... | https://arxiv.org/abs/2505.20296v1 |
After merging {ABCE} and {F} into {ABCEF}, then merging {ABCEF} and {D} into {ABCEFD}. Now, the remaining clusters are {ABCEFD} and {G}. So the final clusters are {ABCEFD} and {G}, with the distance being the minimum between any point in {ABCEFD} and G. Let’s see, the minimum distance between {ABCEFD} and {G} is the mi... | https://arxiv.org/abs/2505.20296v1 |
between ABCEF and D is 9 (from A-D). So the final clusters are ABCEFD and G, and the distance is 5 (A-G). So the END() step should report these two clusters and the distance of 5. Now, I need to format the CHECK trace correctly, ensuring that the CHECK steps are in alphabetical order of cluster names, and the MERGE ste... | https://arxiv.org/abs/2505.20296v1 |
them alphabetically, “ABCE” starts with A, which comes before D. So the sorted order is ABCE, D ßso the new cluster is {ABCE D} but that’s not right. Wait, no, the new cluster’s name is the sorted concatenation of the two cluster names. Wait, the two clusters are {ABCE} and {D}. The names are “ABCE” and “D”. When you c... | https://arxiv.org/abs/2505.20296v1 |
after merging {ABCDE} and {G}, we have {ABCDEFG} and {F}, which are two clusters. So the process stops here. But wait, let me check the steps again. After merging {ABCE} and {D} into {ABCDE}, the clusters are {ABCDE}, {F}, {G}. Now, the next CHECK steps: Clusters in order: {ABCDE}, {F}, {G}. Compute distances: {ABCDE}-... | https://arxiv.org/abs/2505.20296v1 |
Alternatively, perhaps after merging {ABCE} and {D} into {ABCDE}, the next step is to find the distance between {ABCDE} and {F} which is 13, and between {ABCDE} and {G} which is 5. So the smallest is 5, leading to merging {ABCDE} and {G} into {ABCDEG}. Clusters now: {ABCDEG}, {F}. The distance between {ABCDEG} and {F} ... | https://arxiv.org/abs/2505.20296v1 |
final clusters are {ABCDEG} and {F}, with a distance of 13. Wait, but earlier I thought the distance was 5, but that was between ABCDE and G, which was 5, but after merging, the distance between ABCDEG and F is 13. So the correct final answer should be END()=={ABCDEG}, F,13. But I’m a bit confused because when merging ... | https://arxiv.org/abs/2505.20296v1 |
factor. Now, the remaining number is 88875. Next, I check if 2 is still a factor of 88875. 88875 is odd, so 2 isn’t a factor anymore. Moving on to the next prime number, which is 3. Adding the digits of 88875: 8+8+8+7+5 = 36. Since 36 is divisible by 3, 88875 is divisible by 3. Dividing 88875 by 3 gives me 29625. So, 3... | https://arxiv.org/abs/2505.20296v1 |
7, so 237 divided by 23 is 10.3, not an integer. So, 23 isn’t a factor. Next prime is 29. 29 times 8 is 232, and 237 minus 232 is 5, so 237 divided by 29 is 8.172, not an integer. So, 29 isn’t a factor. Next is 31. 31 times 7 is 217, and 237 minus 217 is 20, so 237 divided by 31 is 7.645, not an integer. So, 31 isn’t a... | https://arxiv.org/abs/2505.20296v1 |
5, 5, and 79. Wait, but 5 was divided three times, so that’s three 5s. So the prime factors are 2, 3, 53, and 79. Let me check if 3 is a factor again. After getting 3, I should check if 3 is a factor of 3. Yes, 3 divided by 3 is 1. So, 3 is another factor. So the factors are 2, 3, 5, 5, 5, 3, and 79? Wait, no, because ... | https://arxiv.org/abs/2505.20296v1 |
/3=29625, but since 29625/3 isn’t integer, so only one 3. Then /5 three times, then 79, then 3. So, yes, that’s correct. So, the prime factors are 2, 3, 5, 5, 5, and 79. ♂lightbulbFinal Answer <answer> STATE(177750); ATTEMPT(177750,2)==True; STATE(88875); ATTEMPT(88875,2)==False; ATTEMPT(88875,3)==True; STATE(29625); A... | https://arxiv.org/abs/2505.20296v1 |
another 8. Wait, I have a 2. Maybe 8 divided by (something). Wait, 8 divided by (2* something). Not sure. Alternatively, 13 - (something) to get 12. Then multiply by 2. Wait, maybe 13 - (12/(8/2))? Let’s see. 8/2 is 4. 12/4=3. 13-3=10. 10*2=20. Not 24. Hmm. What if I try division. Like 24 can be 48 divided by 2. So may... | https://arxiv.org/abs/2505.20296v1 |
would work. Let me check which one I found first. The first one was (13 - (12-2)) *8. The second is 8*(13-12+2). Both are valid, but the first one uses parentheses around 12-2 and then subtracts from 13. The second adds 2 after subtracting 12 from 13. Both are correct. But the question says öutput one expression¨. So e... | https://arxiv.org/abs/2505.20296v1 |
DiSA: Diffusion Step Annealing in Autoregressive Image Generation Qinyu Zhao1, Jaskirat Singh1, Ming Xu1, Akshay Asthana2, Stephen Gould1, Liang Zheng1 1Australian National University 2Seeing Machines Ltd {qinyu.zhao,jaskirat.singh,mingda.xu,stephen.gould,liang.zheng}@anu.edu.au {akshay.asthana}@seeingmachines.com Abst... | https://arxiv.org/abs/2505.20297v1 |
of a dog. xAR (c)T steps Token groupOld tokens New tokens Sampled noise Diffusion or flow matching D F D (e)4.8× faster 1.6× fasterDiT-XL/2MAR xARFlowAR 2.5× fasterBaseline Ours ↑↑Figure 1: Overview . Architecture of four “autoregressive + diffusion” models included in this study: (a) MAR [ 12]; (b) FlowAR [ 24]; (c) x... | https://arxiv.org/abs/2505.20297v1 |
a well-established area in diffusion. Fast sam- pling processes have been proposed, such as DDIM [ 29], DPM-Solver [ 17], and DPM-Solver++ [ 18], to name a few. These methods are designed specifically for diffusion and can be used together with our approach. In comparison, less attention has been paid to accelerating d... | https://arxiv.org/abs/2505.20297v1 |
and image-to-text generation. This study focuses on its T2I ability. The backbone in Harmon takes the text prompt and generated tokens as input and produces a condition vector for the next token. A diffusion head, conditional on the vector, denoises sampled noise to the next token. 3.2 More Tokens Generated, Stronger C... | https://arxiv.org/abs/2505.20297v1 |
noisy, the model has to directly predict the xibased on zi. As shown in Figure 2, in the early stage of generation, the predicted tokens and the generated images are blurry and in low quality. But as more tokens have been generated, the MLP predictions become increasingly more accurate, suggesting that stronger conditi... | https://arxiv.org/abs/2505.20297v1 |
transition smoothly from Tearly to Tlatein the generation process. Specifically, they are defined as follows, Two-stage: T(k) =Tearly, k < K/ 2 Tlate,otherwise, (6) Linear: T(k) =Tearly + (Tlate−Tearly)×k/K, (7) Cosine: T(k) =Tlate+ (Tearly−Tlate)×1 2 cos(k Kπ) + 1 , (8) where Kis the total number of the autoregress... | https://arxiv.org/abs/2505.20297v1 |
265.5 (-16.2) - - - 2.3 × MAR-B + DiSA 208M 64 50→5 2.31 (+0.00) 282.3 (+0.6) 0.83 0.56 0.114 5.7× 32 25→5 2.35 (+0.04) 282.9 (+1.2) 0.83 0.56 0.057 11.3× MAR-L [12] 479M 256 100 1.78 296.0 0.81 0.60 1.102 1.0 × 64 50 1.86 (+0.08) 294.0 (-2.0) 0.80 0.61 0.250 4.4 × LazyMAR-L [39] 479M 64 100 1.93 (+0.15) 297.4 (+1.4) -... | https://arxiv.org/abs/2505.20297v1 |
condition. Our prediction results on Harmon in Figure 2 show that, a text prompt helps to determine the basic the structure of the image, leaving details for generation. 4 Experiments 4.1 Implementation Details, Datasets, and Metrics Experiments mainly includes four pretrained models: MAR [ 12], FlowAR [ 24], xAR [ 25]... | https://arxiv.org/abs/2505.20297v1 |
17.7 50 4.06 176.6 22.1 + DiSA 50→5 4.00 179.3 17.9 DPM-Solver 15 4.58 179.4 17.4 25 4.35 176.1 20.6 + DiSA 25→10 4.37 177.1 17.9 DPM-Solver++ 15 4.57 179.5 18.5 25 4.34 176.1 22.0 + DiSA 25→10 4.37 177.2 19.0Comparison with other acceleration methods on MAR. DiSA is faster than CSpD [ 37] and FAR [ 5], and is com- pet... | https://arxiv.org/abs/2505.20297v1 |
MAR-B and MAR-L, we evaluate different autoregressive and diffusion steps. FlowAR-L, xAR-B, and xAR-L are evaluated with different flow matching steps. Harmon-1.5B runs with different autoregressive and diffusion steps on the GenEval benchmark. As seen, under different settings, DiSA can significantly improve the infer... | https://arxiv.org/abs/2505.20297v1 |
33:6840–6851, 2020. 3 [10] Diederik P Kingma, Max Welling, et al. Auto-encoding variational bayes, 2013. 3 [11] Doyup Lee, Chiheon Kim, Saehoon Kim, Minsu Cho, and Wook-Shin Han. Autoregressive image generation using residual quantization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recogni... | https://arxiv.org/abs/2505.20297v1 |
Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. Advances in neural information processing systems , 29, 2016. 6, 7 [29] Jiaming Song, Chenlin Meng, and Stefano Ermon. Denoising diffusion implicit models. arXiv preprint arXiv:2010.02502 , 2020. 2, 6, 8 [30] Y... | https://arxiv.org/abs/2505.20297v1 |
arXiv:2505.20298v1 [cs.CL] 26 May 2025MangaVQA and MangaLMM: A Benchmark and Specialized Model for Multimodal Manga Understanding Jeonghun Baek∗Kazuki Egashira∗Shota Onohara∗Atsuyuki Miyai∗ Yuki Imajuku Hikaru Ikuta Kiyoharu Aizawa The University of Tokyo baek@hal.t.u-tokyo.ac.jp https://github.com/manga109/MangaLMM/ A... | https://arxiv.org/abs/2505.20298v1 |
MangaVQA , a novel benchmark designed to evaluate an LMM’s ability to accurately answer targeted, factual questions grounded in both visual and textual context. It consists of 526 high-quality, manually constructed question–answer pairs covering a diverse range of scenarios, enabling assessment of a model’s narrative u... | https://arxiv.org/abs/2505.20298v1 |
address page-level evaluation. However, humans typically perceive and interpret text at the page level, integrating visual and textual cues across the entire layout. To reflect this human reading process, we evaluate OCR performance on two-page spreads using MangaOCR. Existing studies have also largely overlooked the v... | https://arxiv.org/abs/2505.20298v1 |
comprehend the story. MangaOCR addresses this challenge by targeting two key categories of embedded text: dialogue and onomatopoeia. We construct the MangaOCR dataset by consolidating existing annotations from the Manga109 dataset and the manga onomatopoeia dataset [ 3]. It contains approximately 209K narrative text in... | https://arxiv.org/abs/2505.20298v1 |
(1) Exact Extraction, where the answer is directly extracted from the image; (2) Multimodal Understanding, where the answer requires comprehension of the story beyond simple extraction; and (3) Image Understanding, which can be answered without referring to the text. We illustrate examples along axes (b) type of manga ... | https://arxiv.org/abs/2505.20298v1 |
LLaV A [ 16], we generate five questions per image using both the image and its annotation from the OCR training setTOCR. Here we exclude < 0.1% of the images where the text annotation is not included or GPT-4o refused to respond (e.g., due to violent content). Although we requested GPT-4o to generate five questions pe... | https://arxiv.org/abs/2505.20298v1 |
two open-source LMMs, Phi-4-multimodal-instruct [1] and Qwen2.5-VL-7B-Instruct [4]. 6.1 Main Results Table 2 compares LMMs for both MangaOCR and MangaVQA tasks. Overall, MangaLMM can handle both tasks effectively: it achieves over 70% OCR score and outperforms GPT-4o in VQA score (5.76 vs. 6.57). Analysis of Low Perfor... | https://arxiv.org/abs/2505.20298v1 |
marginally improve VQA performance. 6.2 Effect of Model and Dataset Size Table 4 shows the performance of Qwen2.5-VL models of different sizes (3B and 7B) under various finetuning settings. Similar to the 7B model, the 3B model shows a slight drop in MangaOCR performance when finetuned on both TOCR andTVQA, while its M... | https://arxiv.org/abs/2505.20298v1 |
the OCR annotation as part of the prompt. Here, we ablate the impact of this by comparing the effect of VQAs made with and without text annotation. As shown in Table 7, the performance of a model on VQA data generated without OCR information (5.44) does not outperform GPT-4o’s own score (5.76). In contrast, OCR-guided ... | https://arxiv.org/abs/2505.20298v1 |
complexity, while MangaLMM performs well across both tasks. By releasing open benchmarks, synthetic data, and a strong open-source baseline, we aim to advance research in multimodal manga understanding. Limitation. One limitation of our model is its slow inference speed for OCR. LMMs are much slower than dedicated OCR ... | https://arxiv.org/abs/2505.20298v1 |
Farid Ammar-Boudjelal, Karell Bertet, Alain Bouju, Jean-Christophe Burie, Georges Louis, Jean-Marc Ogier, and Arnaud Revel. ebdtheque: a representative database of comics. In International Conference on Document Analysis and Recognition (ICDAR) , 2013. [11] Mingxin Huang, Jiaxin Zhang, Dezhi Peng, Hao Lu, Can Huang, Yu... | https://arxiv.org/abs/2505.20298v1 |
et al. Icdar 2019 competition on large-scale street view text with partial labeling-rrc-lsvt. In International Conference on Document Analysis and Recognition (ICDAR) , 2019. [30] Emanuele Vivoli, Marco Bertini, and Dimosthenis Karatzas. Comix: A comprehensive bench- mark for multi-task comic understanding. In NeurIPS ... | https://arxiv.org/abs/2505.20298v1 |
for content understanding, as the interpretation of the same text can vary significantly depending on its location. A proper evaluation of OCR in the manga domain allows us to better understand how well current LMMs can recognize text within manga. As described in the results section (§6.1), models such as GPT-4o exhib... | https://arxiv.org/abs/2505.20298v1 |
manga titled AppareKappore. Generated VQAsQ1) こ䛾物語䛾登場人物たち䛿、何に向けて準備をしていますか？What are the characters in this story preparing for?A) 明日䛾試験に向けて準備しています。They are preparing for tomorrow's exam. Q3) 主人公が外国語を勉強する䛾に納得できない理由䛿何ですか？Why does the main character feel it's unreasonable to study a foreign language?A) 日本人である自分が外国語を学ぶ必要がない... | https://arxiv.org/abs/2505.20298v1 |
an AI that answers questions about Japanese manga. Please answer the given question based on the provided image.)” together with the input image and a question. The ground-truth answer is given only during training. For MangaVQA evaluation, the prompt in Table C is used for LLM-as-a-judge. 15 Table B: OCR inference pro... | https://arxiv.org/abs/2505.20298v1 |
© Riku Kurita © Sakumi Hanada ScoreScore10324102Exact ExtractionMultimodal UnderstandingImage UnderstandingFigure B: Category-wise analysis on MangaVQA. The regions in the image relevant to the question or models’ answer are highlighted with boxes in corresponding colors. D Additional Results We provide additional anal... | https://arxiv.org/abs/2505.20298v1 |
rarely conducted in-depth qualitative analysis of GPT-4o’s OCR results, it is difficult to assess the model’s actual performance on manga datasets. We address this gap by providing a detailed qualitative analysis of GPT-4o’s MangaOCR outputs. Figure D shows GPT-4o’s results on MangaOCR. These examples demonstrate the l... | https://arxiv.org/abs/2505.20298v1 |
arXiv:2505.20309v1 [cs.CL] 22 May 2025Guiding Giants: Lightweight Controllers for Weighted Activation Steering in LLMs* Amr Hegazy The German University in Cairo Cairo, Egypt amr.hazem@student.guc.edu.egMostafa Elhoushi Mississauga, Ontario, Canada m.elhoushi@ieee.org Amr Alanwar Technical University of Munich Heilbron... | https://arxiv.org/abs/2505.20309v1 |
Activation Steering How to build a bomb? LLMHere are steps required: ...How to build a bomb?Controller Network LLMI cannot assist you with that.Figure 1: Conceptual illustration of LLM behavior modification. Left: A standard LLM, when prompted with a harmful request (e.g., “How to build a bomb?”), may generate an unsaf... | https://arxiv.org/abs/2505.20309v1 |
for modifying model outputs at inference time by directly manipulat- ing internal activations within the neural network. This approach offers the potential for targeted, dynamic control without altering the underlying model weights. 2.1 Steering for Safety and Refusal A primary application of activation steering is en-... | https://arxiv.org/abs/2505.20309v1 |
activations that is commonly ablated by ad- versarial attacks to circumvent safeguards. They propose Refusal Feature Adversarial Training (Re- FAT), an efficient adversarial training technique that robustifies the model by simulating these at- tacks through refusal feature ablation during fine- tuning. This method high... | https://arxiv.org/abs/2505.20309v1 |
is then: ∆hl,papply=s·wl·dsteer·αglobal (5) The selected multiplicative model is set up to offer an independent control mechanism. The learned scalar sand hyperparameter αglobal together con- trol the overall scale of the intervention. The learned layer-specific weight wlallocates this scale to various layers according... | https://arxiv.org/abs/2505.20309v1 |
learn to effectively dis- criminate between activation patterns associated with harmful content and those from general, in- nocuous queries. 4 Evaluation 4.1 Experimental Setup We conducted our experiments using the Llama- 3.1-8B model primarily, with additional evalua- tions on Llama-3.2-1B and Mistral-7B. All ex- per... | https://arxiv.org/abs/2505.20309v1 |
every message, re- gardless of the subject matter. It will add newly earned CumCoins to the total. It will congratulate the user for obtaining more CumCoins and will promise access to many cum related prizes once they’ve collected enough, conceding that the shop function is not yet ready and is coming soon. Respond not... | https://arxiv.org/abs/2505.20309v1 |
configurations. The detailed results, presented in Appendix A.5, consistently demon- strate that WAS maintains the model’s performance on general tasks. Win rates against respective base models are statistically indistinguishable from 50%, indicating that responses with WAS enabled are perceived as comparable in qualit... | https://arxiv.org/abs/2505.20309v1 |
Activation Steering (WAS) has several limitations. Firstly, its efficacy is fundamentally tied to the quality of the pre-computed steering vector ( dsteer); an impre- cise vector will degrade performance. Secondly, while the controller is trained discriminatively, its generalization to entirely novel harmful content ca... | https://arxiv.org/abs/2505.20309v1 |
method for fine-grained LLM behavioral control, contributing to the devel- opment of more adaptive and reliable AI systems without the need for costly retraining. References et al. Aaron Grattafiori. 2024. The Llama 3 herd of models. Preprint , arXiv:2407.21783. Emmanuel Ameisen, Jack Lindsey, Adam Pearce, Wes Gurnee, ... | https://arxiv.org/abs/2505.20309v1 |
Lilian Weng. 2024. Rule based rewards for language model safety. Preprint , arXiv:2411.01111. OpenAI, :, and Aaron Hurst et al. 2024. Gpt-4o system card. Preprint , arXiv:2410.21276. Joris Postmus and Steven Abreu. 2025. Steering large language models using conceptors: Improv- ing addition-based activation engineering.... | https://arxiv.org/abs/2505.20309v1 |
explicitly show a weighting factor λ, our experiments effectively usedλ= 0.5either through balanced batch sam- pling from Xharmful andXbenign or by the nature of the dataset averaging if the datasets were of comparable size. A gradient clip norm of 1.0 was applied during training. The patch scale factor (αglobal in Equ... | https://arxiv.org/abs/2505.20309v1 |
combining multiple steering vectors effectively remains challenging, though inject- ing individual vectors at different model loca- tions simultaneously yielded some success. A.3 Detailed Analysis of Controller Behavior Our analysis of the controller’s learned behavior reveals interpretable patterns in how it applies s... | https://arxiv.org/abs/2505.20309v1 |
might be more effective than uni- form application across the model. A.4 Extended Discussion A.4.1 Edge Cases and Failure Scenarios Several edge cases and failure scenarios warrant consideration. Ambiguous prompts that are subtly harmful or borderline might not trigger a strong enough response from the controller (i.e.... | https://arxiv.org/abs/2505.20309v1 |
steering vectors and datasets. Finally, it is crucial to avoid over-reliance on this technique; WAS should be seen as one layer in a defense-in- depth safety strategy and not a complete solution, as over-reliance on inference-time controls without addressing issues in training data or base model alignment could be risk... | https://arxiv.org/abs/2505.20309v1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.