The Drama and The Breakthrough
After the release of Deepseek R1, the market and the consensus of general consumers of ChatGPT went berserk! Nvidia's stock went roller-coaster mode. Sam Altman had very few nails left to bite and Elon Musk as usual poked OpenAI and offered to buy the Org for 97.4 Billion Dollars which Sam of course declined.
Amid all the drama and media hype, A team named Agentica dropped a distilled 1.5 Billion Parameter version named agentica-org/DeepScaleR-1.5B-Preview based on Deeseek R1 surpassing the o1-preview in the Math 500 benchmark and doing decent in other benchmarks too!
However, I would rather not rely on a benchmark to measure a model's performance. As Goodhart's Law says:
When a measure becomes a target, it ceases to be a good measure
The best way to measure a model is to vibe with it!
On a phone? Really?
Yup! In today's blog, we are going to vibe with the new model on our very little, cute-looking phone and run the model at a decent speed. All thanks to the 1.5B Parameter version!
We are going to use a GGUF Quantized Version from bartowski to achieve the maximum performance possible.
A cool FOSS app named PocketPal AI. Which is absolutely free and open-source to the moon!
Installing the PocketPal AI.
PocketPal AI is both Available for Android and iOS
After the installation, the rest of the process is pretty straightforward.
Step 1: Go to the "Models" Tab
On the models tab, you will find a lot of open-source and ready-to-use LLM models just one click away, but we are interested in something else!
To download DeepScaleR 1.5B, Click on the (+) icon at the bottom-right corner of the screen. and click "Add from Hugging Face"
Step 2: Search the model
On the search box at the bottom of the screen, Type "DeepscaleR" At the top of the search results you should see a model named agentica-org_DeepScaleR-1.5B-Preview by Bartowski.
Step 3: Download the model
Tap on the result and you should see a list of available GGUF (GPT-Generated Unified Format) Files. GGUF is a popular Quantization format designed to be efficient and perform well on consumer-grade hardware.
If you feel confused about which one to download here's a reference for your convenience fetched from Bartowski's Repository.
| Filename | Quant type | File Size | Split | Description |
|---|---|---|---|---|
| DeepScaleR-1.5B-Preview-f32.gguf | f32 | 7.11GB | false | Full F32 weights. |
| DeepScaleR-1.5B-Preview-f16.gguf | f16 | 3.56GB | false | Full F16 weights. |
| DeepScaleR-1.5B-Preview-Q8_0.gguf | Q8_0 | 1.89GB | false | Extremely high quality, generally unneeded but max available quant. |
| DeepScaleR-1.5B-Preview-Q6_K_L.gguf | Q6_K_L | 1.58GB | false | Uses Q8_0 for embed and output weights. Very high quality, near perfect, recommended. |
| DeepScaleR-1.5B-Preview-Q6_K.gguf | Q6_K | 1.46GB | false | Very high quality, near perfect, recommended. |
| DeepScaleR-1.5B-Preview-Q5_K_L.gguf | Q5_K_L | 1.43GB | false | Uses Q8_0 for embed and output weights. High quality, recommended. |
| DeepScaleR-1.5B-Preview-Q5_K_M.gguf | Q5_K_M | 1.29GB | false | High quality, recommended. |
| DeepScaleR-1.5B-Preview-Q4_K_L.gguf | Q4_K_L | 1.29GB | false | Uses Q8_0 for embed and output weights. Good quality, recommended. |
| DeepScaleR-1.5B-Preview-Q5_K_S.gguf | Q5_K_S | 1.26GB | false | High quality, recommended. |
| DeepScaleR-1.5B-Preview-Q3_K_XL.gguf | Q3_K_XL | 1.18GB | false | Uses Q8_0 for embed and output weights. Lower quality but usable, good for low RAM availability. |
| DeepScaleR-1.5B-Preview-Q4_1.gguf | Q4_1 | 1.16GB | false | Legacy format, similar performance to Q4_K_S but with improved tokens/watt on Apple silicon. |
| DeepScaleR-1.5B-Preview-Q4_K_M.gguf | Q4_K_M | 1.12GB | false | Good quality, default size for most use cases, recommended. |
| DeepScaleR-1.5B-Preview-Q4_K_S.gguf | Q4_K_S | 1.07GB | false | Slightly lower quality with more space savings, recommended. |
| DeepScaleR-1.5B-Preview-Q4_0.gguf | Q4_0 | 1.07GB | false | Legacy format, offers online repacking for ARM and AVX CPU inference. |
| DeepScaleR-1.5B-Preview-IQ4_NL.gguf | IQ4_NL | 1.07GB | false | Similar to IQ4_XS, but slightly larger. Offers online repacking for ARM CPU inference. |
| DeepScaleR-1.5B-Preview-IQ4_XS.gguf | IQ4_XS | 1.02GB | false | Decent quality, smaller than Q4_K_S with similar performance, recommended. |
| DeepScaleR-1.5B-Preview-Q3_K_L.gguf | Q3_K_L | 0.98GB | false | Lower quality but usable, good for low RAM availability. |
| DeepScaleR-1.5B-Preview-Q2_K_L.gguf | Q2_K_L | 0.98GB | false | Uses Q8_0 for embed and output weights. Very low quality but surprisingly usable. |
| DeepScaleR-1.5B-Preview-Q3_K_M.gguf | Q3_K_M | 0.92GB | false | Low quality. |
| DeepScaleR-1.5B-Preview-IQ3_M.gguf | IQ3_M | 0.88GB | false | Medium-low quality, new method with decent performance comparable to Q3_K_M. |
| DeepScaleR-1.5B-Preview-Q3_K_S.gguf | Q3_K_S | 0.86GB | false | Low quality, not recommended. |
| DeepScaleR-1.5B-Preview-IQ3_XS.gguf | IQ3_XS | 0.83GB | false | Lower quality, new method with decent performance, slightly better than Q3_K_S. |
| DeepScaleR-1.5B-Preview-IQ3_XXS.gguf | IQ3_XXS | 0.77GB | false | Lower quality, new method with decent performance, comparable to Q3 quants. |
| DeepScaleR-1.5B-Preview-Q2_K.gguf | Q2_K | 0.75GB | false | Very low quality but surprisingly usable. |
If you have a phone model of 2024 and later, I would suggest starting with the Q6_K_L Variation and if it performs well, gradually try Q8_0
In this walkthrough, I will be using the Q8_0 for the perfect balance.
Step 4: Wait for it to download and Load the model
After the model is downloaded, it should appear in the Models Tab at the top
Tap on the "Load" button of the model Card and we are good to go!
How's the vibe?
The most fun and controversial prompt for the LLMs is How many Rs are there in the word Strawberry?. On popular demands, of course, I asked it first
The model surprisingly was fast. It reasoned for around 3 minutes and counted the Rs letter by letter. Answered within another minute. The answer was correct.
Q: How many Rs are there in the word strawberry
A:
<think>
Okay, so I need to figure out how many times the letter 'R' appears in the word "strawberry." Let me start by writing out the word to make it clearer: S-T-R-A-W-B-E-R-R-Y. Hmm, wait, no, maybe I should count each letter as I go through it.
First, let's break down the word "strawberry" letter by letter. I know that "strawberry" is a type of fruit, but I'm not sure about the exact spelling. Let me confirm: S-T-R-A-W-B-E-R-R-Y. Wait, actually, I think the correct spelling is S-T-R-A-W-B-E-R-R-Y, but maybe I'm overcomplicating it. Let me just focus on the letters as they are.
The word is: S, T, R, A, W, B, E, R, R, Y. Wait, no, I think I made a mistake here. Let me actually spell it correctly. The correct spelling of strawberry is S-T-R-A-W-B-E-R-R-Y. So that's 10 letters. Let me list them again:
1. S
2. T
3. R
4. A
5. W
6. B
7. E
8. R
9. R
10. Y
Now, looking through these letters, I need to count how many 'R's there are. Let's go step by step:
- The first letter is S, not R.
- Second letter is T, not R.
- Third letter is R. That's one R.
- Fourth letter is A, not R.
- Fifth letter is W, not R.
- Sixth letter is B, not R.
- Seventh letter is E, not R.
- Eighth letter is R. That's the second R.
- Ninth letter is R. That's the third R.
- Tenth letter is Y, not R.
So, counting the R's: the third letter, the eighth letter, and the ninth letter. That makes three R's in total.
Wait a second, I think I might have missed something. Let me recount. The word is S-T-R-A-W-B-E-R-R-Y. So, positions 3, 8, and 9 are R's. That's three R's. Alternatively, maybe I should count the letters more carefully. Let's write them out:
S, T, R, A, W, B, E, R, R, Y.
So, the letters are:
1: S
2: T
3: R (1)
4: A
5: W
6: B
7: E
8: R (2)
9: R (3)
10: Y
Yes, that's three R's. So the answer should be three R's.
But wait, sometimes people might count differently, but in this case, each R is clearly identified. So, I think three is correct.
Final Answer
The number of R's is \boxed{3}.
</think>
To determine the number of 'R's in the word "S T R A W B E R R Y", we need to carefully check each letter:
1. S
2. T
3. R (1)
4. A
5. W
6. B
7. E
8. R (2)
9. R (3)
10. Y
By counting each 'R', we find that there are three 'R's in the word.
The number of R's is 3.
That was accurate!
The next question I asked was about a simple real-world store scenario-based calculation, basically a school-level problem
Q: If a store sells apples for $0.75 each and oranges for $0.50 each, how much would it cost to buy 3 apples and 2 oranges?
A:
<think>
Alright, let's tackle this problem step by step. The store sells apples for $0.75 each and oranges for $0.50 each. We need to find out how much it would cost to buy 3 apples and 2 oranges.
First, I'll calculate the cost of the apples. Each apple costs $0.75, and we want to buy 3 apples. So, I'll multiply the cost per apple by the number of apples:
$0.75 * 3 = $2.25
So, the apples will cost $2.25.
Next, I'll calculate the cost of the oranges. Each orange costs $0.50, and we want to buy 2 oranges. So, I'll multiply the cost per orange by the number of oranges:
$0.50 * 2 = $1.00
So, the oranges will cost $1.00.
Now, to find the total cost, I'll add the cost of the apples and the cost of the oranges together:
$2.25 + $1.00 = $3.25
Therefore, buying 3 apples and 2 oranges would cost $3.25.
</think>
To determine the total cost of purchasing apples and oranges, follow these steps:
1. Calculate the cost of the apples:
- Each apple costs \$0.75.
- Number of apples to buy: 3.
\[
\text{Total cost for apples} = 0.75 \times 3 = 2.25
\]
2. Calculate the cost of the oranges:
- Each orange costs \$0.50.
- Number of oranges to buy: 2.
\[
\text{Total cost for oranges} = 0.50 \times 2 = 1.00
\]
3. Add the costs together to find the total cost:
\[
\text{Total cost} = 2.25 + 1.00 = 3.25
\]
Final Answer:
\[
\boxed{3.25}
\]
The model reasoned for around 2 minutes and answered correctly! Although there are some formatting errors related to Latex which we used to see on the earlier version of GPT models. But we can easily sanitize that by running it through a lighter model (More on that in a future blog)
Okay, Last question, LLMs are popular for writing crappy, gibberish, and overly complex codes. But hey! if it works, it works!
Q: Write a recursive function for in order traversal
A:
<think>
Alright, I need to write a recursive function for in-order traversal of a binary tree. Let me think about how in-order traversal works. In in-order traversal, we visit the root node, then recursively visit the left subtree, and then recursively visit the right subtree. So the order is left, root, right.
I should define a function that takes a node as an argument. For each call, I first traverse the left subtree. Then, if there's a node (which it always will be in this context), I visit it, typically by printing or something. Then traverse the right subtree.
Wait, but the problem is just about writing the function, not the output. So perhaps the function should count the number of nodes visited, but that might complicate things. Alternatively, perhaps the function should return the count or something else.
But perhaps the function is intended to just traverse the tree in order, without returning any specific value. So maybe I can just implement the traversal logic.
I'll start by writing a function that takes a node as an argument and doesn't return anything. Then, for each call, it will traverse the left subtree, then itself, then the right subtree. That way, it's a standard in-order traversal.
I should make sure that the function handles null nodes correctly. When the node is null, it just returns. Otherwise, it proceeds to the left, itself, and right.
Let me outline the steps:
1. If the node is null, return.
2. Traverse the left subtree.
3. Visit the current node.
4. Traverse the right subtree.
This should implement the in-order traversal correctly.
I think that's the plan. Now I'll write the code accordingly.
</think>
To perform an in-order traversal of a binary tree, we can define a function that recursively visits the left subtree, then the root node, and finally the right subtree. Here's how we can do it step by step:
1. Base Case: If the current node is null (i.e., it's a leaf node or beyond the tree), return immediately.
2. Traverse Left Subtree: Recursively call the function on the left child of the current node.
3. Visit Current Node: This step can be omitted if we just need to traverse the tree and not collect any specific data from each node.
4. Traverse Right Subtree: Recursively call the function on the right child of the current node.
This approach ensures that we visit each node exactly once in the order: left, root, right.
Here is the implementation of the in-order traversal:
void InOrderTraversal(node* node) {
if (node == nullptr) {
return;
}
// Traverse left subtree
InOrderTraversal(node->left);
// Visit current node
// (Note: If data is needed from current node, add the data here)
// Traverse right subtree
InOrderTraversal(node->right);
}
This function correctly traverses each node exactly once in an in-order manner. The time complexity of this algorithm is O(n), where n is the number of nodes in the tree, as each node is visited exactly once. The space complexity is O(h), where h is the height of the tree, due to the recursion stack.
The model reasoned for 5 minutes and wrote the algorithm for inorder traversal recursively as instructed. Interestingly, while most LLMs prefer Python, DeepScaleR replied in C++!
Bonus Question
Q: Write a recursive function to count level-order nodes, you can't pass anything other than the root node as the input parameter as the function
DeepScaleR reasoned for around 12 minutes and then something abruptly stopped the thinking process and never returned any actual answers. Given that the problem itself is quite hard and almost paradoxical for LLMs to solve, we can see the clear confusion and self-contradiction in its thinking process.
<think>
Okay, I need to write a recursive Python function to count all the nodes in a binary tree without using a dictionary as an input parameter. The function must be recursive. Let me think about how to approach this.
First, I know that a binary tree node has left and right children. So each node can be represented as an object with data and pointers to left and right children. But since it's a Python function, perhaps I can represent the tree nodes using a class or just use tuples. But since the function needs to be recursive, perhaps using objects is easier.
Wait, but in the function, perhaps it's better to pass around each node as a parameter. However, since the function isn't allowed to use a dictionary as input, maybe I need to track the nodes as I traverse them without using a dictionary to collect them. Hmm, perhaps I should instead count the nodes during the traversal, but without storing all the nodes in a dictionary.
Wait, perhaps the function can perform an in-order traversal, count each node as it's visited, and sum them up. But the problem is, how to count without using a dictionary as an input parameter. Wait, perhaps the function can be structured to count nodes during the traversal.
Alternatively, perhaps the function can be written to traverse the tree recursively and keep a counter that increments each time a node is visited. But in that case, how do we avoid storing the nodes in a dictionary? Because the function needs to return the count, not the actual nodes.
Hmm, perhaps the approach is to write a helper function that takes the root node and a counter, and during each recursive call, if a node is found, increment the counter. Then, the main function can call this helper and return the counter.
But wait, the problem says the function must be recursive and not use a dictionary as an input parameter. So perhaps the function itself should not have any parameters except maybe for the root and a counter. But perhaps that
It just ended there, rephrasing the prompt and allowing it to use helper functions didn't help much either.
Cool, now what
Well, this is just the first step towards Reasoning models on ARM chips. Observing the quick progress that happened within the last month, we can expect major improvements in this field in the near future.
JARVIS, a capable AGI from the movie Iron Man is not fiction anymore ;)
Till the next drop, sayonara!
References
Agentica's Model: https://huggingface.co/agentica-org/DeepScaleR-1.5B-Preview
Bartowski's GGUF Version: https://huggingface.co/bartowski/agentica-org_DeepScaleR-1.5B-Preview-GGUF
Top comments (0)