update pr

Author: Mohamed-Ashraf273

keras_hub/src/models/gemma/gemma_causal_lm.py

@@ -258,9 +258,6 @@ def next(prompt, cache, index):
             cache_update_index = index - 1
             batch_size = ops.shape(prompt)[0]
             prompt = ops.slice(prompt, [0, cache_update_index], [batch_size, 1])
-            if keras.config.backend() == "openvino":
-                # Avoid returning dynamic shape by openvino slice
-                prompt = ops.reshape(prompt, [batch_size, 1])
             logits, hidden_states, cache = self.call_with_cache(
                 prompt,
                 cache,

keras_hub/src/models/gpt2/gpt2_causal_lm.py

@@ -246,9 +246,6 @@ def next(prompt, cache, index):
             cache_update_index = index - 1
             batch_size = ops.shape(prompt)[0]
             prompt = ops.slice(prompt, [0, cache_update_index], [batch_size, 1])
-            if keras.config.backend() == "openvino":
-                # Avoid returning dynamic shape by openvino slice
-                prompt = ops.reshape(prompt, [batch_size, 1])
             logits, hidden_states, cache = self.call_with_cache(
                 prompt,
                 cache,

keras_hub/src/models/mistral/mistral_causal_lm.py

@@ -145,9 +145,6 @@ def next(prompt, cache, index):
             cache_update_index = index - 1
             batch_size = ops.shape(prompt)[0]
             prompt = ops.slice(prompt, [0, cache_update_index], [batch_size, 1])
-            if keras.config.backend() == "openvino":
-                # Avoid returning dynamic shape by openvino slice
-                prompt = ops.reshape(prompt, [batch_size, 1])
             logits, hidden_states, cache = self.call_with_cache(
                 prompt,
                 cache,

keras_hub/src/utils/openvino_utils.py

@@ -2,7 +2,6 @@
 import functools
 from pathlib import Path
 
-import keras
 from keras import tree
 
 from keras_hub.src.utils.keras_utils import print_msg
@@ -166,9 +165,6 @@ def get_openvino_skip_reason(item, supported_paths, auto_skip_training=True):
     Returns:
         str or None: Skip reason if should skip, None otherwise.
     """
-    if keras.config.backend() != "openvino":
-        return None
-
     test_name = item.name.split("[")[0]
     test_path = str(item.fspath)
 

keras_hub/src/utils/openvino_utils_test.py

@@ -39,7 +39,6 @@ def setUp(self):
             self.skipTest("OpenVINO not available")
 
     def test_get_device_returns_valid_device(self):
-        """Test that get_device returns a valid device."""
         device = get_device()
 
         self.assertIn(device, ["GPU", "CPU"])
@@ -48,14 +47,12 @@ def test_get_device_returns_valid_device(self):
         self.assertIn(device, core.available_devices)
 
     def test_get_device_consistency(self):
-        """Test that get_device returns consistent results."""
         device1 = get_device()
         device2 = get_device()
 
         self.assertEqual(device1, device2)
 
     def test_compile_model_with_mock_params(self):
-        """Test compile_model function interface with mocking."""
         # We mock the OpenVINO components because
         # creating real OpenVINO operations
         # is complex and requires proper parameter
@@ -103,7 +100,6 @@ def output(self):
                 mock_core.compile_model.assert_called_once()
 
     def test_compile_model_precision_hints(self):
-        """Test compile_model with different precision hints."""
         # Mock the entire compilation process to test precision hint behavior
         with unittest.mock.patch(
             "keras_hub.src.utils.openvino_utils.ov.Model"
@@ -150,8 +146,6 @@ def output(self):
                 self.assertEqual(mock_core.compile_model.call_count, 2)
 
     def test_get_outputs_basic_functionality(self):
-        """Test get_outputs with a mocked compiled model."""
-
         # Mock result needs to_tuple() method as expected by get_outputs
         class MockResult:
             def __init__(self, data):
@@ -195,7 +189,6 @@ def mock_unpack_singleton(x):
         np.testing.assert_array_almost_equal(outputs, expected)
 
     def test_ov_infer_model_caching(self):
-        """Test that ov_infer properly handles model caching attributes."""
         # Use current device to match ov_infer's device check for caching
         current_device = get_device()
 
@@ -235,8 +228,6 @@ def mock_fn(struct_params, stop_token_ids):
         self.assertIsNotNone(result)
 
     def test_ov_infer_dtype_selection(self):
-        """Test that ov_infer handles different dtypes correctly."""
-
         class MockModel:
             def __init__(self, dtype):
                 self.dtype = dtype
@@ -284,7 +275,6 @@ def mock_fn(struct_params, stop_token_ids):
                         self.assertEqual(args[3], expected_ov_dtype)
 
     def test_load_openvino_supported_tools_valid_file(self):
-        """Test loading supported tools from a valid file."""
         with tempfile.NamedTemporaryFile(
             mode="w", delete=False, suffix=".txt"
         ) as f:
@@ -308,12 +298,10 @@ def test_load_openvino_supported_tools_valid_file(self):
             os.unlink(temp_file)
 
     def test_load_openvino_supported_tools_nonexistent_file(self):
-        """Test loading supported tools from a nonexistent file."""
         result = load_openvino_supported_tools("/nonexistent/file.txt")
         self.assertEqual(result, [])
 
     def test_load_openvino_supported_tools_empty_file(self):
-        """Test loading supported tools from an empty file."""
         with tempfile.NamedTemporaryFile(
             mode="w", delete=False, suffix=".txt"
         ) as f:
@@ -325,38 +313,21 @@ def test_load_openvino_supported_tools_empty_file(self):
         finally:
             os.unlink(temp_file)
 
-    def test_setup_openvino_test_config_non_openvino_backend(self):
-        """Test setup_openvino_test_config with non-OpenVINO backend."""
-        try:
-            with unittest.mock.patch(
-                "keras.config.backend", return_value="tensorflow"
-            ):
-                result = setup_openvino_test_config("/some/path")
-                self.assertEqual(result, [])
-        finally:
-            pass
-
     def test_setup_openvino_test_config_openvino_backend(self):
-        """Test setup_openvino_test_config with OpenVINO backend."""
         with tempfile.TemporaryDirectory() as temp_dir:
             config_file = os.path.join(temp_dir, "openvino_supported_tests.txt")
             with open(config_file, "w") as f:
                 f.write("keras_hub/src/models/gemma\n")
                 f.write("keras_hub/src/tokenizers\n")
 
-            with unittest.mock.patch(
-                "keras.config.backend", return_value="openvino"
-            ):
-                result = setup_openvino_test_config(temp_dir)
-                expected = [
-                    "keras_hub/src/models/gemma",
-                    "keras_hub/src/tokenizers",
-                ]
-                self.assertEqual(result, expected)
+            result = setup_openvino_test_config(temp_dir)
+            expected = [
+                "keras_hub/src/models/gemma",
+                "keras_hub/src/tokenizers",
+            ]
+            self.assertEqual(result, expected)
 
     def test_contains_training_methods_with_training_code(self):
-        """Test _contains_training_methods with file containing training
-        methods."""
         training_code = """
         import keras
 
@@ -384,7 +355,6 @@ def test_other_method():
             os.unlink(temp_file)
 
     def test_contains_training_methods_nonexistent_file(self):
-        """Test _contains_training_methods with nonexistent file."""
         result = _contains_training_methods(
             "/nonexistent/file.py", "test_method"
         )
@@ -393,8 +363,6 @@ def test_contains_training_methods_nonexistent_file(self):
         self.assertTrue(result)
 
     def test_should_auto_skip_training_test_non_python_file(self):
-        """Test should_auto_skip_training_test with non-Python file."""
-
         class MockItem:
             def __init__(self, fspath):
                 self.fspath = type("MockPath", (), {"basename": fspath})()
@@ -404,51 +372,7 @@ def __init__(self, fspath):
         result = should_auto_skip_training_test(item)
         self.assertFalse(result)
 
-    def test_should_auto_skip_training_test_non_openvino_backend(self):
-        """Test should_auto_skip_training_test function behavior.
-
-        Note: This function doesn't check the backend - it only analyzes
-        code for training methods. Backend checking is done in
-        get_openvino_skip_reason."""
-
-        # Create a temporary file with simple test code (no training methods)
-        simple_test_code = """
-def test_method():
-    # A simple test without training methods
-    assert True
-"""
-        with tempfile.NamedTemporaryFile(
-            mode="w", delete=False, suffix=".py"
-        ) as f:
-            f.write(simple_test_code)
-            temp_file = f.name
-
-        try:
-
-            class MockFspath:
-                def __init__(self, path):
-                    self.path = path
-                    self.basename = os.path.basename(path)
-
-                def __str__(self):
-                    return self.path
-
-            class MockItem:
-                def __init__(self, fspath, name):
-                    self.fspath = MockFspath(fspath)
-                    self.name = name
-
-            item = MockItem(temp_file, "test_method")
-
-            # This function should return False for a simple test without
-            # training methods, regardless of backend
-            result = should_auto_skip_training_test(item)
-            self.assertFalse(result)
-        finally:
-            os.unlink(temp_file)
-
     def test_should_auto_skip_training_test_with_training_methods(self):
-        """Test should_auto_skip_training_test with training methods."""
         training_code = """
         def test_fit_method():
             model.fit(x, y)
@@ -476,57 +400,31 @@ def __init__(self, fspath, name):
                     self.name = name
 
             item = MockItem(temp_file, "test_fit_method")
-
-            with unittest.mock.patch(
-                "keras.config.backend", return_value="openvino"
-            ):
-                result = should_auto_skip_training_test(item)
-                self.assertTrue(result)
+            result = should_auto_skip_training_test(item)
+            self.assertTrue(result)
         finally:
             os.unlink(temp_file)
 
-    def test_get_openvino_skip_reason_non_openvino_backend(self):
-        """Test get_openvino_skip_reason with non-OpenVINO backend."""
-
-        class MockItem:
-            def __init__(self):
-                self.name = "test_method"
-                self.fspath = type("MockPath", (), {})()
-
-        item = MockItem()
-        with unittest.mock.patch(
-            "keras.config.backend", return_value="tensorflow"
-        ):
-            result = get_openvino_skip_reason(item, [], True)
-            self.assertIsNone(result)
-
     def test_get_openvino_skip_reason_specific_test_skip(self):
-        """Test get_openvino_skip_reason with specific test methods that
-        should be skipped."""
-
         class MockItem:
             def __init__(self, test_name):
                 self.name = test_name
                 self.fspath = type("MockPath", (), {})()
                 setattr(self.fspath, "__str__", lambda: "test_file.py")
 
-        with unittest.mock.patch(
-            "keras.config.backend", return_value="openvino"
-        ):
-            # Define expected skip reasons matching the implementation
-            expected_reasons = {
-                "test_backbone_basics": "Requires trainable backend",
-                "test_score_loss": "Non-implemented roll operation",
-                "test_layer_behaviors": "Requires trainable backend",
-            }
-
-            for test_name, expected_reason in expected_reasons.items():
-                item = MockItem(test_name)
-                result = get_openvino_skip_reason(item, [], True)
-                self.assertEqual(result, expected_reason)
+        # Define expected skip reasons matching the implementation
+        expected_reasons = {
+            "test_backbone_basics": "Requires trainable backend",
+            "test_score_loss": "Non-implemented roll operation",
+            "test_layer_behaviors": "Requires trainable backend",
+        }
+
+        for test_name, expected_reason in expected_reasons.items():
+            item = MockItem(test_name)
+            result = get_openvino_skip_reason(item, [], True)
+            self.assertEqual(result, expected_reason)
 
     def test_get_openvino_skip_reason_training_skip(self):
-        """Test get_openvino_skip_reason with training methods."""
         training_code = """
         def test_training_method():
             model.fit(x, y)
@@ -554,18 +452,12 @@ def __init__(self, fspath, name):
                     self.name = name
 
             item = MockItem(temp_file, "test_training_method")
-
-            with unittest.mock.patch(
-                "keras.config.backend", return_value="openvino"
-            ):
-                result = get_openvino_skip_reason(item, [], True)
-                self.assertEqual(result, "Training operations not supported")
+            result = get_openvino_skip_reason(item, [], True)
+            self.assertEqual(result, "Training operations not supported")
         finally:
             os.unlink(temp_file)
 
     def test_get_openvino_skip_reason_whitelist_supported(self):
-        """Test get_openvino_skip_reason with supported path in whitelist."""
-
         class MockFspath:
             def __init__(self, path):
                 self.path = path
@@ -584,17 +476,10 @@ def __init__(self, fspath, name):
         supported_paths = ["keras_hub/src/models/gemma"]
 
         item = MockItem(test_path, "test_inference")
-
-        with unittest.mock.patch(
-            "keras.config.backend", return_value="openvino"
-        ):
-            result = get_openvino_skip_reason(item, supported_paths, False)
-            self.assertIsNone(result)
+        result = get_openvino_skip_reason(item, supported_paths, False)
+        self.assertIsNone(result)
 
     def test_get_openvino_skip_reason_whitelist_not_supported(self):
-        """Test get_openvino_skip_reason with unsupported path not in
-        whitelist."""
-
         class MockFspath:
             def __init__(self, path):
                 self.path = path
@@ -613,16 +498,10 @@ def __init__(self, fspath, name):
         supported_paths = ["keras_hub/src/models/gemma"]
 
         item = MockItem(test_path, "test_inference")
-
-        with unittest.mock.patch(
-            "keras.config.backend", return_value="openvino"
-        ):
-            result = get_openvino_skip_reason(item, supported_paths, False)
-            self.assertEqual(result, "File/directory not in OpenVINO whitelist")
+        result = get_openvino_skip_reason(item, supported_paths, False)
+        self.assertEqual(result, "File/directory not in OpenVINO whitelist")
 
     def test_get_openvino_skip_reason_no_whitelist(self):
-        """Test get_openvino_skip_reason with empty whitelist."""
-
         class MockFspath:
             def __init__(self, path):
                 self.path = path
@@ -637,11 +516,6 @@ def __init__(self, fspath, name):
                 self.name = name
 
         test_path = "/some/path/keras_hub/src/models/gemma/gemma_test.py"
-
         item = MockItem(test_path, "test_inference")
-
-        with unittest.mock.patch(
-            "keras.config.backend", return_value="openvino"
-        ):
-            result = get_openvino_skip_reason(item, [], False)
-            self.assertIsNone(result)
+        result = get_openvino_skip_reason(item, [], False)
+        self.assertIsNone(result)