added an option to disable Ray (make it easier to debug and also usef…

…ul on platform where Ray is not well supported")

datas/eq/Rogers LS3|5A/iir-autoeq.txt

@@ -1,14 +1,14 @@
 EQ for Rogers LS3|5A computed from ASR data
-Preference Score 1.69 with EQ 5.29
+Preference Score 1.69 with EQ 5.68
 Generated from http://github.com/pierreaubert/spinorama/generate_peqs.py v0.25
-Dated: 2023-11-23-11:12:17
+Dated: 2023-11-23-18:12:03
 
-Preamp: -3.2 dB
+Preamp: -2.9 dB
 
-Filter  1: ON PK Fc   155 Hz Gain -3.43 dB Q 1.54
-Filter  2: ON PK Fc   356 Hz Gain +0.76 dB Q 2.99
-Filter  3: ON PK Fc   424 Hz Gain +2.99 dB Q 0.25
-Filter  4: ON PK Fc  1121 Hz Gain -5.35 dB Q 2.67
-Filter  5: ON PK Fc  1954 Hz Gain -2.48 dB Q 2.11
-Filter  6: ON PK Fc  4989 Hz Gain -1.91 dB Q 2.15
-Filter  7: ON PK Fc  9001 Hz Gain -3.18 dB Q 0.38
+Filter  1: ON PK Fc    95 Hz Gain +2.99 dB Q 0.27
+Filter  2: ON PK Fc   149 Hz Gain -4.93 dB Q 1.16
+Filter  3: ON PK Fc   910 Hz Gain +3.00 dB Q 0.30
+Filter  4: ON PK Fc  1121 Hz Gain -5.76 dB Q 2.47
+Filter  5: ON PK Fc  1887 Hz Gain -2.82 dB Q 2.24
+Filter  6: ON PK Fc  5732 Hz Gain -4.16 dB Q 0.49
+Filter  7: ON PK Fc 16239 Hz Gain -1.83 dB Q 1.22

generate_peqs.py

@@ -43,7 +43,8 @@
  [--fitness=<function>] \
  [--optimisation=<options>] \
  [--graphic_eq=<eq_name>] \
- [--graphic_eq_list]
+ [--graphic_eq_list] \
+ [--disable-ray]
 
 Options:
   --help                   Display usage()
@@ -89,6 +90,7 @@
   --graphic_eq=<eq_name>   Result is tailored for graphic_eq "name".
   --graphic_eq_list        List the known graphic eq and exit
   --optimisation=<options> Choose an algorithm: options are greedy or global. Greedy is fast, Global is much slower but could find better solutions.
+  --disable-ray            Disable ray
 """
 import sys
 
@@ -107,11 +109,17 @@
 from datas.metadata import speakers_info as metadata
 from datas.grapheq import vendor_info as grapheq_info
 
-from generate_common import get_custom_logger, args2level, custom_ray_init, cache_load
-from spinorama.auto_save import optim_save_peq
+from generate_common import (
+    get_custom_logger,
+    args2level,
+    custom_ray_init,
+    cache_load,
+    cache_load_seq,
+)
+from spinorama.auto_save import optim_save_peq, optim_save_peq_seq
 
 
-VERSION = "0.25"
+VERSION = "0.26"
 
 
 def print_items(aggregated_results):
@@ -240,6 +248,52 @@ def compute_peqs(ray_ids):
     return 0
 
 
+def compute_peqs_sequential(df_all_speakers, optim_config, speaker_name):
+    for current_speaker_name in df_all_speakers:
+        if speaker_name is not None and current_speaker_name != speaker_name:
+            continue
+        default = None
+        default_origin = None
+        if (
+            current_speaker_name in metadata
+            and "default_measurement" in metadata[current_speaker_name]
+        ):
+            default = metadata[current_speaker_name]["default_measurement"]
+            default_origin = metadata[current_speaker_name]["measurements"][default]["origin"]
+        else:
+            logger.error("no default_measurement for %s", current_speaker_name)
+            continue
+        if default_origin not in df_all_speakers[current_speaker_name]:
+            logger.error("default origin %s not in %s", default_origin, current_speaker_name)
+            continue
+        if default not in df_all_speakers[current_speaker_name][default_origin]:
+            logger.error(
+                "default %s not in default origin %s for %s",
+                default,
+                default_origin,
+                current_speaker_name,
+            )
+            continue
+        df_speaker = df_all_speakers[current_speaker_name][default_origin][default]
+        if not (
+            ("SPL Horizontal_unmelted" in df_speaker and "SPL Vertical_unmelted" in df_speaker)
+            or ("CEA2034" in df_speaker and "Estimated In-Room Response" in df_speaker)
+        ):
+            logger.info(
+                "not enough data for %s known measurements are (%s)",
+                current_speaker_name,
+                ", ".join(df_speaker),
+            )
+            continue
+
+        status, (current_speaker_name, results_iter, scores) = optim_save_peq_seq(
+            current_speaker_name,
+            default_origin,
+            df_speaker,
+            optim_config,
+        )
+
+
 def main():
     parameter_error = False
 
@@ -531,7 +585,10 @@ def main():
             "origin": origin,
             "version": mversion,
         }
-        df_all_speakers = cache_load(filters=do_filters, smoke_test=smoke_test)
+        if disable_ray:
+            df_all_speakers = cache_load_seq(filters=do_filters, smoke_test=smoke_test)
+        else:
+            df_all_speakers = cache_load(filters=do_filters, smoke_test=smoke_test)
     except ValueError as v_e:
         if speaker_name is not None:
             print(
@@ -544,7 +601,8 @@ def main():
         sys.exit(1)
 
     # start ray
-    custom_ray_init(args)
+    if not disable_ray:
+        custom_ray_init(args)
 
     # add global parameters into the config
     current_optim_config["verbose"] = verbose
@@ -553,8 +611,11 @@ def main():
     current_optim_config["version"] = VERSION
     current_optim_config["level"] = level
 
-    ids = queue_speakers(df_all_speakers, current_optim_config, speaker_name)
-    compute_peqs(ids)
+    if disable_ray:
+        compute_peqs_sequential(df_all_speakers, current_optim_config, speaker_name)
+    else:
+        ids = queue_speakers(df_all_speakers, current_optim_config, speaker_name)
+        compute_peqs(ids)
 
     sys.exit(0)
 
@@ -572,6 +633,7 @@ def main():
     force = args["--force"]
     verbose = args["--verbose"]
     smoke_test = args["--smoke-test"]
+    disable_ray = args["--disable-ray"]
 
     if args["--graphic_eq_list"]:
         print("INFO: The list of know graphical EQ is: {}".format(list(grapheq_info.keys())))

src/spinorama/auto_global.py

@@ -102,19 +102,25 @@ def __init__(
 
         # a bit of black magic
         self.freq_min_index = self._freq2index(self.freq_min)
+        self.freq_2k_index = self._freq2index(2000)
         self.freq_midrange_index = self._freq2index(MIDRANGE_MAX_FREQ / 2)
         self.freq_max_index = self._freq2index(self.freq_max)
 
-        # get lw/on
+        # get lw/on/pir & freq
         self.lw = df_speaker["CEA2034_unmelted"]["Listening Window"].to_numpy()
         self.on = df_speaker["CEA2034_unmelted"]["On Axis"].to_numpy()
+        # self.pir = df_speaker["Estimated In-Room Response_unmelted"]["Estimated In-Room Response"].to_numpy()
         self.freq = df_speaker["CEA2034_unmelted"]["Freq"].to_numpy()
 
         # used for controlling optimisation of the score
-        lw_slope = self.optim_config.get("slope_listening_window", -0.5)
-        lw_target = self.lw + np.linspace(0, lw_slope, len(self.lw))
-        self.target = _resample(self.freq, self.freq_space, lw_target)
-        self.target = _resample(self.freq, self.freq_space, self.on)
+        # lw_slope = self.optim_config.get("slope_listening_window", -0.5)
+        # lw_target = self.lw + np.linspace(0, lw_slope, len(self.lw))
+        # pir_slope = self.optim_config.get("slope_pred_in_room", -7)
+        # pir_target = self.pir + np.linspace(0, pir_slope, len(self.pir))
+
+        # self.target_lw = _resample(self.freq, self.freq_space, lw_target)
+        self.target_on = _resample(self.freq, self.freq_space, self.on)
+        # self.target_pir = _resample(self.freq, self.freq_space, pir_target)
 
         self.min_db = optim_config["MIN_DBGAIN"]
         self.max_db = optim_config["MAX_DBGAIN"]
@@ -169,20 +175,30 @@ def _opt_peq_score(self, x: Encoded) -> float:
         peq = self._x2peq(x)
         peq_freq = np.array(self._x2spl(x))
         score = score_loss(self.df_speaker, peq)
-        flat = np.add(self.target, peq_freq)
-        flatness_bass_mid = np.linalg.norm(
-            flat[self.freq_min_index : self.freq_midrange_index], ord=2
+        flat_on = np.add(self.target_on, peq_freq)
+        # currently unsued
+        # flat_lw = np.add(self.target_lw, peq_freq)
+        # flat_pir = np.add(self.target_pir, peq_freq)
+        # split flatness of ON on various ranges
+        flatness_on_bass_mid = np.linalg.norm(
+            flat_on[self.freq_min_index : self.freq_midrange_index], ord=2
         )
-        flatness_mid_high = np.linalg.norm(flat[self.freq_midrange_index :], ord=2)
+        flatness_on_mid_high = np.linalg.norm(flat_on[self.freq_midrange_index :], ord=2)
+        # flatness_on_bass_mid = np.linalg.norm(flat_on[self.freq_min_index : self.freq_2k_index], ord=2)
+        # flatness_on_mid_high = np.linalg.norm(flat_on[self.freq_2k_index :], ord=2)
+        # not used but could be
+        # flatness_pir = np.linalg.norm(flat_pir, ord=2)
+        # flatness_pir_bass_mid = np.linalg.norm(flat_pir[self.freq_min_index : self.freq_midrange_index], ord=2)
+        # flatness_pir_mid_high = np.linalg.norm(flat_pir[self.freq_midrange_index :], ord=2)
         # this is black magic, why 10, 20, 40?
         # if you increase 20 you give more flexibility to the score (and less flat LW/ON)
         # without the constraint optimising the score get crazy results
-        return score + float(flatness_bass_mid) / 5 + float(flatness_mid_high) / 50
+        return score + float(flatness_on_bass_mid) / 15 + float(flatness_on_mid_high) / 50
 
     def _opt_peq_flat(self, x: list[float | int]) -> float:
         # for  a given encoded peq, compute a loss function based on flatness
         peq_freq = np.array(self._x2spl(x))
-        flat = np.add(self.target, peq_freq)[self.freq_min_index : self.freq_max_index]
+        flat = np.add(self.target_on, peq_freq)[self.freq_min_index : self.freq_max_index]
         flatness_l2 = np.linalg.norm(flat, ord=2)
         flatness_l1 = np.linalg.norm(flat, ord=1)
         return float(flatness_l2 + flatness_l1)

src/spinorama/auto_save.py

@@ -168,16 +168,13 @@ def print_small_summary(
         )
 
 
-@ray.remote
-def optim_save_peq(
+def optim_save_peq_seq(
     current_speaker_name: str,
     current_speaker_origin: str,
     df_speaker: DataSpeaker,
     optim_config: dict,
 ) -> tuple[bool, tuple[str, OptimResult, list[dict]]]:
     """Compute and then save PEQ for this speaker"""
-    ray_setup_logger(optim_config["level"])
-
     eq_dir = "datas/eq/{}".format(current_speaker_name)
     pathlib.Path(eq_dir).mkdir(parents=True, exist_ok=True)
     eq_name = "{}/iir-autoeq.txt".format(eq_dir)
@@ -301,3 +298,17 @@ def optim_save_peq(
         print_small_summary(current_speaker_name, score, auto_score)
 
     return True, (current_speaker_name, auto_results, scores)
+
+
+@ray.remote
+def optim_save_peq(
+    current_speaker_name: str,
+    current_speaker_origin: str,
+    df_speaker: DataSpeaker,
+    optim_config: dict,
+) -> tuple[bool, tuple[str, OptimResult, list[dict]]]:
+    """Compute and then save PEQ for this speaker"""
+    ray_setup_logger(optim_config["level"])
+    return optim_save_peq_seq(
+        current_speaker_name, current_speaker_origin, df_speaker, optim_config
+    )