updating parameters in a batch

[miangoleh]

I am trying to only perform the opt.step() after accumulating grads from a few different samples.

for iteration
  for views
    compute loss
    loss backwards
   opt step

However by probing the opt it seems that gradients are not accumulated and only the first computation is kept. Is there a way to achieve the similar effect as of using batches/mini batches in training neural networks?

[njroussel]

Hi @miangoleh

This should happen by default, if you don't mess with the parameters/optimizers. Here's an example in one of our tutorials: https://mitsuba.readthedocs.io/en/stable/src/inverse_rendering/radiance_field_reconstruction.html#Optimization

[miangoleh]

I have a very simple scene with a mesh and envmap. I am optimizing the "scale" parameter of an environment map. When I tried printing the grads after each loss.backward call with {dr.ravel(dr.grad(opt[k]))} I was expecting the grad values to change each time (accumulate) but the first computed gradient stays the same untill opt.step is called.

I noticed however the optimization seems to be fine! (The results are very similar to the case where opt.step is called after each loss.backward).

for it in tqdm(range(args.niters), desc="Optimization Iterations"):
      inner_tqdm = tqdm(range(nviews), desc="Per-view Loss", leave=False)
      for view_idx in inner_tqdm:
          # render
          rendered = mi.render(scene, params=scene_params, sensor=view_idx, spp=args.opt_spp, seed=it)
          
          # reference 
          ref_image, ref_mask = dataset.get_reference_image(view_idx)
          ref_mask = np.stack([ref_mask]*3, axis=-1)

          # convert to mitsuba
          ref_image_mi = mi.TensorXf(ref_image)
          ref_mask_mi = mi.TensorXf(ref_mask)

          loss = l1loss(rendered, ref_image_mi, ref_mask_mi)

          inner_tqdm.set_description(f"(it:{it} view:{view_idx}) loss: {np.array(loss):.4f}")
          dr.backward(loss)
     opt.step()
     scene_params.update(opt)

[njroussel]

That sounds like a bug, could you provide us a with a small reproducer ?

[miangoleh]

It seems to happen when I am optimizing a latent_variable or geometry optimization as in "u" parameter of the LargeStep algorithm.

For example I am trying to optimize the radiance of an area light. When I directly use the scene param key as the parameter gradients are updated after each call to backward. However when I define a latent variable and update the scene params using that the gradients only update after opt.step() is called.

*** I am using "light2.emitter.radiance_value" as latent variable to update scene_param[light2.emitter.radiance.value]

view = 0
light1.emitter.radiance_value, grads: [-0.0224826]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [-0.00175828]                                                                                                                                                                                                                                                                             

loss.backward is called
view = 1
light1.emitter.radiance_value, grads: [-0.0224826]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [-0.00175828]                                                                                                                                                                                                                                                                             

loss.backward is called
view = 2
light1.emitter.radiance_value, grads: [-0.0224826]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [-0.00175828]                                                                                                                                                                                                                                                                             

loss.backward is called
view = 3
light1.emitter.radiance_value, grads: [-0.0224826]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [-0.00175828]                                                                                                                                                                                                                                                                             

loss.backward is called
view = 4
light1.emitter.radiance_value, grads: [-0.0224826]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [-0.00175828]                                                                                                                                                                                                                                                                             

loss.backward is called
view = 5
light1.emitter.radiance_value, grads: [-0.0224826]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [-0.00175828]                                                                                                                                                                                                                                                                             

loss.backward is called                                                                                                                                                                                                                                                                         
opt.step() is called

view = 6
light1.emitter.radiance_value, grads: [0.00861032]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [0.0216234]         

loss.backward is called
view = 7                                                                                                                                                                                                                                                                      
light1.emitter.radiance_value, grads: [0.00861032]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [0.0216234]   

loss.backward is called
view = 8                                                                                                                                                                                                                                                                            
light1.emitter.radiance_value, grads: [0.00861032]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [0.0216234]        

loss.backward is called
view = 9                                                                                                                                                                                                                                                                       
light1.emitter.radiance_value, grads: [0.00861032]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [0.0216234]     

loss.backward is called
view = 10                                                                                                                                                                                                                                                                          
light1.emitter.radiance_value, grads: [0.00861032]                                                                                                                                                                                                                                                                              
light2.emitter.radiance_value, grads: [0.0216234]  

....