1 # Copyright 2015 The TensorFlow Authors. All Rights Reserved. 2 # 3 # Licensed under the Apache License, Version 2.0 (the "License"); 4 # you may not use this file except in compliance with the License. 5 # You may obtain a copy of the License at 6 # 7 # http://www.apache.org/licenses/LICENSE-2.0 8 # 9 # Unless required by applicable law or agreed to in writing, software 10 # distributed under the License is distributed on an "AS IS" BASIS, 11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 # See the License for the specific language governing permissions and 13 # limitations under the License. 14 # ============================================================================== 15 """Tests for tensorflow.ops.clip_ops.""" 16 17 from __future__ import absolute_import 18 from __future__ import division 19 from __future__ import print_function 20 21 from tensorflow.python.framework import constant_op 22 from tensorflow.python.framework import ops 23 from tensorflow.python.ops import clip_ops 24 from tensorflow.python.platform import test 25 26 27 class ClipTest(test.TestCase): 28 29 # ClipByValue test 30 def testClipByValue(self): 31 with self.test_session(): 32 x = constant_op.constant([-5.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3]) 33 np_ans = [[-4.4, 2.0, 3.0], [4.0, 4.4, 4.4]] 34 clip_value = 4.4 35 ans = clip_ops.clip_by_value(x, -clip_value, clip_value) 36 tf_ans = ans.eval() 37 38 self.assertAllClose(np_ans, tf_ans) 39 40 def testClipByValueBadShape(self): 41 with self.test_session(): 42 x = constant_op.constant([-5.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3, 1]) 43 # Use a nonsensical shape. 44 clip = constant_op.constant([1.0, 2.0]) 45 with self.assertRaises(ValueError): 46 _ = clip_ops.clip_by_value(x, -clip, clip) 47 with self.assertRaises(ValueError): 48 _ = clip_ops.clip_by_value(x, 1.0, clip) 49 50 def testClipByValueNonFinite(self): 51 with self.test_session(): 52 x = constant_op.constant([float('NaN'), float('Inf'), -float('Inf')]) 53 np_ans = [float('NaN'), 4.0, -4.0] 54 clip_value = 4.0 55 ans = clip_ops.clip_by_value(x, -clip_value, clip_value) 56 tf_ans = ans.eval() 57 58 self.assertAllClose(np_ans, tf_ans) 59 60 # ClipByNorm tests 61 def testClipByNormClipped(self): 62 # Norm clipping when clip_norm < 5 63 with self.test_session(): 64 x = constant_op.constant([-3.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 65 # Norm of x = sqrt(3^2 + 4^2) = 5 66 np_ans = [[-2.4, 0.0, 0.0], [3.2, 0.0, 0.0]] 67 clip_norm = 4.0 68 ans = clip_ops.clip_by_norm(x, clip_norm) 69 tf_ans = ans.eval() 70 71 clip_tensor = constant_op.constant(4.0) 72 ans = clip_ops.clip_by_norm(x, clip_norm) 73 tf_ans_tensor = ans.eval() 74 75 self.assertAllClose(np_ans, tf_ans) 76 self.assertAllClose(np_ans, tf_ans_tensor) 77 78 def testClipByNormBadShape(self): 79 with self.test_session(): 80 x = constant_op.constant([-3.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3, 1]) 81 # Use a nonsensical shape. 82 clip = constant_op.constant([1.0, 2.0]) 83 with self.assertRaises(ValueError): 84 _ = clip_ops.clip_by_norm(x, clip) 85 86 def testClipByNormNotClipped(self): 87 # No norm clipping when clip_norm >= 5 88 with self.test_session(): 89 x = constant_op.constant([-3.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 90 # Norm of x = sqrt(3^2 + 4^2) = 5 91 np_ans = [[-3.0, 0.0, 0.0], [4.0, 0.0, 0.0]] 92 clip_norm = 6.0 93 ans = clip_ops.clip_by_norm(x, clip_norm) 94 tf_ans = ans.eval() 95 96 self.assertAllClose(np_ans, tf_ans) 97 98 def testClipByNormZero(self): 99 # No norm clipping when norm = 0 100 with self.test_session(): 101 x = constant_op.constant([0.0, 0.0, 0.0, 0.0, 0.0, 0.0], shape=[2, 3]) 102 # Norm = 0, no changes 103 np_ans = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] 104 clip_norm = 6.0 105 ans = clip_ops.clip_by_norm(x, clip_norm) 106 tf_ans = ans.eval() 107 108 self.assertAllClose(np_ans, tf_ans) 109 110 def testClipByNormClippedWithDim0(self): 111 # Norm clipping when clip_norm < 5 112 with self.test_session(): 113 x = constant_op.constant([-3.0, 0.0, 0.0, 4.0, 0.0, 3.0], shape=[2, 3]) 114 # Norm of x[:, 0] = sqrt(3^2 + 4^2) = 5, x[:, 2] = 3 115 np_ans = [[-2.4, 0.0, 0.0], [3.2, 0.0, 3.0]] 116 clip_norm = 4.0 117 ans = clip_ops.clip_by_norm(x, clip_norm, [0]) 118 tf_ans = ans.eval() 119 120 self.assertAllClose(np_ans, tf_ans) 121 122 def testClipByNormClippedWithDim1(self): 123 # Norm clipping when clip_norm < 5 124 with self.test_session(): 125 x = constant_op.constant([-3.0, 0.0, 0.0, 4.0, 0.0, 3.0], shape=[2, 3]) 126 # Norm of x[0, :] = 3, x[1, :] = sqrt(3^2 + 4^2) = 5 127 np_ans = [[-3.0, 0.0, 0.0], [3.2, 0.0, 2.4]] 128 clip_norm = 4.0 129 ans = clip_ops.clip_by_norm(x, clip_norm, [1]) 130 tf_ans = ans.eval() 131 132 self.assertAllClose(np_ans, tf_ans) 133 134 def testClipByNormNotClippedWithAxes(self): 135 # No norm clipping when clip_norm >= 5 136 with self.test_session(): 137 x = constant_op.constant([-3.0, 0.0, 0.0, 4.0, 0.0, 3.0], shape=[2, 3]) 138 # Norm of x[0, :] = 3, x[1, :] = sqrt(3^2 + 4^2) = 5 139 np_ans = [[-3.0, 0.0, 0.0], [4.0, 0.0, 3.0]] 140 clip_norm = 6.0 141 ans = clip_ops.clip_by_norm(x, clip_norm, [1]) 142 tf_ans = ans.eval() 143 144 self.assertAllClose(np_ans, tf_ans) 145 146 # ClipByGlobalNorm tests 147 def testClipByGlobalNormClipped(self): 148 # Norm clipping when clip_norm < 5 149 with self.test_session(): 150 x0 = constant_op.constant([-2.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 151 x1 = constant_op.constant([1.0, -2.0]) 152 # Global norm of x0 and x1 = sqrt(1 + 4^2 + 2^2 + 2^2) = 5 153 clip_norm = 4.0 154 155 # Answers are the original tensors scaled by 4.0/5.0 156 np_ans_0 = [[-1.6, 0.0, 0.0], [3.2, 0.0, 0.0]] 157 np_ans_1 = [0.8, -1.6] 158 159 ans, norm = clip_ops.clip_by_global_norm((x0, x1), clip_norm) 160 tf_ans_1 = ans[0].eval() 161 tf_ans_2 = ans[1].eval() 162 tf_norm = norm.eval() 163 164 self.assertAllClose(tf_norm, 5.0) 165 self.assertAllClose(np_ans_0, tf_ans_1) 166 self.assertAllClose(np_ans_1, tf_ans_2) 167 168 def testClipByGlobalNormClippedTensor(self): 169 # Norm clipping when clip_norm < 5 170 with self.test_session(): 171 x0 = constant_op.constant([-2.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 172 x1 = constant_op.constant([1.0, -2.0]) 173 # Global norm of x0 and x1 = sqrt(1 + 4^2 + 2^2 + 2^2) = 5 174 clip_norm = constant_op.constant(4.0) 175 176 # Answers are the original tensors scaled by 4.0/5.0 177 np_ans_0 = [[-1.6, 0.0, 0.0], [3.2, 0.0, 0.0]] 178 np_ans_1 = [0.8, -1.6] 179 180 ans, norm = clip_ops.clip_by_global_norm((x0, x1), clip_norm) 181 tf_ans_1 = ans[0].eval() 182 tf_ans_2 = ans[1].eval() 183 tf_norm = norm.eval() 184 185 self.assertAllClose(tf_norm, 5.0) 186 self.assertAllClose(np_ans_0, tf_ans_1) 187 self.assertAllClose(np_ans_1, tf_ans_2) 188 189 def testClipByGlobalNormSupportsNone(self): 190 # Norm clipping when clip_norm < 5 191 with self.test_session(): 192 x0 = constant_op.constant([-2.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 193 x1 = constant_op.constant([1.0, -2.0]) 194 # Global norm of x0 and x1 = sqrt(1 + 4^2 + 2^2 + 2^2) = 5 195 clip_norm = 4.0 196 197 # Answers are the original tensors scaled by 4.0/5.0 198 np_ans_0 = [[-1.6, 0.0, 0.0], [3.2, 0.0, 0.0]] 199 np_ans_1 = [0.8, -1.6] 200 201 ans, norm = clip_ops.clip_by_global_norm((x0, None, x1, None), clip_norm) 202 self.assertTrue(ans[1] is None) 203 self.assertTrue(ans[3] is None) 204 tf_ans_1 = ans[0].eval() 205 tf_ans_2 = ans[2].eval() 206 tf_norm = norm.eval() 207 208 self.assertAllClose(tf_norm, 5.0) 209 self.assertAllClose(np_ans_0, tf_ans_1) 210 self.assertAllClose(np_ans_1, tf_ans_2) 211 212 def testClipByGlobalNormWithIndexedSlicesClipped(self): 213 # Norm clipping when clip_norm < 5 214 with self.test_session(): 215 x0 = constant_op.constant([-2.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 216 x1 = ops.IndexedSlices( 217 constant_op.constant([1.0, -2.0]), constant_op.constant([3, 4])) 218 # Global norm of x0 and x1 = sqrt(1 + 4^2 + 2^2 + 2^2) = 5 219 clip_norm = 4.0 220 221 # Answers are the original tensors scaled by 4.0/5.0 222 np_ans_0 = [[-1.6, 0.0, 0.0], [3.2, 0.0, 0.0]] 223 np_ans_1 = [0.8, -1.6] 224 225 ans, norm = clip_ops.clip_by_global_norm([x0, x1], clip_norm) 226 tf_ans_1 = ans[0].eval() 227 tf_ans_2 = ans[1].values.eval() 228 tf_norm = norm.eval() 229 230 self.assertAllClose(tf_norm, 5.0) 231 self.assertAllClose(np_ans_0, tf_ans_1) 232 self.assertAllClose(np_ans_1, tf_ans_2) 233 234 def testClipByGlobalNormPreservesDenseShape(self): 235 dense_shape = (1,) 236 slices = ops.IndexedSlices( 237 constant_op.constant([1.0]), 238 constant_op.constant([0]), 239 dense_shape=dense_shape) 240 ans, _ = clip_ops.clip_by_global_norm([slices], 1.0) 241 modified_slices = ans[0] 242 self.assertEqual(dense_shape, slices.dense_shape) 243 self.assertEqual(dense_shape, modified_slices.dense_shape) 244 245 def testClipByGlobalNormNotClipped(self): 246 # No norm clipping when clip_norm >= 5 247 with self.test_session(): 248 x0 = constant_op.constant([-2.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 249 x1 = constant_op.constant([1.0, -2.0]) 250 # Global norm of x0 and x1 = sqrt(1 + 4^2 + 2^2 + 2^2) = 5 251 np_ans_0 = [[-2.0, 0.0, 0.0], [4.0, 0.0, 0.0]] 252 np_ans_1 = [1.0, -2.0] 253 clip_norm = 6.0 254 255 ans, norm = clip_ops.clip_by_global_norm([x0, x1], clip_norm) 256 tf_ans_1 = ans[0].eval() 257 tf_ans_2 = ans[1].eval() 258 tf_norm = norm.eval() 259 260 self.assertAllClose(tf_norm, 5.0) 261 self.assertAllClose(np_ans_0, tf_ans_1) 262 self.assertAllClose(np_ans_1, tf_ans_2) 263 264 def testClipByGlobalNormZero(self): 265 # No norm clipping when norm = 0 266 with self.test_session(): 267 x0 = constant_op.constant([0.0, 0.0, 0.0, 0.0, 0.0, 0.0], shape=[2, 3]) 268 x1 = constant_op.constant([0.0, 0.0]) 269 # Norm = 0, no changes 270 np_ans_0 = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] 271 np_ans_1 = [0.0, 0.0] 272 clip_norm = 6.0 273 274 ans, norm = clip_ops.clip_by_global_norm([x0, x1], clip_norm) 275 tf_ans_1 = ans[0].eval() 276 tf_ans_2 = ans[1].eval() 277 tf_norm = norm.eval() 278 279 self.assertAllClose(tf_norm, 0.0) 280 self.assertAllClose(np_ans_0, tf_ans_1) 281 self.assertAllClose(np_ans_1, tf_ans_2) 282 283 def testClipByAverageNormClipped(self): 284 # Norm clipping when average clip_norm < 0.83333333 285 with self.test_session(): 286 x = constant_op.constant([-3.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 287 # Average norm of x = sqrt(3^2 + 4^2) / 6 = 0.83333333 288 np_ans = [[-2.88, 0.0, 0.0], [3.84, 0.0, 0.0]] 289 clip_norm = 0.8 290 ans = clip_ops.clip_by_average_norm(x, clip_norm) 291 tf_ans = ans.eval() 292 293 self.assertAllClose(np_ans, tf_ans) 294 295 def testClipByAverageNormClippedTensor(self): 296 # Norm clipping when average clip_norm < 0.83333333 297 with self.test_session(): 298 x = constant_op.constant([-3.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 299 # Average norm of x = sqrt(3^2 + 4^2) / 6 = 0.83333333 300 np_ans = [[-2.88, 0.0, 0.0], [3.84, 0.0, 0.0]] 301 clip_norm = constant_op.constant(0.8) 302 ans = clip_ops.clip_by_average_norm(x, clip_norm) 303 tf_ans = ans.eval() 304 305 self.assertAllClose(np_ans, tf_ans) 306 307 def testClipByAverageNormNotClipped(self): 308 # No norm clipping when average clip_norm >= 0.83333333 309 with self.test_session(): 310 x = constant_op.constant([-3.0, 0.0, 0.0, 4.0, 0.0, 0.0], shape=[2, 3]) 311 # Average norm of x = sqrt(3^2 + 4^2) / 6 = 0.83333333 312 np_ans = [[-3.0, 0.0, 0.0], [4.0, 0.0, 0.0]] 313 clip_norm = 0.9 314 ans = clip_ops.clip_by_average_norm(x, clip_norm) 315 tf_ans = ans.eval() 316 317 self.assertAllClose(np_ans, tf_ans) 318 319 def testClipByAverageNormZero(self): 320 # No norm clipping when average clip_norm = 0 321 with self.test_session(): 322 x = constant_op.constant([0.0, 0.0, 0.0, 0.0, 0.0, 0.0], shape=[2, 3]) 323 # Average norm = 0, no changes 324 np_ans = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] 325 clip_norm = 0.9 326 ans = clip_ops.clip_by_average_norm(x, clip_norm) 327 tf_ans = ans.eval() 328 329 self.assertAllClose(np_ans, tf_ans) 330 331 332 if __name__ == '__main__': 333 test.main() 334
