keveman

Moonshine author here: The warning is from Keras library, and is benign. If you didn't get any other output, it was probably because the model thought there was no speech (not saying there really was no speech). We uploaded ONNX version that is considerably faster than the Torch/JAX/TF versions, and is usable with less package bloat. I hope you would give it another shot.

This enables a true natural language voice interface to any device/appliance that currently has a touch pad or a bunch of buttons. Yes, faster than faster-whisper, but that's really an apples to oranges comparison, because useful-transformers uses the NPU on the Rockchip processors, so it works only on those. Whereas faster-whisper works fast on most/all platforms.

This is for speech to text, so generating text, not audio. And on a $120-$170 device, this transcribes at 30x real time. The code does run on lower end Rockchip processors, costing ~$30, although only at 10x real time speed.

The tiny.en Whisper model transcribes speech at 30x real-time speeds on an Orange Pi 5.

I met Bram in the Google Mountain View office. We chatted for over two hours. He was full of humility and curiosity and more interested in what I was working on (I was working on DistBelief back then). Hats off to a life full of impact and a legacy that will continue to impact programmers all over the world. RIP.

How is this programmed?

Full disclosure: I am a Cerebras employee.

There is extensive support for TensorFlow. A wide range of models expressed in the TensorFlow will be accelerated transparently.

Yeah, you are right, alignas is still unsupported in many compilers. clang 3.2 supports it. However, unrestricted unions has been supported in many compilers for a long time now. I would use that in this case, since you already know the type 'T'.

Here is the C++11 way of specifying alignment :

    alignas(T) char buffer[sizeof(T)];

    union {
      T t;
    };

I don't think std::function does any dynamic allocation when you initialize it with simple functions. When you initialize it with function objects or lambda expression, most, if not all implementations use the small object optimization to avoid dynamic allocation when possible.

You are partly right. The frontend of the compiler that translates the CUDA dialect of C++ to LLVM IR is not open source.

The title is not 100% accurate. CUDA has come to mean the tool chain and ecosystem for GPGPU programming. Part of the system is the particular dialect of C++ in which a programmer can mix and match CPU and GPU code. It also includes the compiler that translates the GPU part to object code (the ISA is called PTX [1] which is one level removed from the actual GPU's ISA). What NVIDIA has open-sourced is the part that translates LLVM IR to PTX. The greatest benefit of this will be for people who are developing alternate programming models/DSLs for programming GPUs. They can translate their DSL to LLVM IR, which they probably are already doing, and then generate PTX using the open-source compiler.

[1] http://en.wikipedia.org/wiki/Parallel_Thread_Execution

A somewhat similar project : https://github.com/copperhead/copperhead

Should we all take a serious look at functional programming? Absolutely. Should we start learning a functional programming language? Maybe not. C++ is a multi-paradigm language in which one can write functional programs, and it lends itself nicely to switching back to stateful imperative programming when needed.

Good point. I haven't used STL algorithms on raw pointers in quite a while, that I didn't think of that reason at all.

As engineers and logicians, we almost always ask, how? But this is one of the times that I want to ask, why? :'(

It looks like a worthy competitor to OpenCL and CUDA. The programming model is quite similar to both of them. The current implementation is on Windows only using DirectCompute API, but since they are making it "open", we should hopefully see implementations on other platforms using more close to the metal APIs.

Is there an explanation of how Python yield is implemented?

I find it easier if I disassociate the English meanings of the words from really how the words are used to mean different things in computer science. To me, concurrency is only in the programmers mind. That is, a programmer writes concurrent programs with different threads of control, say, one to process the user input, one to process the network packets etc. In reality, the multiple threads of control could really be running SEQUENTIALLY. That was the case when there was only one core. Remember, pthreads predates multi-cores.

Parallelism is something more concrete, it REALLY exists in the real world. A programmer could just imagine and write a sequential loop, but if the compiler deemed it to be really parallel, it could really run parts of the loop in parallel. Of course, a programmer could write a concurrent program, as in, multiple threads of control, and the system could really run it in parallel, say on different cores of a multi-core processor. So remember, concurrency is abstract, parallelism is concrete.

Ceylon looks a lot (if not identical) to Scala. I was trying hard to find a differentiation, but couldn't.

Here is a link to ArBB website : http://software.intel.com/en-us/articles/intel-array-buildin...

Where would you place expression templates that help designers to embed simple domain specific languages in C++? The end user doesn't have to know much about templates, but this approach leads to high performance AND very concise and expressive code.