Hi, @borodadada

I apologize for the delay in my response and thank you for bringing this issue to our attention and as far I know to avoid memory leak you'll have to use tf.tidy which executes the provided function fn and after it is executed, cleans up all intermediate tensors allocated by fn except those returned by fn. fn must not return a Promise (async functions not allowed). The returned result can be a complex object.

Using this method helps avoid memory leaks. In general, wrap calls to operations in tf.tidy() for automatic memory cleanup.

NOTE: Variables do not get cleaned up when inside a tidy(). If you want to dispose variables, please use tf.disposeVariables() or call dispose() directly on variables please refer tf.dispose.

You can also use tf.memory which returns memory info at the current time in the program.

Could you please give it try after adding tf.tidy and tf.dispose in your code and see memory leak is happening or not ?

If I have missed something here please let me know.

Thank you for your cooperation and patience.

I don’t understand the principle of a memory leak, all the algorithm needs is to change the coefficients and then feedback and comparison of the result, it should work endlessly without a memory leak.
What you wrote has nothing to do with the crash of the program, because the code is as simple as possible and there is nothing in it except the fit function, which crashes.
Or I don't understand something.

You have to dispose the xs and ys after the fit step. Otherwise tfjs creates new tensors in every loop step. They fill up the memory with each step if you don't dispose them.

using my example, can you show how it should be?
the crash process occurs when the fit function is executed, there is no loop, the data was declared once and after that the learning process started

it should be like this

let xs = tf.tensor2d( a );
let ys = tf.tensor2d( b );

await model.fit(xs, ys, {
        epochs: 50000000,
        shuffle: false,
        verbose: 0,
        callbacks:{
            onTrainBegin: ()=>{
                console.log('start')
            },
            onTrainEnd: ()=>{
                console.log('done')
            },
            onEpochEnd: async (epoch, logs)=>{
                if( epoch % 100000 === 0 )
                    console.log(epoch, logs.loss)
            }
        }
})

xs.dispose();
ys.dispose();

This way the tensors get unusable and are freed by tfjs.

By the way that doesn't mean that there isn't any other memory leak. I stumbled across your comment because I'm also hunting a memory issue. But disposing unused tensors will at least wipe out one possible reason.

I am writing to you about this, that it has not reached this point
The program crashes on the - model.fit

await model.fit(xs, ys, {
        epochs: 50000000,
        shuffle: false,
        verbose: 0,
        callbacks:{
            onTrainBegin: ()=>{
                console.log('start')
            },
            onTrainEnd: ()=>{
                console.log('done')
            },
            onEpochEnd: async (epoch, logs)=>{
                if( epoch % 100000 === 0 )
                    console.log(epoch, logs.loss)
            }
        }
})

this part of the code doesn't work because it should fire after the fit function

xs.dispose();
ys.dispose();

if you have the opportunity to run the code, you will see everything for yourself

Now I’ll run the test with your amendments, I’ll write a little later

Oh sorry, my fault. I didn't recognize the amount of epochs. Then you're right and it looks like some internal problem. I'll try it out and see what happens.

Thank you, I'll wait for the result, this problem is bothering me a lot