hydra VS TinyLlama

Different hydra

https://github.com/hydra-synth/hydra

I heard about vvvv in my first year of studying in this industry. And kyma for sound design.

But I later discovered that the more mainstream ones are puredata and its commercial version max/msp. for sound design I also use: supercollider and csound.

After some years, I felt that I still preferred text-based interaction while I need some even simpler live coding or prototyping tool. so I made glicol.

for visuals, I would recommend:

https://hydra.ojack.xyz/

and

https://nannou.cc/

https://www.youtube.com/watch?v=-QY2x6aZzqc

Graphics

- Processing is a great place to start: https://www.youtube.com/watch?v=4JzDttgdILQ

- Great intro to programming shaders for art from kishimisu: https://www.youtube.com/watch?v=f4s1h2YETNY

- Inigo Quilex invented ShaderToy among other things. I haven't watched this yet but I'm sure it's awesome: https://www.youtube.com/watch?v=BFld4EBO2RE

- Hydra looks pretty neat for live-coding graphics in the browser: https://hydra.ojack.xyz/

I was really hoping to find a platform that would allow for integrating a programmatic 'score' of music and drive visuals from it, like one step above just using the wave-form to trigger visuals.. I don't know if I've found what I'm happy with yet.. I think I'll try to hook up the OSC signals from SuperCollider with some visuals, but not sure. I want to use shaders if possible, and SC doesn't really support that. Gibber seems great but I'm not sure. Maybe Tidal has it, but the Tidal lang might take a while to learn. I want to use raw frequency values for the notes as much as possible, and that's really easy in SC. I don't want to be stuck using midi notes.

Or https://github.com/hydra-synth/hydra (Livecoding networked visuals in the browser, since 2017)

http://hydra.ojack.xyz would be my secondary recommendation. You can pull all different kinds of source into it and do lots of the typical video mixer effects plus a lot more.

If you like this, then you will probably like /r/livecoding. https://hydra.ojack.xyz/ is a great starting point if you'd like to code visuals - it is JS based, reactive to audio, quite easy to get started.

hydra - this is a free browser based coding environment that generates visuals. There’s a lot of documentation on their site on how to use it which is great. I’m not super knowledgeable on it but there’s a very active discord server.

Hi there, I just have a friends small party and I'm looking for online visual generators to mix into Resolume via iPad or web browser, is just for fun so is not worth to generate visuals from scratch since is a very small party and we want only to have fun with the projector so I'm looking for online (or iPad apps) that can generate visual elements to mix like ( http://spacetypegenerator.com/ , https://hydra.ojack.xyz/ or https://patatap.com/) so I can run them in an iPad and have some fun with feedback and Resolume. Do you know more resources like this?

Im using hydra.ojack.xyz for a university project and am having some issues. I am aiming to use my laptop mic to affect the onscreen visuals with the audio. I have literally 0 coding knowledge so was using openAI for help but the code its giving me doesn't seem to be working.

Small models: Less than ~1B parameters. TinyLlama and tinydolphin are examples of small models.

GitHub repo with links to the checkpoints: https://github.com/jzhang38/TinyLlama

> While LLM projects typically require an exorbitant amount of resources, it is important to remind ourselves that research does not need to assemble full-fledged massively expensive systems in order to have impact.

Check out TinyLlama; https://github.com/jzhang38/TinyLlama

Four research students from Singapore University of Technology and Design are pretraining a 1.1B Llama model on 3 trillion token using a handful of A100's.

They're also providing the source code, training data, and fine-tuned checkpoints for anyone to run.

The first one was that the minimum learning rate was mistakenly set to the same value as the maximum learning rate in cosine decay, so the learning rate wasn't decreasing. This was discovered relatively early during training and discussed in this issue: https://github.com/jzhang38/TinyLlama/issues/27

Which is a smaller model, that gives good output and that works best with this. I am looking to run this on lower end systems.

I wonder if someone has already tried https://github.com/jzhang38/TinyLlama, could save me some time :)

I thought I'd share something with my experience with HPC that applies to many areas, especially in the rise of GPUs.

The main bottleneck isn't compute, it is memory. If you go to talks you're gonna see lots of figures like this one[0] (typically also showing disk speeds, which are crazy small).

Compute is increasing so fast that at this point we finish our operations long faster than it takes to save those simulations or even create the visualizations and put on disk. There's a lot of research going into this, with a lot of things like in situ computing (asynchronous operations, often pushing to a different machine, but needing many things like flash buffers. See ADIOS[1] as an example software).

What I'm getting at here is that we're at a point where we have to think about that IO bottleneck, even for non-high performance systems. I work in ML now, which we typically think of as compute bound, but being in the generative space there are still many things where the IO bottlenecks. This can be loading batches into memory, writing results to disk, or communication between distributed processes. It's one beg reason we typically want to maximize memory usage (large batches).

There's a lot of low hanging fruit in these areas that aren't going to be generally publishable works but are going to have lots of high impact. Just look at things like LLaMA CPP[2], where in the process they've really decreased the compute time and memory load. There's also projects like TinyLLaMa[3] who are exploring training a 1B model and doing so on limited compute, and are getting pretty good results. But I'll tell you from personal experience, small models and limited compute experience doesn't make for good papers (my most cited work did this and has never been published, gotten many rejections for not competing with models 100x it's size, but is also quite popular in the general scientific community who work with limited compute). Wfiw, companies that are working on applications do value these things, but it is also noise in the community that's hard to parse. Idk how we can do better as a community to not get trapped in these hype cycles, because real engineering has a lot of these aspects too, and they should be (but aren't) really good areas for academics to be working in. Scale isn't everything in research, and there's a lot of different problems out there that are extremely important but many are blind to.

And one final comment, there's lots of code that is used over and over that are not remotely optimized and can be >100x faster. Just gotta slow down and write good code. The move fast and break things method is great for getting moving but the debt compounds. It's just debt is less visible, but there's so much money being wasted from writing bad code (and LLMs are only going to amplify this. They were trained on bad code after all)

[0] https://drivenets.com/wp-content/uploads/2023/05/blog-networ...

[1] https://github.com/ornladios/ADIOS2

[2] https://github.com/ggerganov/llama.cpp

[3] https://github.com/jzhang38/TinyLlama

As discussed in the original GPT3 paper (https://twitter.com/gneubig/status/1286731711150280705?s=20)

TinyLlama is trying to do that for 1.1B: https://github.com/jzhang38/TinyLlama

As long as we are not at the capacity limit, we will have a few of these 7B beats 13B (or 7B beats 70B) moments.