Building a dataset is expensive, manual annotation is expensive. Datasets don't exist in every niche.
I remember around 2013-15 people were scoffing at uses of deep learning CNNs for various things, because why don't you just use an SVM on HOG features? Or face detection is solved, just use Viola-Jones.
What if you give the benefit of doubt and assume the author knows about alternatives and uses VLMs for their strengths? They use it to auto-annotate training data for regular deep learning models.
If you love Zotero as is, I'd say the app isn't for you. However, as far as I know, I have covered almost everything Zotero has, and I find the adoption stage to be easier than when I started using Zotero, and I like that it's a little easier on the eyes.
A couple of differences; Correct me if I'm wrong, is that Zotero doesn't natively allow many-to-many relationships, I sometimes have several different papers, that I am interested in for a couple different reasons, so being able to keep them assigned to different projects at the same time.
Another thing is keeping track of different versions of papers, linXiv has the ability to poll for new versions of the same paper across feeds you setup. I haven't had it come up yet, but it was one of the reasons I started linXiv. Thanks for your comment!
Because of the increased supply of managing remote devices.
The tradeoff with limited graphics is more expansive platform support.
For example, we're doing some Layer 2/Layer 1 networking processing on an embedded linux environment. We can have a nice TUI displaying average SNR, various waveforms, connection status. It's great.
Also, when you do lots of work with remote devices, having something like termscp is wonderful for file transfer.
> I always struggled to understand practical applications.
Me too...and specifically with non-smooth dynamical systems. I always felt some better knowledge or intuition on my part could lead to understanding the practical application.
It's one reason I left academia... wtf this is cool, but wtf is this useful for?
The closest practical application I can fathom in this theoretical realm is optimization. And welp, since that underlies all AI, that's pretty important. Oh and cryptography.
I changed it to "call path planner to navigate: a_star(x0, xf, obs)"
Another fail.
My intuition tells me micro llms will/are important for robotics. I just can't grok it. Can someone without control theory experience give me a good example?
Probably at the planning level of the navigation stack. That's where I see reasoning being helpful. Lower than that...idk
Give me an example of a robotics prompt that seems useful and I'll give you an example why we don't need LLMs to be a tracking controller, etc.
I got inspired by that branchless rust post a couple days ago. Tried it out here and got a ~50% speedup on a 10 million word file. (Averaged over 100 runs).
File IO was the real bottleneck, so I loaded the entire file into RAM and removed the repeated fgetc's so the actual algorithms could be compared.
word_counter elapsed time: 0.043484000 seconds
The number of words is: 10000000
The number of rows is: 221000
How does this work?
You're essentially running an edge detector over words so you can for the main loop you can do a psudo-filter over a 2-sample sliding window.
This works because isalnum returns an int which is 0 when it's not a alphanumeric character. So logically the input stream becomes _ _ _---_ _ _---_ _ -- where ___ is 0 and --- is > 0.
You can detect an edge by having a 2-sample "kernel" [1, 0] which you add with a 2-sample sliding window.
That gives us these cases:
- no-word section the result is [1, 0] + [0, 0] = [1, 0].
- a rising edge section the result is [1, 0] + [0, >0] = [1, >0]
- a word section the result is [1, 0] + [>0, >0] = [>0, >0]
- a falling edge section the result is [1, 0] + [>0, 0] = [>0, 0]
So we can use the rising edge case to increment the word count. Row count can be incremented without a conditional as well.
Resultant loop is:
uint32_t i;
unsigned char new_ch;
int prev_now[2] = {0, 0};
int PREV_IDX = 0;
int NOW_IDX = 1;
int kernel[2] = {1, 0};
int result[2] = {0, 0};
for (i = 0; i < file_size_bytes; i++){
// Update now
new_ch = data[i];
prev_now[NOW_IDX] = isalnum((unsigned char)new_ch);
// Edge detect
result[0] = prev_now[NOW_IDX] + kernel[0];
result[1] = prev_now[PREV_IDX] + kernel[1];
*w_cnt += result[0] == 1 && result[1] > 0;
*r_cnt += new_ch == '\n';
// Shift without a move operation
PREV_IDX = 1 - PREV_IDX;
NOW_IDX = 1 - NOW_IDX;
// Shift with a move operation
//prev_now[PREV_IDX] = prev_now[NOW_IDX];
}
Thanks you so much for taking the time to work with the code that I've written. As someone who is just getting back to the programming world, the C world, these concepts are brand new. As a master student in physics, I love the fact that the input stream can be seen as a signal to be analysed. It's mind-blowing to see how math can reduce the execution time by 50%. I am going to take my time to fully understand your implementation. Again, thank you so much for your time and the masterclass
Personally, I'd make the NULL_PTR error message a bit more specific. "Memory Error" is quite general. The real issue is that specific invalid arguments were passed in.
Now since this may live in it's own module and not be a public function, that could be fine. But if it's ever expanded, you'll want callers to know what specifically went wrong to help debugging.
Great writeup, cheers.
reply