Capture your gear for free with TONEZONE3000

[DLC86]

First of all, thank you guys at TZ3000 for this awesome project! The incredibly fast parallel training of multiple output clips is so much better than local training and I'm saying that as someone with an RTX 4090 GPU.

Here would be my list of wishes:

• Bulk Downloading: Please add a download button to the "Your Tones" page so that we can mark all the trained models that we want to download at once. Maybe I'm missing something here, but so far, I have to click on every model separately and only then am I able to download it.
• Bulk Uploading: It should work the same way as choosing many different output clips for the local trainer, where you can define a core set of descriptions and then start the training for all of them.
• Multi Architecture Training: I usually train standard and complex models for each output clip and I'd love to have that ability on TZ3000 as well.
• Basic Parametric Models: Since most guitar pedals and poweramps have three or less knobs, it would be nice to train them as parametric models instead of sets of 50+ captures.
• Hyper Accuracy Mode: A couple of guys have already mentioned it here and in my private messages that they'd like to try the hyper accuracy mode for their own captures. I've modified the core.py file to include a new architecture called "complex". Here it is: https://paste.ofcode.org/36GiiSFkJrSTkySVjCYnEM9

Since I've only created this code file today, I'm not sure if the code above uses the correct lr and lr_decay values (I used to change them in the def train(...) section) for the complex training. I'd be grateful If an experienced python programmer could chime in and confirm if the following lines work as intended in the code that I posted above:

    if architecture == Architecture.COMPLEX:
        lr = 0.001
        lr_decay = 0.001

These lines are integrated in the def train() section (row 1418 to 1420). The intention behind this if statement is that lr should be 0.004 and lr_decay should be 0.007 (standard values) for any architecture, unless it's the complex one, then both variables need to be set to 0.001. This core.py file can be added to the following directory in case the github repository was installed via the pip install command via anaconda prompt:

C:\Users\ ... \anaconda3\Lib\site-packages\nam\train

Same goes for other local installation methods, simply open the nam\train folder, copy the code from the website above, create a new text file, paste the code in there, save it as core.py and copy the core.py file into the nam\train directory.

You guys at TZ3000 only have to include this section where the complex architecture is defined, as the lr and lr_decay variables are already exposed to the user:

        Architecture.COMPLEX: {
            "layers_configs": [
                {
                    "input_size": 1,
                    "condition_size": 1,
                    "channels": 32,
                    "head_size": 8,
                    "kernel_size": 3,
                    "dilations": [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512],
                    "activation": "Tanh",
                    "gated": False,
                    "head_bias": False,
                },
                {
                    "condition_size": 1,
                    "input_size": 32,
                    "channels": 8,
                    "head_size": 1,
                    "kernel_size": 3,
                    "dilations": [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512],
                    "activation": "Tanh",
                    "gated": False,
                    "head_bias": True,
                },
            ],
            "head_scale": 0.02,
        },

So far, I've settled for 1200 epochs for the hyper accuracy training, mainly because I preferred models with longer training times, but this is based on an experiment with two output clips and various epoch counts (800, 1000, 1200, 1400, 1600). It's not very scientific, I know, so maybe 1000 epochs could be good enough.

Regarding this, I just discovered there's a russian guy on the NAM facebook group that has done quite a bit of experimentation on the architecture and he basically found a configuration that makes standard models almost as accurate as hyper accuracy models with a modest cpu increase (over standard models). Here's one of his posts about this: https://www.facebook.com/share/p/1BT4B7zSKq/

He also made a test tone file that includes some high frequency sine sweeps and that seems to improve the aliasing performance quite a bit: https://www.facebook.com/share/p/18EKHpbsQq/

I just tested the models he shared and here's the impressive result:

"classic input"


"super input" + x standard architecture

 

[DLC86]

Did some more testing by making a capture with this "super input" test tone and here's the result:

Standard capture

"Super input" capture

 

[laxu]

Regarding this, I just discovered there's a russian guy on the NAM facebook group that has done quite a bit of experimentation on the architecture and he basically found a configuration that makes standard models almost as accurate as hyper accuracy models with a modest cpu increase (over standard models). Here's one of his posts about this: https://www.facebook.com/share/p/1BT4B7zSKq/

He also made a test tone file that includes some high frequency sine sweeps and that seems to improve the aliasing performance quite a bit: https://www.facebook.com/share/p/18EKHpbsQq/

I just tested the models he shared and here's the impressive result:

"classic input"
View attachment 37334

"super input" + x standard architecture
View attachment 37333

Could you post the input file? It's behind a FB group you'd have to join so you can't see the posts.

 

[DLC86]

Could you post the input file? It's behind a FB group you'd have to join so you can't see the posts.

But those guys are testing a new version they made under my suggestion, with sweeps that go up to 24 kHz to train the model to reduce aliasing when the signal goes above 20 kHz (you can see in the first graphs I posted aliasing becomes quite higher when the sweep goes above 20 kHz).

Here's the result with this new file and x std architecture:



Compare it to this:

"super input" + x standard architecture

 

[laxu]

But those guys are testing a new version they made under my suggestion, with sweeps that go up to 24 kHz to train the model to reduce aliasing when the signal goes above 20 kHz (you can see in the first graphs I posted it becomes quite higher when the sweep goes above 20 kHz)

Thanks! Please post the new version too when it lands. I'd love to give it a spin later.

For those who want to get the file, use the "pop out" button in the corner and then it opens up the Google Drive which lets you download it. Automatic media embeds can be dumb.

 

[DLC86]

Some more graphs, this time made with the same technique Cliff usually uses to show aliasing: RTA of a -12 dBFS sine sweep ranging from 9 to 11 kHz

Standard v3.0.0 input


Super input with standard architecture


Super input with xSTD architecture


New "40K" input with xSTD architecture

 

[laxu]

That's a pretty impressive improvement overall. How audible do you feel it actually is?

 

[DLC86]

That's a pretty impressive improvement overall. How audible do you feel it actually is?

I only had the chance to try the super input with standard architecture on one of my captures yesterday and the difference is subtle but definitely hearable, more intelligible overall.
Still haven't tried the models they shared but here they are if you wanna try them yourself: https://drive.google.com/drive/folders/1Nrj4xCBnLMYepBBjbNvsP76BVhF4HEnx

PS: "REAMP classic input.nam" is the standard nam model, "superinputHIGHGAIN.nam" is super input with standard architecture and "super xSTD etc." is super input + xSTD architecture

 

[2dor]

The aliasing thing is great as I know a lot of folks complain about it.

I ran my own tests on training with the included sweeps inside the training signal and my conclusion is for pure guitar playing, I have a hard time telling a difference between the vanilla model & the one trained with the "anti aliasing" enhancement.

It might be a great achievement for folks who mix with several instances where it's said that aliasing can pile up & spoil the mix.

Also, the tricky thing with custom, larger architectures is that, while it allows nerds like me & others to milk the most accuracy from reamps, it locks a lot of people out of playing those models. You really need good hardware to run large models in real-time + those won't run on the Dimehead NAM Player so yeah.

 

[DLC86]

The aliasing thing is great as I know a lot of folks complain about it.

I ran my own tests on training with the included sweeps inside the training signal and my conclusion is for pure guitar playing, I have a hard time telling a difference between the vanilla model & the one trained with the "anti aliasing" enhancement.

It might be a great achievement for folks who mix with several instances where it's said that aliasing can pile up & spoil the mix.

Also, the tricky thing with custom, larger architectures is that, while it allows nerds like me & others to milk the most accuracy from reamps, it locks a lot of people out of playing those models. You really need good hardware to run large models in real-time + those won't run on the Dimehead NAM Player so yeah.

The nice thing about this is that it's an almost "free" improvement cpu wise, the super input itself doesn't produce heavier models, the xSTD architecture increases the cpu usage by only about 10% but produces an accuracy comparable to the "HyperAccurate" architecture (and further reduces aliasing when paired with the super input).

How hearable this is also depends on the amount of gain you use obviously.

 

[laxu]

Can you "downgrade" the models? E.g if you were to upload a high accuracy model to a modeler capable of only running a lighter weight one, will it just refuse to accept it or does it run but sound a bit worse?

 

[2dor]

Can you "downgrade" the models? E.g if you were to upload a high accuracy model to a modeler capable of only running a lighter weight one, will it just refuse to accept it or does it run but sound a bit worse?

No; it won't scale down the models. You'd need to re-train using the vanilla standard architecture (at least for the time being anyway).

 

[2dor]

The nice thing about this is that it's an almost "free" improvement cpu wise, the super input itself doesn't produce heavier models, the xSTD architecture increases the cpu usage by only about 10% but produces an accuracy comparable to the "HyperAccurate" architecture (and further reduces aliasing when paired with the super input).

How hearable this is also depends on the amount of gain you use obviously.

10% increase on what machine / CPU? That's the thing.
Don't get me wrong, I'm VERY happy to see improvements but I've also been in touch with folks who felt they were missing out a lot when I issued larger models.
I wonder about the xSTD architecture if it introduces additional latency to the overall model. IIRC having looked at the "core.py" file shared on the FB group, it had several layers (not just 2 like the vanilla network has) stacked on top; those usually introduce some latency but they might have been optimized to not do so.

 

[DLC86]

10% increase on what machine / CPU? That's the thing

10% upon the standard architecture. If standard is 100%, xSTD is 110%

EDIT: it's actually a bit less than 10%

 

[yek]

Probably not wise of me to discuss this publicly. I've deleted my previous post.

 

[HomespunEffects]

This song stinks.

 

[MirrorProfiles]

2 things are quite interesting:

NAM is getting people involved in guitar amp modelling that absolutely would not have the means to be making white box models (as well as some who were already developing software). With so much more potentially good quality modelling out there, it really raises the stakes for everyone else to keep improving and offering something better.

IIRC, ToneX had worse aliasing performance than NAM did but given the open source nature of NAM it's quite achievable to make these improvements in accuracy/performance without roadblocks. I'd never had issues with aliasing and NAM but it's good to know that things are still improving. I haven't made ToneX models in some time, because making models is slow, there's no cloud training, applying metadata is tedious, the app sucks, the quality is worse. NAM is just racing away with new tools and improvements.

 

[HomespunEffects]

I built something! It's called TONEZONE3000 (https://tonezone3000.com) and it's built on top of Nueral Amp Modeler (NAM) the open source project by Steve Atkinson. With this tool you can capture a digital model of your amps, pedals and signal chains for free.

Training/capturing tones is hard - modeling pedals are expensive, colab is frustrating/expensive, local set ups are daunting. My goal is to change that by making training simple, free and accessible. With TONEZONE3000, you can easily train models online, fast and free, with a slick UX.

Here are a few reasons why I've enjoyed TONEZONE3000 coming from colab / my local setup:

• Super fast and totally free training on RTX 4090s (no longer consuming my own resources)
• Dead simple workflow
• Cloud-based, so you can start training and close your computer
• Train multiple models concurrently
• An organized library of your tones
• Easily share your models with friends
• Preview your models with a range of DIs

Btw, you can train models with just a Dry/Wet Pair (DI and its matching stem). This has enabled me to create tones models from sessions I recorded years ago!

I’m sharing the beta to you now, and I'd love for you to train a model (or ten!) and share your feedback and models

Here's a capture of a Klon clone I built with my buddy: https://www.tonezone3000.com/tonezone3000/tones/klon-centaur-silver-clone-130

I have no idea how to train a NAM model but I’m interested. Do the models work in other things like TONEX or Quad Cortex?

Are there any ways to donate, either money or processing time?

 

[2dor]

I have no idea how to train a NAM model but I’m interested. Do the models work in other things like TONEX or Quad Cortex?

Are there any ways to donate, either money or processing time?

The only hardware platform you can run them natively, for now, is the Dimehead NAM Player.

It's completely free of charge & open source; no way to donate $$ to the creator / dev (Steve) but you can help donate to the platform which was developed to host profiles for people to use (https://tonehunt.org/).

 

[HomespunEffects]

I keep getting "Application error: a client-side exception has occurred (see the browser console for more information)." I'll try another browser.