wehub-resource-sync
256 lines
13 KiB
Python
256 lines
13 KiB
Python
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
# ==============================================================================
|
|
"""Functional test for GradientDescent."""
|
|
|
|
from tensorflow.python.framework import constant_op
|
|
from tensorflow.python.framework import dtypes
|
|
from tensorflow.python.framework import indexed_slices
|
|
from tensorflow.python.framework import ops
|
|
from tensorflow.python.ops import embedding_ops
|
|
from tensorflow.python.ops import math_ops
|
|
from tensorflow.python.ops import resource_variable_ops
|
|
from tensorflow.python.ops import resources
|
|
from tensorflow.python.ops import variables
|
|
from tensorflow.python.platform import test
|
|
from tensorflow.python.training import gradient_descent
|
|
|
|
|
|
class GradientDescentOptimizerTest(test.TestCase):
|
|
|
|
def testBasic(self):
|
|
for dtype in [dtypes.half, dtypes.float32, dtypes.float64]:
|
|
# train.GradientDescentOptimizer is V1 only API.
|
|
with ops.Graph().as_default(), self.cached_session():
|
|
var0 = variables.Variable([1.0, 2.0], dtype=dtype)
|
|
var1 = variables.Variable([3.0, 4.0], dtype=dtype)
|
|
grads0 = constant_op.constant([0.1, 0.1], dtype=dtype)
|
|
grads1 = constant_op.constant([0.01, 0.01], dtype=dtype)
|
|
optimizer = gradient_descent.GradientDescentOptimizer(3.0)
|
|
sgd_op = optimizer.apply_gradients(
|
|
zip([grads0, grads1], [var0, var1]))
|
|
self.evaluate(variables.global_variables_initializer())
|
|
# Fetch params to validate initial values
|
|
self.assertAllCloseAccordingToType([1.0, 2.0], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0, 4.0], self.evaluate(var1))
|
|
# Run 1 step of sgd
|
|
sgd_op.run()
|
|
# Validate updated params
|
|
self.assertAllCloseAccordingToType([1.0 - 3.0 * 0.1, 2.0 - 3.0 * 0.1],
|
|
self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0 - 3.0 * 0.01, 4.0 - 3.0 * 0.01],
|
|
self.evaluate(var1))
|
|
self.assertEqual(0, len(optimizer.variables()))
|
|
|
|
def testBasicResourceVariable(self):
|
|
for dtype in [dtypes.half, dtypes.float32, dtypes.float64]:
|
|
# train.GradientDescentOptimizer is V1 only API.
|
|
with ops.Graph().as_default(), self.cached_session():
|
|
var0 = resource_variable_ops.ResourceVariable([1.0, 2.0], dtype=dtype)
|
|
var1 = resource_variable_ops.ResourceVariable([3.0, 4.0], dtype=dtype)
|
|
grads0 = constant_op.constant([0.1, 0.1], dtype=dtype)
|
|
grads1 = constant_op.constant([0.01, 0.01], dtype=dtype)
|
|
sgd_op = gradient_descent.GradientDescentOptimizer(3.0).apply_gradients(
|
|
zip([grads0, grads1], [var0, var1]))
|
|
# TODO(apassos) calling initialize_resources on all resources here
|
|
# doesn't work because the sessions and graph are reused across unit
|
|
# tests and this would mean trying to reinitialize variables. Figure out
|
|
# a long-term solution for this.
|
|
resources.initialize_resources([var0, var1]).run()
|
|
# Fetch params to validate initial values
|
|
self.assertAllCloseAccordingToType([1.0, 2.0], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0, 4.0], self.evaluate(var1))
|
|
# Run 1 step of sgd
|
|
sgd_op.run()
|
|
# Validate updated params
|
|
self.assertAllCloseAccordingToType([1.0 - 3.0 * 0.1, 2.0 - 3.0 * 0.1],
|
|
self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0 - 3.0 * 0.01, 4.0 - 3.0 * 0.01],
|
|
self.evaluate(var1))
|
|
|
|
def testBasicCallableParams(self):
|
|
for dtype in [dtypes.half, dtypes.float32, dtypes.float64]:
|
|
# train.GradientDescentOptimizer is V1 only API.
|
|
with ops.Graph().as_default(), self.cached_session():
|
|
var0 = resource_variable_ops.ResourceVariable([1.0, 2.0], dtype=dtype)
|
|
var1 = resource_variable_ops.ResourceVariable([3.0, 4.0], dtype=dtype)
|
|
grads0 = constant_op.constant([0.1, 0.1], dtype=dtype)
|
|
grads1 = constant_op.constant([0.01, 0.01], dtype=dtype)
|
|
lr = lambda: 3.0
|
|
sgd_op = gradient_descent.GradientDescentOptimizer(lr).apply_gradients(
|
|
zip([grads0, grads1], [var0, var1]))
|
|
# TODO(apassos) calling initialize_resources on all resources here
|
|
# doesn't work because the sessions and graph are reused across unit
|
|
# tests and this would mean trying to reinitialize variables. Figure out
|
|
# a long-term solution for this.
|
|
resources.initialize_resources([var0, var1]).run()
|
|
# Fetch params to validate initial values
|
|
self.assertAllCloseAccordingToType([1.0, 2.0], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0, 4.0], self.evaluate(var1))
|
|
# Run 1 step of sgd
|
|
sgd_op.run()
|
|
# Validate updated params
|
|
self.assertAllCloseAccordingToType([1.0 - 3.0 * 0.1, 2.0 - 3.0 * 0.1],
|
|
self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0 - 3.0 * 0.01, 4.0 - 3.0 * 0.01],
|
|
self.evaluate(var1))
|
|
|
|
def testMinimizeResourceVariable(self):
|
|
for dtype in [dtypes.half, dtypes.float32, dtypes.float64]:
|
|
# train.GradientDescentOptimizer is V1 only API.
|
|
with ops.Graph().as_default(), self.cached_session():
|
|
var0 = resource_variable_ops.ResourceVariable([[1.0, 2.0]], dtype=dtype)
|
|
var1 = resource_variable_ops.ResourceVariable([3.0], dtype=dtype)
|
|
x = constant_op.constant([[4.0], [5.0]], dtype=dtype)
|
|
pred = math_ops.matmul(var0, x) + var1
|
|
loss = pred * pred
|
|
sgd_op = gradient_descent.GradientDescentOptimizer(1.0).minimize(loss)
|
|
# TODO(apassos) calling initialize_resources on all resources here
|
|
# doesn't work because the sessions and graph are reused across unit
|
|
# tests and this would mean trying to reinitialize variables. Figure out
|
|
# a long-term solution for this.
|
|
resources.initialize_resources([var0, var1]).run()
|
|
# Fetch params to validate initial values
|
|
self.assertAllCloseAccordingToType([[1.0, 2.0]], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0], self.evaluate(var1))
|
|
# Run 1 step of sgd
|
|
sgd_op.run()
|
|
# Validate updated params
|
|
np_pred = 1.0 * 4.0 + 2.0 * 5.0 + 3.0
|
|
np_grad = 2 * np_pred
|
|
self.assertAllCloseAccordingToType(
|
|
[[1.0 - np_grad * 4.0, 2.0 - np_grad * 5.0]], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0 - np_grad], self.evaluate(var1))
|
|
|
|
def testMinimizeSparseResourceVariable(self):
|
|
for dtype in [dtypes.half, dtypes.float32, dtypes.float64]:
|
|
# train.GradientDescentOptimizer is V1 only API.
|
|
with ops.Graph().as_default(), self.cached_session():
|
|
var0 = resource_variable_ops.ResourceVariable([[1.0, 2.0]], dtype=dtype)
|
|
var1 = resource_variable_ops.ResourceVariable([3.0], dtype=dtype)
|
|
x = constant_op.constant([[4.0], [5.0]], dtype=dtype)
|
|
pred = math_ops.matmul(embedding_ops.embedding_lookup([var0], [0]), x)
|
|
pred += var1
|
|
loss = pred * pred
|
|
sgd_op = gradient_descent.GradientDescentOptimizer(1.0).minimize(loss)
|
|
# TODO(apassos) calling initialize_resources on all resources here
|
|
# doesn't work because the sessions and graph are reused across unit
|
|
# tests and this would mean trying to reinitialize variables. Figure out
|
|
# a long-term solution for this.
|
|
self.evaluate(variables.global_variables_initializer())
|
|
# Fetch params to validate initial values
|
|
self.assertAllCloseAccordingToType([[1.0, 2.0]], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0], self.evaluate(var1))
|
|
# Run 1 step of sgd
|
|
sgd_op.run()
|
|
# Validate updated params
|
|
np_pred = 1.0 * 4.0 + 2.0 * 5.0 + 3.0
|
|
np_grad = 2 * np_pred
|
|
self.assertAllCloseAccordingToType(
|
|
[[1.0 - np_grad * 4.0, 2.0 - np_grad * 5.0]], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0 - np_grad], self.evaluate(var1))
|
|
|
|
def testTensorLearningRate(self):
|
|
for dtype in [dtypes.half, dtypes.float32, dtypes.float64]:
|
|
# train.GradientDescentOptimizer is V1 only API.
|
|
with ops.Graph().as_default(), self.cached_session():
|
|
var0 = variables.Variable([1.0, 2.0], dtype=dtype)
|
|
var1 = variables.Variable([3.0, 4.0], dtype=dtype)
|
|
grads0 = constant_op.constant([0.1, 0.1], dtype=dtype)
|
|
grads1 = constant_op.constant([0.01, 0.01], dtype=dtype)
|
|
lrate = constant_op.constant(3.0)
|
|
sgd_op = gradient_descent.GradientDescentOptimizer(
|
|
lrate).apply_gradients(zip([grads0, grads1], [var0, var1]))
|
|
self.evaluate(variables.global_variables_initializer())
|
|
# Fetch params to validate initial values
|
|
self.assertAllCloseAccordingToType([1.0, 2.0], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0, 4.0], self.evaluate(var1))
|
|
# Run 1 step of sgd
|
|
sgd_op.run()
|
|
# Validate updated params
|
|
self.assertAllCloseAccordingToType([1.0 - 3.0 * 0.1, 2.0 - 3.0 * 0.1],
|
|
self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0 - 3.0 * 0.01, 4.0 - 3.0 * 0.01],
|
|
self.evaluate(var1))
|
|
|
|
def testGradWrtRef(self):
|
|
for dtype in [dtypes.half, dtypes.float32, dtypes.float64]:
|
|
# train.GradientDescentOptimizer is V1 only API.
|
|
with ops.Graph().as_default(), self.cached_session():
|
|
opt = gradient_descent.GradientDescentOptimizer(3.0)
|
|
values = [1.0, 3.0]
|
|
vars_ = [variables.Variable([v], dtype=dtype) for v in values]
|
|
grads_and_vars = opt.compute_gradients(vars_[0] + vars_[1], vars_)
|
|
self.evaluate(variables.global_variables_initializer())
|
|
for grad, _ in grads_and_vars:
|
|
self.assertAllCloseAccordingToType([1.0], self.evaluate(grad))
|
|
|
|
def testWithGlobalStep(self):
|
|
for dtype in [dtypes.half, dtypes.float32, dtypes.float64]:
|
|
# train.GradientDescentOptimizer is V1 only API.
|
|
with ops.Graph().as_default(), self.cached_session():
|
|
global_step = variables.Variable(0, trainable=False)
|
|
var0 = variables.Variable([1.0, 2.0], dtype=dtype)
|
|
var1 = variables.Variable([3.0, 4.0], dtype=dtype)
|
|
grads0 = constant_op.constant([0.1, 0.1], dtype=dtype)
|
|
grads1 = constant_op.constant([0.01, 0.01], dtype=dtype)
|
|
sgd_op = gradient_descent.GradientDescentOptimizer(3.0).apply_gradients(
|
|
zip([grads0, grads1], [var0, var1]), global_step=global_step)
|
|
self.evaluate(variables.global_variables_initializer())
|
|
# Fetch params to validate initial values
|
|
self.assertAllCloseAccordingToType([1.0, 2.0], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0, 4.0], self.evaluate(var1))
|
|
# Run 1 step of sgd
|
|
sgd_op.run()
|
|
# Validate updated params and global_step
|
|
self.assertAllCloseAccordingToType([1.0 - 3.0 * 0.1, 2.0 - 3.0 * 0.1],
|
|
self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([3.0 - 3.0 * 0.01, 4.0 - 3.0 * 0.01],
|
|
self.evaluate(var1))
|
|
self.assertAllCloseAccordingToType(1, self.evaluate(global_step))
|
|
|
|
def testSparseBasic(self):
|
|
for dtype in [dtypes.half, dtypes.float32, dtypes.float64]:
|
|
# train.GradientDescentOptimizer is V1 only API.
|
|
with ops.Graph().as_default(), self.cached_session():
|
|
var0 = variables.Variable([[1.0], [2.0]], dtype=dtype)
|
|
var1 = variables.Variable([[3.0], [4.0]], dtype=dtype)
|
|
grads0 = indexed_slices.IndexedSlices(
|
|
constant_op.constant(
|
|
[0.1], shape=[1, 1], dtype=dtype),
|
|
constant_op.constant([0]),
|
|
constant_op.constant([2, 1]))
|
|
grads1 = indexed_slices.IndexedSlices(
|
|
constant_op.constant(
|
|
[0.01], shape=[1, 1], dtype=dtype),
|
|
constant_op.constant([1]),
|
|
constant_op.constant([2, 1]))
|
|
sgd_op = gradient_descent.GradientDescentOptimizer(3.0).apply_gradients(
|
|
zip([grads0, grads1], [var0, var1]))
|
|
self.evaluate(variables.global_variables_initializer())
|
|
# Fetch params to validate initial values
|
|
self.assertAllCloseAccordingToType([[1.0], [2.0]], self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([[3.0], [4.0]], self.evaluate(var1))
|
|
# Run 1 step of sgd
|
|
sgd_op.run()
|
|
# Validate updated params
|
|
self.assertAllCloseAccordingToType([[1.0 - 3.0 * 0.1], [2.0]],
|
|
self.evaluate(var0))
|
|
self.assertAllCloseAccordingToType([[3.0], [4.0 - 3.0 * 0.01]],
|
|
self.evaluate(var1))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
test.main()
|