Merge pull request #91 from pytorch/fix-creator

Fix attribute names (creator -> grad_fn)

Author: chsasank

beginner_source/former_torchies/autograd_tutorial.py

@@ -25,9 +25,9 @@
 There’s one more class which is very important for autograd
 implementation - a ``Function``. ``Variable`` and ``Function`` are
 interconnected and build up an acyclic graph, that encodes a complete
-history of computation. Each variable has a ``.creator`` attribute that
+history of computation. Each variable has a ``.grad_fn`` attribute that
 references a function that has created a function (except for Variables
-created by the user - these have ``None`` as ``.creator``).
+created by the user - these have ``None`` as ``.grad_fn``).
 
 If you want to compute the derivatives, you can call ``.backward()`` on
 a ``Variable``. If ``Variable`` is a scalar (i.e. it holds a one element
@@ -52,7 +52,7 @@
 ###############################################################
 #
 
-print(x.creator)  # we've created x ourselves
+print(x.grad_fn)  # we've created x ourselves
 
 ###############################################################
 # Do an operation of x:
@@ -62,8 +62,8 @@
 
 ###############################################################
 # y was created as a result of an operation,
-# so it has a creator
-print(y.creator)
+# so it has a grad_fn
+print(y.grad_fn)
 
 ###############################################################
 # More operations on y:
@@ -91,7 +91,7 @@
 
 x = Variable(torch.ones(2, 2), requires_grad=True)
 y = x + 2
-y.backward(torch.ones(2, 2), retain_variables=True)
+y.backward(torch.ones(2, 2), retain_graph=True)
 # the retain_variables flag will prevent the internal buffers from being freed
 print(x.grad)
 

beginner_source/nlp/pytorch_tutorial.py

@@ -177,13 +177,13 @@
 print(z.data)
 
 # BUT z knows something extra.
-print(z.creator)
+print(z.grad_fn)
 
 
 ######################################################################
 # So Variables know what created them. z knows that it wasn't read in from
 # a file, it wasn't the result of a multiplication or exponential or
-# whatever. And if you keep following z.creator, you will find yourself at
+# whatever. And if you keep following z.grad_fn, you will find yourself at
 # x and y.
 #
 # But how does that help us compute a gradient?
@@ -192,7 +192,7 @@
 # Lets sum up all the entries in z
 s = z.sum()
 print(s)
-print(s.creator)
+print(s.grad_fn)
 
 
 ######################################################################
@@ -248,15 +248,15 @@
 var_y = autograd.Variable(y)
 # var_z contains enough information to compute gradients, as we saw above
 var_z = var_x + var_y
-print(var_z.creator)
+print(var_z.grad_fn)
 
 var_z_data = var_z.data  # Get the wrapped Tensor object out of var_z...
 # Re-wrap the tensor in a new variable
 new_var_z = autograd.Variable(var_z_data)
 
 # ... does new_var_z have information to backprop to x and y?
 # NO!
-print(new_var_z.creator)
+print(new_var_z.grad_fn)
 # And how could it?  We yanked the tensor out of var_z (that is
 # what var_z.data is).  This tensor doesn't know anything about
 # how it was computed.  We pass it into new_var_z, and this is all the