mindspore 2.2.11__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

mindspore/common/auto_dynamic_shape.py

@@ -182,15 +182,15 @@ class _AutoDynamicShapeManager:
 
     def _compare_input_args_and_cache_args(self, input_args, cache_args):
         """compare input args and cache args"""
-        for (input, cache) in zip(input_args, cache_args):
-            if isinstance(input, Tensor) and isinstance(cache, Tensor):
-                if not self.is_tensor_equal(input, cache):
+        for (arg, cache) in zip(input_args, cache_args):
+            if isinstance(arg, Tensor) and isinstance(cache, Tensor):
+                if not self.is_tensor_equal(arg, cache):
                     return False
-            elif isinstance(input, int) and isinstance(cache, int):
-                if input != cache:
+            elif isinstance(arg, int) and isinstance(cache, int):
+                if arg != cache:
                     return False
-            elif isinstance(input, (tuple, list)) and isinstance(cache, (tuple, list)):
-                if not self._compare_input_args_and_cache_args(input, cache):
+            elif isinstance(arg, (tuple, list)) and isinstance(cache, (tuple, list)):
+                if not self._compare_input_args_and_cache_args(arg, cache):
                     return False
         return True
 
@@ -287,21 +287,21 @@ class _AutoIdentifyDynamicShape:
 
 
     @staticmethod
-    def _do_generalize_in_sink(arg, cache, input_index, cache_index, cache_type):
+    def _do_generalize_in_sink(input_arg, cache, input_index, cache_index, cache_type):
         """do generalize in sink, input rank must be 2"""
-        if not arg:
+        if not input_arg:
             raise ValueError("In sink mode, cell input can not be scalar.")
 
-        if arg == cache:
+        if input_arg == cache:
             return cache
 
         shape_value = []
-        if len(arg) != len(cache):
+        if len(input_arg) != len(cache):
             shape_value.append(SHAPE_RANK_ANY)
         else:
-            for _ in arg:
+            for _ in input_arg:
                 shape_value.append(SHAPE_DIM_ANY)
-        logger.info((f'In the {cache_type} cache[{cache_index}], the {input_index}th input tensor shape is {arg},'
+        logger.info((f'In the {cache_type} cache[{cache_index}], the {input_index}th input tensor shape is {input_arg},'
                      f'cache shape is {cache}, not equal, need generalize to {shape_value}.'))
         return shape_value
 
@@ -312,6 +312,20 @@ class _AutoIdentifyDynamicShape:
         self.auto_dynamic_shape_manager.update_phase_and_compile_args(args, phase, self.save_cache_number,
                                                                       is_sink_mode, aux)
 
+    def _check_real_shape_cache(self, res_shape, args_list):
+        """find cache in real_shape_cache"""
+        real_cache_number = self.auto_dynamic_shape_manager.get_real_shape_cache_number()
+        if real_cache_number < 2:
+            logger.info((f'real shape cache cap is {real_cache_number}, smaller than 2, '
+                         f'compile args shape={res_shape}.'))
+            return True
+
+        is_real_shape_exist = self.auto_dynamic_shape_manager.find_compile_args_in_shape_cache(args_list, "real")
+        if is_real_shape_exist:
+            logger.debug((f'find compile args in real shape cache, compile args shape={res_shape}'))
+            return True
+
+        return False
 
     def _generate_with_generalize_shape(self, generalize_shape_args, is_sink_mode, args_list):
         """generate with generalize_shape """
@@ -440,7 +454,6 @@ class _AutoIdentifyDynamicShape:
         return generalize_one_shape, True
 
 
-
     def _do_generalize_shape(self, cache_type, input_args, is_sink_mode):
         """do generalize shape by cache"""
         shape_cache = self.auto_dynamic_shape_manager.get_cache_by_type(cache_type)

mindspore/common/dtype.py

@@ -22,6 +22,9 @@ from inspect import isfunction
 import numpy as np
 from mindspore._c_expression import typing
 from mindspore._c_expression.typing import Type
+from mindspore._c_expression.np_dtypes import np_version_valid
+if np_version_valid(False):
+    from mindspore._c_expression.np_dtypes import bfloat16 as np_bfloat16
 
 __dtype__ = [
     "int8", "byte",
@@ -43,7 +46,7 @@ __dtype__ = [
     "TensorType", "_null",
     "Type", "Int",
     "complex64", "complex128",
-    "bfloat16"
+    "bfloat16", "qint4x2"
 ]
 
 __method__ = [
@@ -58,6 +61,7 @@ __all__.extend(__method__)
 # type definition
 bool_ = typing.Bool()
 
+qint4x2 = typing.Int(4)
 int8 = typing.Int(8)
 byte = int8
 int16 = typing.Int(16)
@@ -140,11 +144,12 @@ number_type = (int8,
                float64,
                bfloat16,
                complex64,
-               complex128,)
+               complex128,
+               qint4x2,)
 
 int_type = (int8, int16, int32, int64,)
 uint_type = (uint8, uint16, uint32, uint64,)
-float_type = (float16, float32, float64,)
+float_type = (float16, float32, float64, bfloat16,)
 signed_type = (int8, byte, int16, short, int32, intc, int64,
                intp, float16, half, float32, single, float64,
                double, bfloat16, complex64, complex128)
@@ -258,8 +263,7 @@ def dtype_to_nptype(type_):
         >>> ms.dtype_to_nptype(ms.int8)
         <class 'numpy.int8'>
     """
-
-    return {
+    _dtype_nptype_dict = {
         bool_: np.bool_,
         int8: np.int8,
         int16: np.int16,
@@ -274,8 +278,10 @@ def dtype_to_nptype(type_):
         float64: np.float64,
         complex64: np.complex64,
         complex128: np.complex128,
-        bfloat16: np.float32,
-    }[type_]
+    }
+    if np_version_valid(False):
+        _dtype_nptype_dict.update({bfloat16: np_bfloat16})
+    return _dtype_nptype_dict[type_]
 
 
 def dtype_to_pytype(type_):
@@ -348,8 +354,9 @@ class QuantDtype(enum.Enum):
     """
     An enum for quant datatype, contains `INT1` ~ `INT16`, `UINT1` ~ `UINT16`.
 
-    `QuantDtype` is defined in `dtype.py <https://gitee.com/mindspore/mindspore/tree/r2.2/mindspore/python/mindspore/
-    common/dtype.py>`_, use command below to import:
+    `QuantDtype` is defined in
+    `dtype.py <https://gitee.com/mindspore/mindspore/blob/master/mindspore/python/mindspore/common/dtype.py>`_ ,
+    use command below to import:
 
     .. code-block::
 
@@ -357,7 +364,7 @@ class QuantDtype(enum.Enum):
 
     Tutorial Examples:
         - `Quantization algorithm in Golden Stick
-          <https://www.mindspore.cn/golden_stick/docs/en/r0.3/quantization/slb.html
+          <https://www.mindspore.cn/golden_stick/docs/en/master/quantization/slb.html
           #applying-the-quantization-algorithm>`_
     """
     INT1 = 0

mindspore/common/dump.py

@@ -25,16 +25,14 @@ def set_dump(target, enabled=True):
     Enable or disable dump for the `target` and its contents.
 
     `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
-    Please note that this API takes effect only when Asynchronous Dump is enabled and the `dump_mode`
-    field in dump config file is ``"2"`` . See the `dump document <https://www.mindspore.cn/tutorials/
-    experts/en/r2.2/debug/dump.html>`_ for details. The default enabled status for
+    Please note that this API takes effect only when Synchronous Dump is enabled and the `dump_mode`
+    field in dump config file is ``"2"`` . See the `dump document
+    <https://www.mindspore.cn/tutorials/experts/en/master/debug/dump.html>`_ for details.
+    The default enabled status for
     a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Note:
-        1. This API is only effective for GRAPH_MODE with Ascend backend.
+        1. This API is only effective for GRAPH_MODE whose graph compilation level is O0/O1 with Ascend backend.
         2. This API only supports being called before training starts.
            If you call this API during training, it may not be effective.
         3. After using `set_dump(Cell, True)` , operators in forward and backward
@@ -60,7 +58,7 @@ def set_dump(target, enabled=True):
         .. note::
             Please set environment variable `MINDSPORE_DUMP_CONFIG` to the dump config file and set `dump_mode` field
             in dump config file to 2 before running this example.
-            See `dump document <https://www.mindspore.cn/tutorials/experts/en/r2.2/debug/dump.html>`_ for details.
+            See `dump document <https://www.mindspore.cn/tutorials/experts/en/master/debug/dump.html>`_ for details.
 
         >>> import numpy as np
         >>> import mindspore as ms

mindspore/common/file_system.py

@@ -0,0 +1,48 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# 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.
+# ============================================================================
+"""File system registration management"""
+
+
+class FileSystem:
+    """File operation interface manager"""
+    def __init__(self):
+        self.create = open
+        self.create_args = ("ab",)
+        self.open = open
+        self.open_args = ("rb",)
+
+
+def _register_basic_file_system(fs: FileSystem):
+    """register basic file system"""
+    fs.create = open
+    fs.create_args = ("ab",)
+    fs.open = open
+    fs.open_args = ("rb",)
+    return True
+
+
+def _register_mindio_file_system(fs: FileSystem):
+    """register mindio file system"""
+    try:
+        import mindio
+    except ImportError:
+        return False
+    if mindio.initialize() != 0:
+        return False
+    fs.create = mindio.create_file
+    fs.create_args = ()
+    fs.open = mindio.open_file
+    fs.open_args = ()
+    return True

mindspore/common/generator.py

@@ -0,0 +1,260 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# 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.
+# ============================================================================
+"""Generator"""
+from mindspore.common.parameter import Parameter
+from mindspore.common import Tensor
+from mindspore.common import dtype as mstype
+from mindspore.ops.operations._inner_ops import Generator as GeneratorOp
+from mindspore.ops.operations._sequence_ops import TensorToScalar
+from mindspore.ops.vm_impl_registry import vm_impl_registry as vm_impl_getters
+from mindspore._c_expression import _random_seeded_generator
+
+
+# pylint: disable=unused-argument
+@vm_impl_getters.register(GeneratorOp)
+def vm_impl_generator(self):
+    """
+    Generate vm_impl function for Generator.
+
+    The default_generator is initialized and called during import.
+    For this reason a vm_impl is required for ut compilation.
+    """
+    def vm_impl(cmd, inputs):
+        return 0
+    return vm_impl
+
+
+STEP = 0
+SEED = 1
+GET_STATE = 2
+SET_STATE = 3
+MANUAL_SEED = 4
+INITIAL_SEED = 5
+
+
+def jit_class(cls):
+    """Make class recognizable in graph mode"""
+    setattr(cls, '__ms_class__', True)
+    return cls
+
+
+@jit_class
+class Generator:
+    """
+    A generator that manages the state of random numbers and provides seed and offset for random functions.
+    When the seed and offset are fixed, the random function generates the same random sequence.
+
+    Inputs:
+        - **step** (int) - Set the step size for offset update.
+
+    Outputs:
+        Tuple consisting of the seed and offset of generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import Generator
+        >>> generator = Generator()
+        >>> generator.manual_seed(5)
+        >>> print(generator.initial_seed())
+        5
+        >>> state = generator.get_state()
+        >>> generator.seed()
+        >>> generator.set_state(state)
+        >>> print(generator.initial_seed())
+        5
+    """
+
+    def __init__(self):
+        self._seed = Parameter(Tensor(0, mstype.int64),
+                               name="seed", requires_grad=False)
+        self._offset = Parameter(
+            Tensor(0, mstype.int64), name="offset", requires_grad=False)
+
+        self._generator = GeneratorOp().set_device("CPU")
+        self._to_scalar = TensorToScalar()
+
+    def set_state(self, state):
+        """
+        Sets the generator state.
+
+        Args:
+            state (tensor): target state of the generator.
+        """
+        self._generator(SET_STATE, (self._seed, self._offset, state))
+
+    def get_state(self):
+        """
+        Get the generator state.
+
+        Returns:
+            Tensor, generator state.
+        """
+        return self._generator(GET_STATE, (self._seed, self._offset))[2]
+
+    def seed(self):  # pylint: disable=redefined-outer-name
+        """
+        Seed generator with random number.
+
+        Returns:
+            Randomly generated seeds, the type is int.
+        """
+        current_seed = self._generator(
+            SEED, (self._seed, self._offset))[0]
+        return self._to_scalar(current_seed)
+
+    def manual_seed(self, seed):  # pylint: disable=redefined-outer-name
+        """
+        Set the generator seed.
+
+        Args:
+            seed (int): Set the generator seed.
+
+        Returns:
+            Generator, the generator instance.
+        """
+        if not isinstance(seed, int):
+            raise TypeError("Seed must be an integer.")
+        seed = Tensor(seed, mstype.int64)
+        self._generator(MANUAL_SEED, (self._seed, self._offset, seed))
+        return self
+
+    def initial_seed(self):
+        """
+        Return the initial seed of generator.
+
+        Returns:
+            The initial seed of generator.
+        """
+        current_seed = self._generator(
+            INITIAL_SEED, (self._seed, self._offset))[0]
+        return self._to_scalar(current_seed)
+
+
+    def _step(self, step):
+        """
+        Return current seed and offset, and update offset for the next call.
+
+        Args:
+            step (Tensor): Update offset by step.
+
+        Returns:
+            Current seed and offset.
+        """
+        return self._generator(STEP, (self._seed, self._offset, step,))[:2]
+
+
+default_generator = _random_seeded_generator()
+
+
+def seed():  # pylint: disable=redefined-outer-name
+    """
+    Seed the default generator with random number.
+
+    Returns:
+        Randomly generated seeds, the type is int.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import seed
+        >>> print(seed())
+        1663920602
+    """
+    return default_generator.seed()
+
+
+def manual_seed(seed):  # pylint: disable=redefined-outer-name
+    """
+    Set the default generator seed.
+
+    Args:
+        seed (int): Set the default generator seed.
+
+    Returns:
+        Generator, the default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import manual_seed, initial_seed
+        >>> manual_seed(13)
+        >>> print(initial_seed())
+        13
+    """
+    default_generator.manual_seed(seed)
+
+
+def initial_seed():
+    """
+    Return the initial seed of the default generator.
+
+    Returns:
+        The initial seed of the default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import manual_seed, initial_seed
+        >>> manual_seed(14)
+        >>> print(initial_seed())
+        14
+    """
+    return default_generator.initial_seed()
+
+
+def get_rng_state():
+    """
+    Get the state of the default generator.
+
+    Returns:
+        Tensor, generator state.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import get_rng_state
+        >>> state = get_rng_state()
+    """
+    return default_generator.get_state()
+
+
+def set_rng_state(state):  # pylint: disable=redefined-outer-name
+    """
+    Set the state of the default generator.
+
+    Args:
+        state (Tensor): the target state
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import set_rng_state, get_rng_state
+        >>> state = get_rng_state()
+        >>> set_rng_state(state)
+    """
+    default_generator.set_state(state)
+
+
+__all__ = ["Generator", "default_generator", "seed", "manual_seed", "initial_seed", "set_rng_state", "get_rng_state"]

mindspore/common/hook_handle.py

@@ -14,9 +14,58 @@
 # ============================================================================
 """The removable handle for cell hook function."""
 from __future__ import absolute_import
-
 import weakref
-from mindspore.common.api import _pynative_executor
+from mindspore._c_expression import Tensor as Tensor_
+
+
+class _TensorHookHandle:
+    r"""
+    A handle provides the ability to remote a tensor hook.
+
+    Note:
+        It is only supported in pynative mode and works when registering or removing hook function for tensor
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+
+    def __init__(self):
+        self.id = None
+
+    def remove(self):
+        """
+        Remove the tensor hook function, which corresponds to this '_TensorHookHandle' object.
+
+        Args:
+            None.
+
+        Returns:
+            None.
+
+        Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> ms.set_context(mode=ms.PYNATIVE_MODE)
+            >>> def hook_fn(grad):
+            ...     return grad * 2
+            ...
+            >>> def hook_test(x, y):
+            ...     z = x * y
+            ...     handle = z.register_hook(hook_fn)
+            ...     z = z * y
+            ...     handle.remove()
+            ...     return z
+            ...
+            >>> ms_grad = ms.grad(hook_test, grad_position=(0,1))
+            >>> output = ms_grad(Tensor(1, ms.float32), Tensor(2, ms.float32))
+            >>> print(output)
+            (Tensor(shape=[], dtype=Float32, value=4), Tensor(shape=[], dtype=Float32, value=4))
+        """
+        if self.id is not None:
+            Tensor_.remove_hook(self.id)
 
 
 class HookHandle:
@@ -100,9 +149,7 @@ class HookHandle:
             hook_cell = self._hook_cell()
             if self._hook_type == "_forward_pre_hook" and self._hook_key in hook_cell._forward_pre_hook:
                 del hook_cell._forward_pre_hook[self._hook_key]
-                _pynative_executor.set_hook_changed(hook_cell)
             elif self._hook_type == "_forward_hook" and self._hook_key in hook_cell._forward_hook:
                 del hook_cell._forward_hook[self._hook_key]
-                _pynative_executor.set_hook_changed(hook_cell)
             elif self._hook_type == "_cell_backward_hook":
                 hook_cell._cell_backward_hook.remove_backward_hook(self._hook_key)

mindspore/common/initializer.py

@@ -37,7 +37,7 @@ class Initializer:
         Initializers are intended to be used for delayed initialization in parallel mode rather than Tensor
         initialization. If you have to use Initializers to create a Tensor, :func:`mindspore.Tensor.init_data` should be
         followed in most of the cases. For more information, please refer to `mindspore.Tensor.init_data
-        <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
+        <https://www.mindspore.cn/docs/en/master/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
         mindspore-tensor-init-data>`_ .
 
     Args:

mindspore/common/jit_config.py

@@ -14,21 +14,20 @@
 # ============================================================================
 """JitConfig for compile."""
 
-
 class JitConfig:
     """
     Jit config for compile.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         jit_level (str, optional): Used to control the compilation optimization level.
-            Supports ["O0", "O1", "O2"]. Default: ``"O1"`` .
+            Supports ["O0", "O1", "O2"]. Default: ``""`` , The framework automatically selects the execution method.
+            Not recommended, it is recommended to use the jit decorator.
 
-            - ``"O0"``: Except for optimizations that may affect functionality, all other optimizations are turned off.
-            - ``"O1"``: Using commonly used optimizations, recommended to set the O1 level.
-            - ``"O2"``: Activate some experimental level optimizations.
+            - ``"O0"``: Except for optimizations that may affect functionality, all other optimizations are turned off,
+              adopt KernelByKernel execution mode.
+            - ``"O1"``: Using commonly used optimizations and automatic operator fusion optimizations,
+              adopt KernelByKernel execution mode.
+            - ``"O2"``: Ultimate performance optimization, adopt Sink execution mode.
 
         exc_mode (str, optional): Control the execution mode of the model.
             Supports ["auto", "sink", "no_sink"]. Default: ``"auto"`` .
@@ -43,7 +42,7 @@ class JitConfig:
             The value must be ``"STRICT"`` , ``"LAX"`` or ``""`` . Default to an empty string, which means that this
             JitConfig configuration will be ignored and the jit_syntax_level of ms.context will be used.
             For more details about ms.context, refer to
-            `set_context <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore/mindspore.set_context.html>`_ .
+            `set_context <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.set_context.html>`_ .
             Default: ``""`` .
 
             - ``"STRICT"``: Only basic syntax is supported, and execution performance is optimal. Can be used for MindIR
@@ -52,6 +51,20 @@ class JitConfig:
               affected and not optimal. Cannot be used for MindIR load and export due to some syntax that may not be
               able to be exported.
 
+        debug_level (str, optional): Set debugging level for graph compiling.
+            The value must be ``"RELEASE"`` or ``"DEBUG"``. Default value: ``RELEASE``.
+
+            - ``RELEASE``: Used for normally running, and some debug information will be discard to get a better
+              compiling performance.
+            - ``DEBUG``: Used for debugging when errors occur, more information will be record in compiling process.
+
+        infer_boost (str, optional): enable infer boost mode.
+            The value must be ``"on"`` , ``"off"``. Default to an "off", which means that disable infer boost.
+            when infer boost mode is enabled, MindSpore will use high perf kernel lib, use faster runtime make
+            infer speed is best.
+            Note: current infer boost only support `jit_level` == ``"O0"`` and only Atlas A2 series products
+            are supported.
+
         **kwargs (dict): A dictionary of keyword arguments that the class needs.
 
     Examples:
@@ -60,19 +73,26 @@ class JitConfig:
         >>> jitconfig = JitConfig(jit_level="O1")
         >>>
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>>
         >>> net.set_jit_config(jitconfig)
     """
-    def __init__(self, jit_level="O1", exc_mode="auto", jit_syntax_level="", **kwargs):
-        if jit_level not in ["O0", "O1", "O2"]:
+    def __init__(self, jit_level="", exc_mode="auto", jit_syntax_level="", debug_level="RELEASE",
+                 infer_boost="off", **kwargs):
+        if jit_level not in ["", "O0", "O1", "O2"]:
             raise ValueError("For 'jit_level' must be one of ['O0', 'O1', 'O2'].")
-        if exc_mode not in ['auto', 'sink', 'no_sink']:
+        if exc_mode not in ["auto", "sink", "no_sink"]:
             raise ValueError("For 'exc_mode' must be one of '['auto', 'sink', 'no_sink']'.")
-        if jit_syntax_level != "" and jit_syntax_level not in ['STRICT', 'COMPATIBLE', 'LAX']:
+        if jit_syntax_level != "" and jit_syntax_level not in ["STRICT", "COMPATIBLE", "LAX"]:
             raise ValueError("For 'jit_syntax_level' must be one of '['STRICT', 'LAX']'.")
+        if debug_level not in ["RELEASE", "DEBUG"]:
+            raise ValueError("For 'debug_level' must be one of '['RELEASE', 'DEBUG']'.")
+        if infer_boost != "" and infer_boost not in ["on", "off"]:
+            raise ValueError("For 'infer_boost' must be one of '['on', 'off']'.")
         self.jit_config_dict = kwargs
         self.jit_config_dict["jit_level"] = jit_level
         self.jit_config_dict["exc_mode"] = exc_mode
         self.jit_config_dict["jit_syntax_level"] = jit_syntax_level
+        self.jit_config_dict["debug_level"] = debug_level
+        self.jit_config_dict["infer_boost"] = infer_boost