Lines Matching refs:block
65 block = fb.FullFB(lc.LayerCollection(), params)
66 block.register_additional_minibatch(32)
68 self.assertAllEqual(params, block.tensors_to_compute_grads())
74 block = fb.FullFB(lc.LayerCollection(), params)
75 block.register_additional_minibatch(32)
77 self.assertAllEqual(params, block.tensors_to_compute_grads())
83 block = fb.FullFB(lc.LayerCollection(), params)
84 block.register_additional_minibatch(32)
87 block.instantiate_factors(grads, 0.5)
93 block = fb.FullFB(lc.LayerCollection(), params)
94 block.register_additional_minibatch(32)
96 block.instantiate_factors((grads,), 0.5)
100 sess.run(block._factor.make_inverse_update_ops())
103 output = block.multiply_inverse(vector)
111 block = fb.FullFB(lc.LayerCollection(), params)
112 block.register_additional_minibatch(32)
114 block.instantiate_factors((grads,), 0.5)
118 sess.run(block._factor.make_inverse_update_ops())
121 output = block.multiply_inverse(vector)
129 block = fb.FullFB(lc.LayerCollection(), params)
130 block.register_additional_minibatch(32)
133 block.instantiate_factors((grads,), damping)
136 sess.run(state_ops.assign(block._factor._cov, _make_psd(3)))
137 sess.run(block._factor.make_inverse_update_ops())
141 output = block.multiply_inverse(vector)
144 full = sess.run(block.full_fisher_block())
156 block = fb.NaiveDiagonalFB(lc.LayerCollection(), params)
157 block.register_additional_minibatch(32)
159 self.assertAllEqual(params, block.tensors_to_compute_grads())
165 block = fb.NaiveDiagonalFB(lc.LayerCollection(), params)
166 block.register_additional_minibatch(32)
168 self.assertAllEqual(params, block.tensors_to_compute_grads())
174 block = fb.NaiveDiagonalFB(lc.LayerCollection(), params)
175 block.register_additional_minibatch(32)
178 block.instantiate_factors(grads, 0.5)
184 block = fb.NaiveDiagonalFB(lc.LayerCollection(), params)
185 block.register_additional_minibatch(32)
187 block.instantiate_factors((grads,), 0.5)
191 sess.run(block._factor.make_inverse_update_ops())
194 output = block.multiply_inverse(vector)
202 block = fb.NaiveDiagonalFB(lc.LayerCollection(), params)
203 block.register_additional_minibatch(32)
205 block.instantiate_factors((grads,), 0.5)
209 sess.run(block._factor.make_inverse_update_ops())
211 output = block.multiply_inverse(vector)
219 block = fb.NaiveDiagonalFB(lc.LayerCollection(), params)
220 block.register_additional_minibatch(32)
223 block.instantiate_factors((grads,), damping)
226 sess.run(state_ops.assign(block._factor._cov, cov))
227 sess.run(block._factor.make_inverse_update_ops())
231 output = block.multiply_inverse(vector)
234 full = sess.run(block.full_fisher_block())
364 block = fb.FullyConnectedDiagonalFB(
367 block.register_additional_minibatch(i, o)
369 block.instantiate_factors((output_grads,), damping=0.0)
372 sess.run(block._factor.make_covariance_update_op(0.0))
373 multiply_result = sess.run(block.multiply(params))
374 multiply_inverse_result = sess.run(block.multiply_inverse(params))
385 # Create a Fisher Block.
387 block = fb.EmbeddingKFACFB(lc.LayerCollection(), vocab_size)
392 block.register_additional_minibatch(inputs, outputs)
397 block.instantiate_factors(([grads],), damping)
403 # Create a Fisher Block.
405 block = fb.EmbeddingKFACFB(lc.LayerCollection(), vocab_size)
410 block.register_additional_minibatch(inputs, outputs)
415 block.instantiate_factors(([grads],), damping)
425 result = block.multiply_inverse(sparse_vector)
426 expected_result = linalg_ops.matrix_solve(block.full_fisher_block(),
445 block = fb.FullyConnectedKFACBasicFB(lc.LayerCollection())
446 block.register_additional_minibatch(inputs, outputs)
448 self.assertAllEqual([outputs], block.tensors_to_compute_grads())
455 block = fb.FullyConnectedKFACBasicFB(lc.LayerCollection(), has_bias=True)
456 block.register_additional_minibatch(inputs, outputs)
459 block.instantiate_factors(([grads],), 0.5)
466 block = fb.FullyConnectedKFACBasicFB(lc.LayerCollection(), has_bias=False)
467 block.register_additional_minibatch(inputs, outputs)
470 block.instantiate_factors(([grads],), 0.5)
477 block = fb.FullyConnectedKFACBasicFB(lc.LayerCollection(), has_bias=False)
478 block.register_additional_minibatch(inputs, outputs)
480 block.instantiate_factors(([grads],), 0.5)
484 sess.run(block._input_factor.make_inverse_update_ops())
485 sess.run(block._output_factor.make_inverse_update_ops())
490 output = block.multiply_inverse((array_ops.constant(vector[0]),
503 block = fb.FullyConnectedKFACBasicFB(lc.LayerCollection(), has_bias=False)
504 block.register_additional_minibatch(inputs, outputs)
506 block.instantiate_factors(([grads],), 0.5)
510 sess.run(block._input_factor.make_inverse_update_ops())
511 sess.run(block._output_factor.make_inverse_update_ops())
514 output = block.multiply_inverse(array_ops.constant(vector))
526 block = fb.FullyConnectedKFACBasicFB(lc.LayerCollection(), has_bias=False)
527 block.register_additional_minibatch(inputs, outputs)
530 block.instantiate_factors(([grads],), damping)
532 sess.run(state_ops.assign(block._input_factor._cov, _make_psd(3)))
533 sess.run(state_ops.assign(block._output_factor._cov, _make_psd(2)))
534 sess.run(block._input_factor.make_inverse_update_ops())
535 sess.run(block._output_factor.make_inverse_update_ops())
539 output = block.multiply_inverse(vector)
542 full = sess.run(block.full_fisher_block())
715 block = fb.ConvDiagonalFB(
718 block.register_additional_minibatch(i, o)
720 block.instantiate_factors((output_grads,), damping=0.0)
723 sess.run(block._factor.make_covariance_update_op(0.0))
724 multiply_result = sess.run(block.multiply(params))
725 multiply_inverse_result = sess.run(block.multiply_inverse(params))
741 block = fb.ConvKFCBasicFB(lc.LayerCollection(), params, [1, 1, 1], 'SAME')
742 block.register_additional_minibatch(inputs, outputs)
744 self.assertAllEqual([outputs], block.tensors_to_compute_grads())
758 block = fb.ConvKFCBasicFB(lc.LayerCollection(), params, (1, 1, 1, 1),
760 block.register_additional_minibatch(inputs, outputs)
762 block.instantiate_factors(([grads],), 0.5)
766 sess.run(block._input_factor.make_inverse_update_ops())
767 sess.run(block._output_factor.make_inverse_update_ops())
771 output = block.multiply_inverse((array_ops.constant(vector[0]),
784 block = fb.ConvKFCBasicFB(lc.LayerCollection(), params, (1, 1, 1, 1),
786 block.register_additional_minibatch(inputs, outputs)
787 self.assertFalse(block._has_bias)
789 block.instantiate_factors(([grads],), 0.5)
793 sess.run(block._input_factor.make_inverse_update_ops())
794 sess.run(block._output_factor.make_inverse_update_ops())
797 output = block.multiply_inverse(array_ops.constant(vector))
807 block = fb.ConvKFCBasicFB(lc.LayerCollection(), params, (1, 1, 1, 1),
809 block.register_additional_minibatch(inputs, outputs)
810 self.assertTrue(block._has_bias)
812 block.instantiate_factors(([grads],), 0.5)
816 sess.run(block._input_factor.make_inverse_update_ops())
817 sess.run(block._output_factor.make_inverse_update_ops())
820 output = block.multiply_inverse(array_ops.constant(vector))
830 block = fb.ConvKFCBasicFB(lc.LayerCollection(), params, (1, 1, 1, 1),
832 block.register_additional_minibatch(inputs, outputs)
835 block.instantiate_factors(([grads],), damping)
837 sess.run(state_ops.assign(block._input_factor._cov, _make_psd(8)))
838 sess.run(state_ops.assign(block._output_factor._cov, _make_psd(2)))
839 sess.run(block._input_factor.make_inverse_update_ops())
840 sess.run(block._output_factor.make_inverse_update_ops())
844 output = block.multiply_inverse(vector)
847 full = sess.run(block.full_fisher_block())
860 block = fb.FullyConnectedSeriesFB(
862 self.assertAllEqual([outputs], block.tensors_to_compute_grads())
869 block = fb.FullyConnectedSeriesFB(
875 block.instantiate_factors(((grads,),), 0.5)
882 block = fb.FullyConnectedSeriesFB(
888 block.instantiate_factors(((grads,),), 0.5)
