Zettelkasten | An implementation of a Zettelkasten for terminals | Plugin library

Try:

Your function LoginWindow() is another component inside function Auth(props:IProps). All your setStates happens in your parent component as you type. In React any change in the Parent component will trigger a re-render of child components.

If you really wanted to keep a separate child component, you had to pass all those set methods you are using in LoginWindow as props. Then you will have to wrap your methods that are passed into your child component in a useCallback so every time your parent re-renders due to the state update your functions will not regenerate as new objects. That's a path you don't need for such a small component I believe.

I don't know why you are using a component inside another component in the wrong way. Why don't you directly return your JSX like,

If you install DynamicPageList3, you can use {{#dpl: linksfrom = {{FULLPAGENAME}} }}.

With Scribunto, you can define Module:Links with inner function:

You are aware that the training is non-deterministic anyway, right? Did you try to rerun each case a couple of times? Also the baseline? Maybe the baseline itself is an outlier.

Also, changing the computation graph, even if this will be a no-op, can also have an effect. Unfortunately it can be sensitive.

You might want to try setting deterministic_train = True in your config. This might make it a bit more deterministic. Maybe you get the same result then in each of your cases. This might make it a bit slower, though.

The order of parameter initialization might be different as well. The order depends on the order of when the layers are created. Maybe compare that in the log. It is always the same random initializer, but would use a different seed offset then, so you would get another initialization. You could play around by explicitly setting random_seed in the config, and see how much variance you get by that. Maybe all these values are within this range.

For a more in-depth debugging, you could really compare directly the computation graph (in TensorBoard). Maybe there is a difference which you did not notice. Also, maybe make a diff on the log output during net construction, for the case pretrain vs baseline. There should be no diff.

(As this is maybe a mistake, for now only as a side comment: Of course, different RETURNN versions might have some different behavior. So this should be the same.)

Another note: You do not need this tf.reduce_sum in your loss. Actually that might not be such a good idea. Now it will forget about number of frames, and number of seqs. If you just do not use tf.reduce_sum, it should also work, but now you get the correct normalization.

Another note: Instead of your lambda, you can also use loss_scale, which is simpler, and you get the original value in the log.

So basically, you could write it this way: