removed export_cpp_header in the whole of code (#537)

Co-authored-by: shirzady1934 <shirzady1934@gmail.com>

Author: shirzady1934

nam/models/conv_net.py

@@ -173,38 +173,6 @@ def _num_layers(self) -> int:
     def _batchnorm(self) -> bool:
         return _BATCHNORM_NAME in self._net._modules["block_0"]._modules
 
-    def export_cpp_header(self, filename: _Path):
-        with _TemporaryDirectory() as tmpdir:
-            tmpdir = _Path(tmpdir)
-            self.export(_Path(tmpdir))
-            with open(_Path(tmpdir, "config.json"), "r") as fp:
-                _c = _json.load(fp)
-            version = _c["version"]
-            config = _c["config"]
-            with open(filename, "w") as f:
-                f.writelines(
-                    (
-                        "#pragma once\n",
-                        "// Automatically-generated model file\n",
-                        "#include <vector>\n",
-                        f'#define PYTHON_MODEL_VERSION "{version}"\n',
-                        f"const int CHANNELS = {config['channels']};\n",
-                        f"const bool BATCHNORM = {'true' if config['batchnorm'] else 'false'};\n",
-                        "std::vector<int> DILATIONS{"
-                        + ",".join([str(d) for d in config["dilations"]])
-                        + "};\n",
-                        f"const std::string ACTIVATION = \"{config['activation']}\";\n",
-                        "std::vector<float> PARAMS{"
-                        + ",".join(
-                            [
-                                f"{w:.16f}"
-                                for w in _np.load(_Path(tmpdir, "weights.npy"))
-                            ]
-                        )
-                        + "};\n",
-                    )
-                )
-
     def _export_config(self):
         return {
             "channels": self._channels,

nam/models/exportable.py

@@ -102,14 +102,6 @@ def export(
         # And resume training state
         self.train(training)
 
-    @_abc.abstractmethod
-    def export_cpp_header(self, filename: _Path):
-        """
-        Export a .h file to compile into the plugin with the weights written right out
-        as text
-        """
-        pass
-
     def export_onnx(self, filename: _Path):
         """
         Export model in format for ONNX Runtime

nam/models/linear.py

@@ -27,9 +27,6 @@ def pad_start_default(self) -> bool:
     def receptive_field(self) -> int:
         return self._net.weight.shape[2]
 
-    def export_cpp_header(self):
-        raise NotImplementedError()
-
     @property
     def _bias(self) -> bool:
         return self._net.bias is not None

nam/models/recurrent.py

@@ -129,36 +129,6 @@ def pad_start_default(self) -> bool:
         # I should simplify this...
         return True
 
-    def export_cpp_header(self, filename: _Path):
-        with _TemporaryDirectory() as tmpdir:
-            tmpdir = _Path(tmpdir)
-            LSTM.export(self, _Path(tmpdir))  # Hacky...need to work w/ CatLSTM
-            with open(_Path(tmpdir, "model.nam"), "r") as fp:
-                _c = _json.load(fp)
-            version = _c["version"]
-            config = _c["config"]
-            s_parametric = self._export_cpp_header_parametric(config.get("parametric"))
-            with open(filename, "w") as f:
-                f.writelines(
-                    (
-                        "#pragma once\n",
-                        "// Automatically-generated model file\n",
-                        "#include <vector>\n",
-                        '#include "json.hpp"\n',
-                        '#include "lstm.h"\n',
-                        f'#define PYTHON_MODEL_VERSION "{version}"\n',
-                        f'const int NUM_LAYERS = {config["num_layers"]};\n',
-                        f'const int INPUT_SIZE = {config["input_size"]};\n',
-                        f'const int HIDDEN_SIZE = {config["hidden_size"]};\n',
-                    )
-                    + s_parametric
-                    + (
-                        "std::vector<float> PARAMS{"
-                        + ", ".join([f"{w:.16f}f" for w in _c["weights"]])
-                        + "};\n",
-                    )
-                )
-
     def _apply_head(self, features: _torch.Tensor) -> _torch.Tensor:
         """
         :param features: (B,S,DH)
@@ -242,13 +212,6 @@ def _export_config(self):
             "hidden_size": self._core.hidden_size,
             "num_layers": self._core.num_layers,
         }
-
-    def _export_cpp_header_parametric(self, config):
-        # TODO refactor to merge w/ WaveNet implementation
-        if config is not None:
-            raise ValueError("Got non-None parametric config")
-        return ("nlohmann::json PARAMETRIC {};\n",)
-
     def _export_weights(self):
         """
         * Loop over cells:

nam/models/wavenet.py

@@ -356,67 +356,6 @@ def pad_start_default(self) -> bool:
     def receptive_field(self) -> int:
         return self._net.receptive_field
 
-    def export_cpp_header(self, filename: _Path):
-        with _TemporaryDirectory() as tmpdir:
-            tmpdir = _Path(tmpdir)
-            WaveNet.export(self, _Path(tmpdir))  # Hacky...need to work w/ CatWaveNet
-            with open(_Path(tmpdir, "model.nam"), "r") as fp:
-                _c = _json.load(fp)
-            version = _c["version"]
-            config = _c["config"]
-
-            if config["head"] is not None:
-                raise NotImplementedError("No heads yet")
-            # head_scale
-            # with_head
-            # parametric
-
-            # String for layer array params:
-            s_lap = (
-                "const std::vector<wavenet::LayerArrayParams> LAYER_ARRAY_PARAMS{\n",
-            )
-            for i, lc in enumerate(config["layers"], 1):
-                s_lap_line = (
-                    f'  wavenet::LayerArrayParams({lc["input_size"]}, '
-                    f'{lc["condition_size"]}, {lc["head_size"]}, {lc["channels"]}, '
-                    f'{lc["kernel_size"]}, std::vector<int> '
-                    "{"
-                    + ", ".join([str(d) for d in lc["dilations"]])
-                    + "}, "
-                    + (
-                        f'"{lc["activation"]}", {str(lc["gated"]).lower()}, '
-                        f'{str(lc["head_bias"]).lower()})'
-                    )
-                )
-                if i < len(config["layers"]):
-                    s_lap_line += ","
-                s_lap_line += "\n"
-                s_lap += (s_lap_line,)
-            s_lap += ("};\n",)
-            s_parametric = self._export_cpp_header_parametric(config.get("parametric"))
-            with open(filename, "w") as f:
-                f.writelines(
-                    (
-                        "#pragma once\n",
-                        "// Automatically-generated model file\n",
-                        "#include <vector>\n",
-                        '#include "json.hpp"\n',
-                        '#include "wavenet.h"\n',
-                        f'#define PYTHON_MODEL_VERSION "{version}"\n',
-                    )
-                    + s_lap
-                    + (
-                        f'const float HEAD_SCALE = {config["head_scale"]};\n',
-                        "const bool WITH_HEAD = false;\n",
-                    )
-                    + s_parametric
-                    + (
-                        "std::vector<float> PARAMS{"
-                        + ", ".join([f"{w:.16f}f" for w in _c["weights"]])
-                        + "};\n",
-                    )
-                )
-
     def import_weights(self, weights: _Sequence[float]):
         if not isinstance(weights, _torch.Tensor):
             weights = _torch.Tensor(weights)
@@ -425,11 +364,6 @@ def import_weights(self, weights: _Sequence[float]):
     def _export_config(self):
         return self._net.export_config()
 
-    def _export_cpp_header_parametric(self, config):
-        if config is not None:
-            raise ValueError("Got non-None parametric config")
-        return ("nlohmann::json PARAMETRIC {};\n",)
-
     def _export_weights(self) -> _np.ndarray:
         return self._net.export_weights()
 

tests/test_nam/test_models/test_base.py

@@ -31,8 +31,6 @@ def pad_start_default(self) -> bool:
     def receptive_field(self) -> int:
         return 1
 
-    def export_cpp_header(self, filename: Path):
-        pass
 
     def _export_config(self):
         pass

tests/test_nam/test_models/test_exportable.py

@@ -200,9 +200,6 @@ def __init__(self):
             def forward(self, x: torch.Tensor):
                 return self._scale * x + self._bias
 
-            def export_cpp_header(self, filename: Path):
-                pass
-
             def _export_config(self):
                 return {}