We hope real 3d camera will be a reality in some years.
462 karma · joined June 13, 2020
We hope real 3d camera will be a reality in some years.
I had a very complex piece of logic, with many many many moving parts. So I implemented many paths of that logic by hand, every one with their own specifics. Every path took something like 200-400 lines of code.
When this was done and correct. It was difficult to see the moving parts through the forest. Some code was similar but still a bit different, and hard to think about and spread in many places.
I put everything into an Llm and asked about isolation, architecture and refactoring.
And it actually gave me pretty good abstractions and a good architecture. It didn't include every possible path, but was easy enough to be continued by hand.
It's not that I would not have tought about it. But it was easier that way, and probably my handcrafted solution would be very similar (+headache).
Of course, I reviewed it extensively, and reimplemented every missing path and corrected the ones that were buggy now by hand.
For the experiment, I played with agents to fill the missing parts, it was a disaster :)
As a more concrete example, as soon as you learn to enjoy learning as an activity, it becomes fun, whatever you are studying. So you only need to learn to have fun while learning. Start with simple things, make it a game, find beauty in what you are learning.
I found the most systematic way of teaching critical thinking is to do a lot of maths.
I need to import many of my books from America by resellers and pay many duties..
Sometimes a book at $20 is sold >$200..
Professional apps should stay professional and more time should be spent in training power users.
I'm trying not to mix with my own survivorship bias,but I tend to believe that current trends of design remove the existance of advanced users at a young age. The applications are so polished and limiting that you don't spend time trying to do complex things with them.
I find bugs in old apps were a feature for learning. If it doesn't work, you try to understand why. Curiosity is intrinsic to young children, until we remove it by giving them something that never bug or limits their possibilities.
While easy to use softwares are more 'enjoyable' and the dopamine reward is high for small actions, it also prevent to develop some ability and resilience in navigating harder things. When the software complexity increases, users get annoyed and don't use it correctly because they were never exposed to much complexity before. (thinking about medical softwares that require many many actions to encode a patient, finance softwares, etc..)
Now, not all softwares are made to improve one efficiency. In your case, the app allows a children to express its creativity in other ways, which is very valuable also. So I think it is good that the interface and the interaction are easy, the focus should be on the creativity and not on the manipulation.
A scientific paper is written for a specific audience, experts in that field, and when you read many papers, it's very annoying 'easy writing' because you need to rapidly understand the meat of the paper, not being introduced again and again to your subject. Now it's more difficult to find the details that you need, if they're even written.
It makes maybe the job of a PhD easier when he start studying in the field, but I think we lost something there..
Not all fields are equal, deep learning papers are very easy to read, but also very annoying to read, too many repetitions of something that is explained in another paper, I don't need to read for the 100th time what NeRF is, only what is different in this paper compared to the previous ones. While many mathematical papers are way more dense and target the intended audience.
Increasing the page count is not really a solution either, it is a burden for the writer to continue writing easy things, and for the reader to never find the interesting parts.
On the other hand, when I read a paper that is not in my field, I appreciate the easy to read paper.
I think papers should return to dense readings by experts, but authors should also maintain blogs where the paper is simplified, and those blogs should be included in the evaluation for a PhD. In this way, if you are an expert, you get the interesting parts, and at the same time, if it is not your field, you can be introduced with many good blogs to the field.
I agree that would be a good solution, despite that my data is huge, but it assumes the data doesn't change, or doesn't change that much.
When I tried to refactor using types, this kind of problems became obvious. And forced more conversions than intended.
So I'm really curious because, a part from rewriting everything, I don't see how to avoid this problem. It's more natural for some applications to have the data format 1 and for others the data format 2. And forcing one over the other would make the application slow.
The problem arises only in 'hybrid' pipelines when new scientist need to use some existing functions some of them in the first data format, and the others in the other.
As a simple example, you can write rotations in a software in many ways, some will use matrix multiply, some Euler angles, some quaternions, some geometric algebra. It depends on the application at hand which one works the best as it maps better with the mental model of the current application. For example geometric algebra is way better to think about a problem, but sometimes Euler angles are output from a physical sensor. So some scientists will use the first, and the others the second. (of course, those kind of conversions are quite trivial and we don't care that much, but suppose each conversion is very expensive for one reason or another)
I didn't find it a criticism :)
For example, it's not my case but it's like having to convert between two image representations (matrix multiply each pixel) every time.
I'm scared that this kind of 'automatic conversion' slowness will be extremely difficult to debug and to monitor.
There is no a 'proper' way to do it! It goes like this, you change it, if it looks good, well, good job, if not, ask yourself why, and try your best to take that into account next time.
It's by doing millions of small mistakes that you improve. The teacher teaches one way that is kinda easy to grasp, it's not the only way and far from unique.
The further you go, the further you will see the same mistakes, and you will start to think in terms of volumes, shapes, shadows, perspective, even anatomy if you still struggle on some human body parts
Supoose you make two simple types one for Kelvin K and the other for Fahrenheit F or degrees D.
And you implement the conversions between them in the types.
But then you have something like
d: D = 10;
For i=1...100000:
k=f_Take_D_Return_K(d)
d=g_Take_K_Return_D(k)
endThen you will implicitly have many many automatic conversions that are not useful. How to handle this? Is it easily catched by the compiler when the functions are way more complex?
But also remember, many of those lectures are at a slower peace, so one or two lectures per week. It takes time to internalize the material. People that don't follow university usually try to binge watch them, but this leads to low outcomes.
I think the best strategy is to put deadlines and risks for yourself, and follow them at a natural peace. And, do the exercices.
> One explanation for why this game works is that there is only one way in which things are related
There is not, this is a completely non transitive relationship.
On another point, suppose you keep the same vocabulary, but permute the signification of the words, the neural network will still learn relationships, completely different ones, but it's representation may converge toward a better compression for that set of words, but I'm dubious that this new compression scheme will ressemble the previous one (?)
I would say that given an optimal encoding of the relationships, we can achieve an extreme compression, but not all encodings lead to the same compression at the end.
If I add 'bla' between every words in a text, that is easy to compress, but now, if I add an increasing sequence of words between each words, the meaning is still there, but the compression will not be the same, as the network will try to generate the words in-between.
(thinking out loud)
I didn't really get the last two bullet points
People that are interested can ask either to give more details on what I have explained, or what about the rest. If they are not interested, they say something and I usually ask what about them, no hard feelings.
It works smoothly for me.
You transform your training data in a very strange and high dimensional space. Then when you write an input, you calculate the distance between that input and the closest point in that space.
So, in some sense.. You pattern match your input with the training data. Of course, in a very non intuitive way for humans.
Now, it doesn't necessarily imply things as 'models cannot solve new problems not seen before' we don't know if our problem could get matched to something completely unrelated for us, but in that space it makes sense.
So with your experiments, if the model is able to solve a new puzzle never seen before, you'll never know why, but it doesn't imply either that the new puzzle was not matched in some sense to some previous data in the dataset.
You have global memory and shared memory, the global is slower.
You read in rows in the global memory (faster than reading columns)
You write in columns in the shared memory (slower than in rows, but the shared memory is fast, this is the transpose operation)
You read in rows in the shared memory (very fast)
You write in rows in the global memory (faster than writing in columns)
The idea behind that tiling is to hide the slow part in a memory that is faster.
In inkscape you can make only a one direction gradient, never a gradient with more than 2 points, I don't know if it is a limitation of the format itself.
Also when you have multiple gradients in one file, the software becomes extremely slow. And they don't mix correctly when overlapped with transparency.
It seems a low hanging fruit to optimize that, but I guess there is little traction
I don't use much the Healthcare system in Europe, but I knew someone that had a very rare disease, and in that case there were absolutely no reimbursements, again only one data point.
It's nice and well to say that everyone has 'access' to Healthcare in europe, but if the quality is very low, I'm not sure it's a win. But that's just my opinion.
They often move out of the country, and the ones that remains are often not the better ones.
But yeah, its less expensive, unless you factor all the things that are not reimbursed and the wait times.
I'm loosing karma, I guess I can't express my data point freely.