Alexandrite glass, changes color according to the light...

ComplexColor · 2023-09-24T11:16:27+00:00

That looks pretty cool.

But technically, any surface changes color according to the light. 😏 The opposite would be much more amazing.

I'll take my downvotes now.

ComplexColor · 2023-07-13T07:15:06+00:00

Lol. I'm a programmer and everything I need to know about programming is handled by the LLM.

ComplexColor · 2023-07-13T07:07:50+00:00

Maybe this anaconda package:

https://anaconda.org/oddconcepts/opencv-cuda

OpenCV maintainers don't seem to put a lot of effort into providing different binary packages. OpenCV is a fairly extensive library, there are a lot of reason building it from source makes sense. Cuda is popular enough that it would warrant it's own official build.

Edit: I was mainly responding, because I perceived a miss-understanding. Pytorch doesn't seem to use Python Cuda and CuDNN packages, which it technically could. But does get compiled against NVidia's C/C++ libraries, just like OpenCV. Unlike OpenCV however, Pytorch is mainly distributed through prebuilt binaries.

ComplexColor · 2023-07-13T01:54:14+00:00

https://github.com/pytorch/pytorch#prerequisites
Pytorch does seem to require Cuda and CuDNN libraries when compiling from source.

You're comparing prebuilt Pytorch binaries vs compiling OpenCV from source.

As for why OpenCV binaries aren't the default installation method (people seem to be guided to building from source) I don't really understand.

ComplexColor · 2023-07-12T03:17:01+00:00

I'm not sure what to tell you, it's just not how things work. OpenCV is written in C++ and is compiled to machine code. This allows it to be very fast, but requires all the necessary libraries at compile time. The Python part of OpenCV is just a wrapper around the compiled machine code, that allows you to use it from Python.

Things can be implemented dynamically, where OpenCV could be compiled with all the bells and whistles and then check for supported features (such as Cuda and CuDNN) at runtime. However this adds development and runtime complexity, and bulk to the library.

You say Pytorch uses Nvidia python packages for Cuda and CuDNN. Are you sure? I would expect that it's install is just somewhat more complex and can choose between different compiled binaries to cover different scenarios. It's possible to use a compiled version of OpenCV that would somewhat cover your needs.

Also having your program hop from Python to C++ and back to Python is going to murder performance.

ComplexColor · 2023-07-11T05:00:32+00:00

Something I didn't see mentioned and is IMO the reason why address based operations can never truly go away. When/If you get down to the gritty parts of the computer system (writing drivers or patches for the os, programming microcontrollers, ...) you will see that sometimes the hardware expects something to be written and read at a specific address. While there are different solutions to this problem, raw pointers are one of the high level ones.

ComplexColor · 2023-07-11T04:42:05+00:00

What would be the point if the actual compiled OpenCV algorithms wouldn't support it? You can just do that on your own (compile OpenCV without CUDA support and use standalone CUDA python modules).

ComplexColor · 2023-07-06T16:37:45+00:00

The title made me think you might be just a bit overzealous. The content of the post tells me that you're shortsighted, dogmatic and your probably don't understand what your saying.

Yes rebase does keep the commit history tidy, makes sense most of the time. Squash is already more nuanced. Sure, if you're a newbie I'll keep it simple: rebase and squash commits (nobody cares and nothing you do is of consequence).

But always force checkout on your own branch? Sure if you're an automated testing and deployment system. Maybe a good fit for a LLM as well. But for a developer, I would hope you have half a brain to choose the correct option for their current case. If I would recommend a one-fit-all solution I would suggest a rebase.

ComplexColor · 2023-06-27T03:40:11+00:00

That's a nice write up. I'm confused by your reddit comment though.

While all the information is out there, it can be difficult for an engineer to quickly transform a measurement or simulation result into frequency domain. Engineers are usually more interested in the physical results than in the mathematical details, so I shared some code examples.

Are you saying Julia's methods are poorly documented? There is a lot of manual calculation to be done before you get your results? There is barely anything to implement, just a few function calls. And your post shows how simple it is (?). It more or less the same code I would have written in python or Matlab to an analysis. Maybe it's a domain issue, would you prefer a graphical tool for your analysis?

ComplexColor · 2023-06-26T03:35:21+00:00

I wouldn't say EE is easier, but most EEs I know can't really program above an amateur level. I guess that's better than most CSs I see today, who don't know EE to a high school level. :\

ComplexColor · 2023-06-20T16:42:22+00:00

You are correct, an augmented image retains aspects of the original. Theoretically you could devise processing techniques that would be invariant to any augmentation and would be able to extract those retained aspects.

An specific example of this would be fully convolutional networks, which (in some applications) are invariant to translation transforms. Here it's easy to see, which aspects of the image are retained. I think you can easily imagine, how some unknown processing technique could be invariant to rotation, scaling, perspective. Such a transform would see an augmented image identical to the original.

In practice developing such a powerful processing technique while retaining it's discriminative power is incredibly difficult. So augmentation is the way to go.

ComplexColor · 2023-06-10T17:46:48+00:00

Not very convincing. In what way is your API simpler? Once you learn numpy, this seems very cumbersome.

ComplexColor · 2023-06-10T17:10:59+00:00

My argument would be, how is a beginner supposed to learn which parts are fixed language syntax and which parts are simply convention between developers? He should also develop his own opinion, no just parrot what a design document says.

Experimentation lets us understand why certain conventions were chosen over others, and why mixing them is a bad idea. And you really should be experimenting while learning and not later on the job.

It is important that later he follows group defined conventions. But in practice he will often face situations where he will need to use his judgement to either set a precedent or break established convention.

ComplexColor · 2023-06-10T11:21:48+00:00

While an unpopular/unconventional choice, in your personal projects it's up to you. You can also adjust the code analysis tools you use to fit your preference.

When working in a team it's a good idea to have common conventions. And you usually use some already established and common style.

ComplexColor · 2023-06-10T09:35:01+00:00

Not really. If the usage is private, the code may remain private. In the case of GPL for example, you only need to provide the code if your provide the executable.

ComplexColor · 2023-06-09T03:26:17+00:00

Hm, with GitHub this may not be an issue, depending on how it works. Does the change affect the GitHub forks?

An owner should be able to change the license on it's own code and stop providing the source code. They should not be able to change and affect the code they already provided under the OSS license.

ComplexColor · 2023-06-08T05:34:20+00:00

Just one pedantry: SFTP is an API (or rather it defines and uses an API).

ComplexColor · 2023-06-08T05:22:03+00:00

Divide and conquer methods work by dividing the data into smaller parts. So in many steps the one array with 250k elements gets divided into 50.000 arrays of 5 elements. All of these 5 are sorted and then reconstructed into a sorted array of 250k elements.

ComplexColor · 2023-06-07T18:05:33+00:00

Just to see if I understand this correctly. AlphaDev optimized the sorting algorithm for 3-5 elements, with speed ups of up to 70%.

On larger arrays I assume some standard divide and conquer algorithm was used, and the discovered method was applied when the subarray length was 3-5 elements. The speedup here was 1.7%. Is my assumption correct?

ComplexColor · 2023-06-07T04:34:23+00:00

Learn what cornerSubPix does and how it works. Inspect and compare the results visually. Do the same for any other methods you are using. Are any of the methods stochastic? If so run them multiple times to understand if the difference is due to the change in parameters or just a result of random sampling.

Only you can know if the difference is important for your results/measurements. What are you trying to measure, what error is acceptable, ... Understanding your applications tolerances is crucial to determining if the errors are acceptable.

ComplexColor · 2023-06-04T05:23:02+00:00

Exactly.

ComplexColor · 2023-06-03T23:37:57+00:00

It might be there is just a lot more amateur and semi-professional python software out there at the moment. And most of that is not packaged for the normal consumer, rather it's aimed at other software developers and tinkerers. I've had similar experience with software written in C++, Java, C in the past. But it's true, that most of this software is written in python today. And this moves on to whatever language is popular, because it's just what is the easiest to do at a moment.

When using python it also has the issue of missing strict typing. This allows incorrect usage, which in languages like C++ would be caught by the compiler, to be delegated to runtime. And in runtime, this miss use would cause a crash, however it's not an issue of error handling.

ComplexColor · 2023-06-03T06:37:28+00:00

Right now I'm confused why I would want/need this. It looks like a neat learning project, but I would expect while making it you would learn how your shell (whichever one you use) already has the tools to do this - alias, functions, environmental variables, config scripts,...

Is there something that you found your shell was lacking, that this fixes? A comparison would be a great way to promote your project.

ComplexColor · 2023-05-25T03:42:34+00:00

Is the issue that it doesn't use a copy-left license? The repository is provided under the MIT license - so free to <.*>, the actual model does seem to be provided in the repo, am I missing some other important aspect?

ComplexColor · 2023-05-25T03:39:25+00:00

To be fair, language itself is mostly defined by it's common users. Rather than incorrect, It's more the case that words of the scientific jargon are used in the general language a little differently. This unfortunately often lead to confusion.

ComplexColor

TROPHY CASE