sonusai 0.20.3__py3-none-any.whl → 1.0.2__py3-none-any.whl

sonusai/mixture/mixdb.py

@@ -6,36 +6,43 @@ from sqlite3 import Connection
 from sqlite3 import Cursor
 from typing import Any
 
-from .datatypes import ASRConfigs
-from .datatypes import AudioF
-from .datatypes import AudioT
-from .datatypes import ClassCount
-from .datatypes import Feature
-from .datatypes import FeatureGeneratorConfig
-from .datatypes import FeatureGeneratorInfo
-from .datatypes import GeneralizedIDs
-from .datatypes import ImpulseResponseFile
-from .datatypes import MetricDoc
-from .datatypes import MetricDocs
-from .datatypes import Mixture
-from .datatypes import NoiseFile
-from .datatypes import Segsnr
-from .datatypes import SpectralMask
-from .datatypes import SpeechMetadata
-from .datatypes import TargetFile
-from .datatypes import TransformConfig
-from .datatypes import TruthConfigs
-from .datatypes import TruthDict
-from .datatypes import UniversalSNR
+from ..datatypes import ASRConfigs
+from ..datatypes import AudioF
+from ..datatypes import AudioT
+from ..datatypes import ClassCount
+from ..datatypes import Feature
+from ..datatypes import FeatureGeneratorConfig
+from ..datatypes import FeatureGeneratorInfo
+from ..datatypes import GeneralizedIDs
+from ..datatypes import ImpulseResponseFile
+from ..datatypes import MetricDoc
+from ..datatypes import MetricDocs
+from ..datatypes import Mixture
+from ..datatypes import Segsnr
+from ..datatypes import SourceFile
+from ..datatypes import Sources
+from ..datatypes import SourcesAudioF
+from ..datatypes import SourcesAudioT
+from ..datatypes import SpectralMask
+from ..datatypes import SpeechMetadata
+from ..datatypes import TransformConfig
+from ..datatypes import TruthConfigs
+from ..datatypes import TruthDict
+from ..datatypes import TruthsConfigs
+from ..datatypes import TruthsDict
+from ..datatypes import UniversalSNR
 
 
 def db_file(location: str, test: bool = False) -> str:
     from os.path import join
 
+    from .constants import MIXDB_NAME
+    from .constants import TEST_MIXDB_NAME
+
     if test:
-        name = "mixdb_test.db"
+        name = TEST_MIXDB_NAME
     else:
-        name = "mixdb.db"
+        name = MIXDB_NAME
 
     return join(location, name)
 
@@ -103,7 +110,7 @@ class MixtureDatabase:
         config = load_config(self.location)
         new_asr_configs = json.dumps(config["asr_configs"])
         with self.db() as c:
-            old_asr_configs = c.execute("SELECT top.asr_configs FROM top").fetchone()
+            old_asr_configs = c.execute("SELECT asr_configs FROM top").fetchone()
 
         if old_asr_configs is not None and new_asr_configs != old_asr_configs[0]:
             con = db_connection(location=self.location, readonly=False, test=self.test)
@@ -113,7 +120,7 @@ class MixtureDatabase:
 
     @cached_property
     def json(self) -> str:
-        from .datatypes import MixtureDatabaseConfig
+        from ..datatypes import MixtureDatabaseConfig
 
         config = MixtureDatabaseConfig(
             asr_configs=self.asr_configs,
@@ -121,13 +128,11 @@ class MixtureDatabase:
             class_labels=self.class_labels,
             class_weights_threshold=self.class_weights_thresholds,
             feature=self.feature,
-            impulse_response_files=self.impulse_response_files,
-            mixtures=self.mixtures(),
-            noise_mix_mode=self.noise_mix_mode,
-            noise_files=self.noise_files,
+            ir_files=self.ir_files,
+            mixtures=self.mixtures,
             num_classes=self.num_classes,
             spectral_masks=self.spectral_masks,
-            target_files=self.target_files,
+            source_files=self.source_files,
         )
         return config.to_json(indent=2)
 
@@ -153,30 +158,28 @@ class MixtureDatabase:
         return get_feature_generator_info(self.fg_config)
 
     @cached_property
-    def truth_parameters(self) -> dict[str, int | None]:
+    def truth_parameters(self) -> dict[str, dict[str, int | None]]:
         with self.db() as c:
-            rows = c.execute("SELECT * FROM truth_parameters").fetchall()
-            truth_parameters: dict[str, int | None] = {}
+            rows = c.execute("SELECT category, name, parameters FROM truth_parameters").fetchall()
+            truth_parameters: dict[str, dict[str, int | None]] = {}
             for row in rows:
-                truth_parameters[row[1]] = row[2]
+                category, name, parameters = row
+                if category not in truth_parameters:
+                    truth_parameters[category] = {}
+                truth_parameters[category][name] = parameters
             return truth_parameters
 
     @cached_property
     def num_classes(self) -> int:
         with self.db() as c:
-            return int(c.execute("SELECT top.num_classes FROM top").fetchone()[0])
-
-    @cached_property
-    def noise_mix_mode(self) -> str:
-        with self.db() as c:
-            return str(c.execute("SELECT top.noise_mix_mode FROM top").fetchone()[0])
+            return int(c.execute("SELECT num_classes FROM top").fetchone()[0])
 
     @cached_property
     def asr_configs(self) -> ASRConfigs:
         import json
 
         with self.db() as c:
-            return json.loads(c.execute("SELECT top.asr_configs FROM top").fetchone()[0])
+            return json.loads(c.execute("SELECT asr_configs FROM top").fetchone()[0])
 
     @cached_property
     def supported_metrics(self) -> MetricDocs:
@@ -223,36 +226,36 @@ class MixtureDatabase:
                     "mxssnrdbf_std",
                     "Per-bin segmental standard deviation of the dB frame values over all frames (using feature transform)",
                 ),
-                MetricDoc("Mixture Metrics", "mxpesq", "PESQ of mixture versus true targets"),
+                MetricDoc("Mixture Metrics", "mxpesq", "PESQ of mixture versus true sources"),
                 MetricDoc(
                     "Mixture Metrics",
                     "mxwsdr",
-                    "Weighted signal distortion ratio of mixture versus true targets",
+                    "Weighted signal distortion ratio of mixture versus true sources",
                 ),
                 MetricDoc(
                     "Mixture Metrics",
                     "mxpd",
-                    "Phase distance between mixture and true targets",
+                    "Phase distance between mixture and true sources",
                 ),
                 MetricDoc(
                     "Mixture Metrics",
                     "mxstoi",
-                    "Short term objective intelligibility of mixture versus true targets",
+                    "Short term objective intelligibility of mixture versus true sources",
                 ),
                 MetricDoc(
                     "Mixture Metrics",
                     "mxcsig",
-                    "Predicted rating of speech distortion of mixture versus true targets",
+                    "Predicted rating of speech distortion of mixture versus true sources",
                 ),
                 MetricDoc(
                     "Mixture Metrics",
                     "mxcbak",
-                    "Predicted rating of background distortion of mixture versus true targets",
+                    "Predicted rating of background distortion of mixture versus true sources",
                 ),
                 MetricDoc(
                     "Mixture Metrics",
                     "mxcovl",
-                    "Predicted rating of overall quality of mixture versus true targets",
+                    "Predicted rating of overall quality of mixture versus true sources",
                 ),
                 MetricDoc("Mixture Metrics", "ssnr", "Segmental SNR"),
                 MetricDoc("Mixture Metrics", "mxdco", "Mixture DC offset"),
@@ -265,26 +268,26 @@ class MixtureDatabase:
                 MetricDoc("Mixture Metrics", "mxcr", "Mixture Crest factor"),
                 MetricDoc("Mixture Metrics", "mxfl", "Mixture Flat factor"),
                 MetricDoc("Mixture Metrics", "mxpkc", "Mixture Pk count"),
-                MetricDoc("Mixture Metrics", "mxtdco", "Mixture target DC offset"),
-                MetricDoc("Mixture Metrics", "mxtmin", "Mixture target min level"),
-                MetricDoc("Mixture Metrics", "mxtmax", "Mixture target max levl"),
-                MetricDoc("Mixture Metrics", "mxtpkdb", "Mixture target Pk lev dB"),
-                MetricDoc("Mixture Metrics", "mxtlrms", "Mixture target RMS lev dB"),
-                MetricDoc("Mixture Metrics", "mxtpkr", "Mixture target RMS Pk dB"),
-                MetricDoc("Mixture Metrics", "mxttr", "Mixture target RMS Tr dB"),
-                MetricDoc("Mixture Metrics", "mxtcr", "Mixture target Crest factor"),
-                MetricDoc("Mixture Metrics", "mxtfl", "Mixture target Flat factor"),
-                MetricDoc("Mixture Metrics", "mxtpkc", "Mixture target Pk count"),
-                MetricDoc("Targets Metrics", "tdco", "Targets DC offset"),
-                MetricDoc("Targets Metrics", "tmin", "Targets min level"),
-                MetricDoc("Targets Metrics", "tmax", "Targets max levl"),
-                MetricDoc("Targets Metrics", "tpkdb", "Targets Pk lev dB"),
-                MetricDoc("Targets Metrics", "tlrms", "Targets RMS lev dB"),
-                MetricDoc("Targets Metrics", "tpkr", "Targets RMS Pk dB"),
-                MetricDoc("Targets Metrics", "ttr", "Targets RMS Tr dB"),
-                MetricDoc("Targets Metrics", "tcr", "Targets Crest factor"),
-                MetricDoc("Targets Metrics", "tfl", "Targets Flat factor"),
-                MetricDoc("Targets Metrics", "tpkc", "Targets Pk count"),
+                MetricDoc("Mixture Metrics", "mxtdco", "Mixture source DC offset"),
+                MetricDoc("Mixture Metrics", "mxtmin", "Mixture source min level"),
+                MetricDoc("Mixture Metrics", "mxtmax", "Mixture source max levl"),
+                MetricDoc("Mixture Metrics", "mxtpkdb", "Mixture source Pk lev dB"),
+                MetricDoc("Mixture Metrics", "mxtlrms", "Mixture source RMS lev dB"),
+                MetricDoc("Mixture Metrics", "mxtpkr", "Mixture source RMS Pk dB"),
+                MetricDoc("Mixture Metrics", "mxttr", "Mixture source RMS Tr dB"),
+                MetricDoc("Mixture Metrics", "mxtcr", "Mixture source Crest factor"),
+                MetricDoc("Mixture Metrics", "mxtfl", "Mixture source Flat factor"),
+                MetricDoc("Mixture Metrics", "mxtpkc", "Mixture source Pk count"),
+                MetricDoc("Sources Metrics", "sdco", "Sources DC offset"),
+                MetricDoc("Sources Metrics", "smin", "Sources min level"),
+                MetricDoc("Sources Metrics", "smax", "Sources max levl"),
+                MetricDoc("Sources Metrics", "spkdb", "Sources Pk lev dB"),
+                MetricDoc("Sources Metrics", "slrms", "Sources RMS lev dB"),
+                MetricDoc("Sources Metrics", "spkr", "Sources RMS Pk dB"),
+                MetricDoc("Sources Metrics", "str", "Sources RMS Tr dB"),
+                MetricDoc("Sources Metrics", "scr", "Sources Crest factor"),
+                MetricDoc("Sources Metrics", "sfl", "Sources Flat factor"),
+                MetricDoc("Sources Metrics", "spkc", "Sources Pk count"),
                 MetricDoc("Noise Metrics", "ndco", "Noise DC offset"),
                 MetricDoc("Noise Metrics", "nmin", "Noise min level"),
                 MetricDoc("Noise Metrics", "nmax", "Noise max levl"),
@@ -320,16 +323,16 @@ class MixtureDatabase:
         for name in self.asr_configs:
             metrics.append(
                 MetricDoc(
-                    "Target Metrics",
-                    f"mxtasr.{name}",
-                    f"Mixture Target ASR text using {name} ASR as defined in mixdb asr_configs parameter",
+                    "Source Metrics",
+                    f"mxsasr.{name}",
+                    f"Mixture Source ASR text using {name} ASR as defined in mixdb asr_configs parameter",
                 )
             )
             metrics.append(
                 MetricDoc(
-                    "Target Metrics",
-                    f"tasr.{name}",
-                    f"Targets ASR text using {name} ASR as defined in mixdb asr_configs parameter",
+                    "Source Metrics",
+                    f"sasr.{name}",
+                    f"Sources ASR text using {name} ASR as defined in mixdb asr_configs parameter",
                 )
             )
             metrics.append(
@@ -341,16 +344,16 @@ class MixtureDatabase:
             )
             metrics.append(
                 MetricDoc(
-                    "Target Metrics",
+                    "Source Metrics",
                     f"basewer.{name}",
-                    f"Word error rate of tasr.{name} vs. speech text metadata for the target",
+                    f"Word error rate of sasr.{name} vs. speech text metadata for the source",
                 )
             )
             metrics.append(
                 MetricDoc(
                     "Mixture Metrics",
                     f"mxwer.{name}",
-                    f"Word error rate of mxasr.{name} vs. tasr.{name}",
+                    f"Word error rate of mxasr.{name} vs. sasr.{name}",
                 )
             )
 
@@ -359,12 +362,12 @@ class MixtureDatabase:
     @cached_property
     def class_balancing(self) -> bool:
         with self.db() as c:
-            return bool(c.execute("SELECT top.class_balancing FROM top").fetchone()[0])
+            return bool(c.execute("SELECT class_balancing FROM top").fetchone()[0])
 
     @cached_property
     def feature(self) -> str:
         with self.db() as c:
-            return str(c.execute("SELECT top.feature FROM top").fetchone()[0])
+            return str(c.execute("SELECT feature FROM top").fetchone()[0])
 
     @cached_property
     def fg_decimation(self) -> int:
@@ -396,7 +399,7 @@ class MixtureDatabase:
 
     @cached_property
     def transform_frame_ms(self) -> float:
-        from .constants import SAMPLE_RATE
+        from ..constants import SAMPLE_RATE
 
         return float(self.ft_config.overlap) / float(SAMPLE_RATE / 1000)
 
@@ -417,12 +420,7 @@ class MixtureDatabase:
         return self.ft_config.overlap * self.fg_decimation * self.fg_step
 
     def total_samples(self, m_ids: GeneralizedIDs = "*") -> int:
-        samples = 0
-        for m_id in self.mixids_to_list(m_ids):
-            s = self.mixture(m_id).samples
-            if s is not None:
-                samples += s
-        return samples
+        return sum([self.mixture(m_id).samples for m_id in self.mixids_to_list(m_ids)])
 
     def total_transform_frames(self, m_ids: GeneralizedIDs = "*") -> int:
         return self.total_samples(m_ids) // self.ft_config.overlap
@@ -457,10 +455,7 @@ class MixtureDatabase:
         :return: Class labels
         """
         with self.db() as c:
-            return [
-                str(item[0])
-                for item in c.execute("SELECT class_label.label FROM class_label ORDER BY class_label.id").fetchall()
-            ]
+            return [str(item[0]) for item in c.execute("SELECT label FROM class_label ORDER BY id").fetchall()]
 
     @cached_property
     def class_weights_thresholds(self) -> list[float]:
@@ -469,37 +464,20 @@ class MixtureDatabase:
         :return: Class weights thresholds
         """
         with self.db() as c:
-            return [
-                float(item[0])
-                for item in c.execute(
-                    "SELECT class_weights_threshold.threshold FROM class_weights_threshold"
-                ).fetchall()
-            ]
-
-    @cached_property
-    def truth_configs(self) -> TruthConfigs:
-        """Get truth configs from db
-
-        :return: Truth configs
-        """
-        import json
+            return [float(item[0]) for item in c.execute("SELECT threshold FROM class_weights_threshold").fetchall()]
 
-        from .datatypes import TruthConfig
+    def category_truth_configs(self, category: str) -> dict[str, str]:
+        return _category_truth_configs(self.db, category, self.use_cache)
 
-        with self.db() as c:
-            truth_configs: TruthConfigs = {}
-            for truth_config_record in c.execute("SELECT truth_config.config FROM truth_config").fetchall():
-                truth_config = json.loads(truth_config_record[0])
-                if truth_config["name"] not in truth_configs:
-                    truth_configs[truth_config["name"]] = TruthConfig(
-                        function=truth_config["function"],
-                        stride_reduction=truth_config["stride_reduction"],
-                        config=truth_config["config"],
-                    )
-            return truth_configs
+    def source_truth_configs(self, s_id: int) -> TruthConfigs:
+        return _source_truth_configs(self.db, s_id, self.use_cache)
 
-    def target_truth_configs(self, t_id: int) -> TruthConfigs:
-        return _target_truth_configs(self.db, t_id, self.use_cache)
+    def mixture_truth_configs(self, m_id: int) -> TruthsConfigs:
+        mixture = self.mixture(m_id)
+        return {
+            category: self.source_truth_configs(mixture.all_sources[category].file_id)
+            for category in mixture.all_sources
+        }
 
     @cached_property
     def random_snrs(self) -> list[float]:
@@ -509,10 +487,7 @@ class MixtureDatabase:
         """
         with self.db() as c:
             return list(
-                {
-                    float(item[0])
-                    for item in c.execute("SELECT mixture.snr FROM mixture WHERE mixture.random_snr == 1").fetchall()
-                }
+                {float(item[0]) for item in c.execute("SELECT snr FROM source WHERE snr_random == 1").fetchall()}
             )
 
     @cached_property
@@ -523,10 +498,7 @@ class MixtureDatabase:
         """
         with self.db() as c:
             return list(
-                {
-                    float(item[0])
-                    for item in c.execute("SELECT mixture.snr FROM mixture WHERE mixture.random_snr == 0").fetchall()
-                }
+                {float(item[0]) for item in c.execute("SELECT snr FROM source WHERE snr_random == 0").fetchall()}
             )
 
     @cached_property
@@ -570,199 +542,216 @@ class MixtureDatabase:
         return _spectral_mask(self.db, sm_id, self.use_cache)
 
     @cached_property
-    def target_files(self) -> list[TargetFile]:
-        """Get target files from db
+    def source_files(self) -> dict[str, list[SourceFile]]:
+        """Get source files from db
 
-        :return: Target files
+        :return: Source files
         """
         import json
 
-        from .datatypes import TruthConfig
-        from .datatypes import TruthConfigs
-        from .db_datatypes import TargetFileRecord
+        from ..datatypes import TruthConfig
+        from ..datatypes import TruthConfigs
+        from .db_datatypes import SourceFileRecord
 
         with self.db() as c:
-            target_files: list[TargetFile] = []
-            target_file_records = [
-                TargetFileRecord(*result) for result in c.execute("SELECT * FROM target_file").fetchall()
-            ]
-            for target_file_record in target_file_records:
-                truth_configs: TruthConfigs = {}
-                for truth_config_records in c.execute(
-                    """
-                    SELECT truth_config.config
-                    FROM truth_config, target_file_truth_config
-                    WHERE ? = target_file_truth_config.target_file_id
-                    AND truth_config.id = target_file_truth_config.truth_config_id
-                    """,
-                    (target_file_record.id,),
-                ).fetchall():
-                    truth_config = json.loads(truth_config_records[0])
-                    truth_configs[truth_config["name"]] = TruthConfig(
-                        function=truth_config["function"],
-                        stride_reduction=truth_config["stride_reduction"],
-                        config=truth_config["config"],
-                    )
-                target_files.append(
-                    TargetFile(
-                        name=target_file_record.name,
-                        samples=target_file_record.samples,
-                        class_indices=json.loads(target_file_record.class_indices),
-                        level_type=target_file_record.level_type,
-                        truth_configs=truth_configs,
-                        speaker_id=target_file_record.speaker_id,
+            source_files: dict[str, list[SourceFile]] = {}
+            categories = c.execute("SELECT DISTINCT category FROM source_file").fetchall()
+            for category in categories:
+                source_files[category[0]] = []
+                source_file_records = [
+                    SourceFileRecord(*result)
+                    for result in c.execute("SELECT * FROM source_file WHERE ? = category", (category[0],)).fetchall()
+                ]
+                for source_file_record in source_file_records:
+                    truth_configs: TruthConfigs = {}
+                    for truth_config_records in c.execute(
+                        """
+                        SELECT truth_config.config
+                        FROM truth_config, source_file_truth_config
+                        WHERE ? = source_file_truth_config.source_file_id
+                        AND truth_config.id = source_file_truth_config.truth_config_id
+                        """,
+                        (source_file_record.id,),
+                    ).fetchall():
+                        truth_config = json.loads(truth_config_records[0])
+                        truth_configs[truth_config["name"]] = TruthConfig(
+                            function=truth_config["function"],
+                            stride_reduction=truth_config["stride_reduction"],
+                            config=truth_config["config"],
+                        )
+                    source_files[source_file_record.category].append(
+                        SourceFile(
+                            id=source_file_record.id,
+                            category=source_file_record.category,
+                            name=source_file_record.name,
+                            samples=source_file_record.samples,
+                            class_indices=json.loads(source_file_record.class_indices),
+                            level_type=source_file_record.level_type,
+                            truth_configs=truth_configs,
+                            speaker_id=source_file_record.speaker_id,
+                        )
                     )
-                )
-            return target_files
+            return source_files
 
     @cached_property
-    def target_file_ids(self) -> list[int]:
-        """Get target file IDs from db
+    def source_file_ids(self) -> dict[str, list[int]]:
+        """Get source file IDs from db
 
-        :return: List of target file IDs
+        :return: Dictionary of list of source file IDs
         """
         with self.db() as c:
-            return [int(item[0]) for item in c.execute("SELECT target_file.id FROM target_file").fetchall()]
+            source_file_ids: dict[str, list[int]] = {}
+            categories = c.execute("SELECT DISTINCT category FROM source_file").fetchall()
+            for category in categories:
+                source_file_ids[category[0]] = [
+                    int(item[0])
+                    for item in c.execute("SELECT id FROM source_file WHERE ? = category", (category[0],)).fetchall()
+                ]
+            return source_file_ids
 
-    def target_file(self, t_id: int) -> TargetFile:
-        """Get target file with ID from db
+    def source_file(self, s_id: int) -> SourceFile:
+        """Get source file with ID from db
 
-        :param t_id: Target file ID
-        :return: Target file
+        :param s_id: Source file ID
+        :return: Source file
         """
-        return _target_file(self.db, t_id, self.use_cache)
+        return _source_file(self.db, s_id, self.use_cache)
 
-    @cached_property
-    def num_target_files(self) -> int:
-        """Get number of target files from db
+    def num_source_files(self, category: str) -> int:
+        """Get number of source files from category from db
 
-        :return: Number of target files
+        :param category: Source category
+        :return: Number of source files
         """
-        with self.db() as c:
-            return int(c.execute("SELECT count(target_file.id) FROM target_file").fetchone()[0])
+        return _num_source_files(self.db, category, self.use_cache)
 
     @cached_property
-    def noise_files(self) -> list[NoiseFile]:
-        """Get noise files from db
+    def ir_files(self) -> list[ImpulseResponseFile]:
+        """Get impulse response files from db
 
-        :return: Noise files
+        :return: Impulse response files
         """
-        with self.db() as c:
-            return [
-                NoiseFile(name=noise[0], samples=noise[1])
-                for noise in c.execute("SELECT noise_file.name, samples FROM noise_file").fetchall()
-            ]
-
-    @cached_property
-    def noise_file_ids(self) -> list[int]:
-        """Get noise file IDs from db
+        from .db_datatypes import ImpulseResponseFileRecord
 
-        :return: List of noise file IDs
-        """
         with self.db() as c:
-            return [int(item[0]) for item in c.execute("SELECT noise_file.id FROM noise_file").fetchall()]
+            files: list[ImpulseResponseFile] = []
+            entries = c.execute("SELECT * FROM ir_file").fetchall()
+            for entry in entries:
+                file = ImpulseResponseFileRecord(*entry)
+
+                tags = [
+                    tag[0]
+                    for tag in c.execute(
+                        """
+                SELECT ir_tag.tag
+                FROM ir_tag, ir_file_ir_tag
+                WHERE ? = ir_file_ir_tag.file_id
+                AND ir_tag.id = ir_file_ir_tag.tag_id
+                """,
+                        (file.id,),
+                    ).fetchall()
+                ]
 
-    def noise_file(self, n_id: int) -> NoiseFile:
-        """Get noise file with ID from db
+                files.append(
+                    ImpulseResponseFile(
+                        delay=file.delay,
+                        name=file.name,
+                        tags=tags,
+                    )
+                )
 
-        :param n_id: Noise file ID
-        :return: Noise file
-        """
-        return _noise_file(self.db, n_id, self.use_cache)
+            return files
 
     @cached_property
-    def num_noise_files(self) -> int:
-        """Get number of noise files from db
+    def ir_file_ids(self) -> list[int]:
+        """Get impulse response file IDs from db
 
-        :return: Number of noise files
+        :return: List of impulse response file IDs
         """
         with self.db() as c:
-            return int(c.execute("SELECT count(noise_file.id) FROM noise_file").fetchone()[0])
+            return [int(item[0]) for item in c.execute("SELECT id FROM ir_file").fetchall()]
 
-    @cached_property
-    def impulse_response_files(self) -> list[ImpulseResponseFile]:
-        """Get impulse response files from db
+    def ir_file_ids_for_tag(self, tag: str) -> list[int]:
+        """Get impulse response file IDs for given tag from db
 
-        :return: Impulse response files
+        :return: List of impulse response file IDs for given tag
         """
-        import json
-
-        from .datatypes import ImpulseResponseFile
-
         with self.db() as c:
-            return [
-                ImpulseResponseFile(impulse_response[1], json.loads(impulse_response[2]), impulse_response[3])
-                for impulse_response in c.execute(
-                    "SELECT impulse_response_file.* FROM impulse_response_file"
-                ).fetchall()
-            ]
-
-    @cached_property
-    def impulse_response_file_ids(self) -> list[int]:
-        """Get impulse response file IDs from db
+            tag_id = c.execute("SELECT id FROM ir_tag WHERE ? = tag", (tag,)).fetchone()
+            if not tag_id:
+                return []
 
-        :return: List of impulse response file IDs
-        """
-        with self.db() as c:
             return [
-                int(item[0])
-                for item in c.execute("SELECT impulse_response_file.id FROM impulse_response_file").fetchall()
+                int(item[0] - 1)
+                for item in c.execute("SELECT file_id FROM ir_file_ir_tag WHERE ? = tag_id", (tag_id[0],)).fetchall()
             ]
 
-    def impulse_response_file(self, ir_id: int | None) -> str | None:
+    def ir_file(self, ir_id: int) -> str:
         """Get impulse response file name with ID from db
 
         :param ir_id: Impulse response file ID
         :return: Impulse response file name
         """
-        if ir_id is None:
-            return None
-        return _impulse_response_file(self.db, ir_id, self.use_cache)
+        return _ir_file(self.db, ir_id, self.use_cache)
 
-    def impulse_response_delay(self, ir_id: int | None) -> int | None:
+    def ir_delay(self, ir_id: int) -> int:
         """Get impulse response delay with ID from db
 
         :param ir_id: Impulse response file ID
         :return: Impulse response delay
         """
-        if ir_id is None:
-            return None
-        return _impulse_response_delay(self.db, ir_id, self.use_cache)
+        return _ir_delay(self.db, ir_id, self.use_cache)
 
     @cached_property
-    def num_impulse_response_files(self) -> int:
+    def num_ir_files(self) -> int:
         """Get number of impulse response files from db
 
         :return: Number of impulse response files
         """
         with self.db() as c:
-            return int(c.execute("SELECT count(impulse_response_file.id) FROM impulse_response_file").fetchone()[0])
+            return int(c.execute("SELECT count(id) FROM ir_file").fetchone()[0])
 
+    @cached_property
+    def ir_tags(self) -> list[str]:
+        """Get tags of impulse response files from db
+
+        :return: Tags of impulse response files
+        """
+        with self.db() as c:
+            return [tag[0] for tag in c.execute("SELECT tag FROM ir_tag").fetchall()]
+
+    @property
     def mixtures(self) -> list[Mixture]:
         """Get mixtures from db
 
         :return: Mixtures
         """
         from .db_datatypes import MixtureRecord
-        from .db_datatypes import TargetRecord
+        from .db_datatypes import SourceRecord
         from .helpers import to_mixture
-        from .helpers import to_target
+        from .helpers import to_source
 
         with self.db() as c:
             mixtures: list[Mixture] = []
             for mixture in [MixtureRecord(*record) for record in c.execute("SELECT * FROM mixture").fetchall()]:
-                targets = [
-                    to_target(TargetRecord(*target))
-                    for target in c.execute(
+                sources_list = [
+                    to_source(SourceRecord(*source))
+                    for source in c.execute(
                         """
-                        SELECT target.*
-                        FROM target, mixture_target
-                        WHERE ? = mixture_target.mixture_id AND target.id = mixture_target.target_id
+                        SELECT source.*
+                        FROM source, mixture_source
+                        WHERE ? = mixture_source.mixture_id AND source.id = mixture_source.source_id
                         """,
                         (mixture.id,),
                     ).fetchall()
                 ]
-                mixtures.append(to_mixture(mixture, targets))
+
+                sources: Sources = {}
+                for source in sources_list:
+                    sources[self.source_file(source.file_id).category] = source
+
+                mixtures.append(to_mixture(mixture, sources))
+
             return mixtures
 
     @cached_property
@@ -772,7 +761,7 @@ class MixtureDatabase:
         :return: List of zero-based mixture IDs
         """
         with self.db() as c:
-            return [int(item[0]) - 1 for item in c.execute("SELECT mixture.id FROM mixture").fetchall()]
+            return [int(item[0]) - 1 for item in c.execute("SELECT id FROM mixture").fetchall()]
 
     def mixture(self, m_id: int) -> Mixture:
         """Get mixture record with ID from db
@@ -785,7 +774,7 @@ class MixtureDatabase:
     @cached_property
     def mixid_width(self) -> int:
         with self.db() as c:
-            return int(c.execute("SELECT top.mixid_width FROM top").fetchone()[0])
+            return int(c.execute("SELECT mixid_width FROM top").fetchone()[0])
 
     def mixture_location(self, m_id: int) -> str:
         """Get the file location for the give mixture ID
@@ -804,231 +793,342 @@ class MixtureDatabase:
         :return: Number of mixtures
         """
         with self.db() as c:
-            return int(c.execute("SELECT count(mixture.id) FROM mixture").fetchone()[0])
+            return int(c.execute("SELECT count(id) FROM mixture").fetchone()[0])
 
-    def read_mixture_data(self, m_id: int, items: list[str] | str) -> Any:
+    def read_mixture_data(self, m_id: int, items: list[str] | str) -> dict[str, Any]:
         """Read mixture data
 
         :param m_id: Zero-based mixture ID
         :param items: String(s) of dataset(s) to retrieve
-        :return: Data (or tuple of data)
+        :return: Dictionary of name: data
         """
-        from sonusai.mixture import read_cached_data
+        from .data_io import read_cached_data
 
         return read_cached_data(self.location, "mixture", self.mixture(m_id).name, items)
 
-    def read_target_audio(self, t_id: int) -> AudioT:
-        """Read target audio
+    def read_source_audio(self, s_id: int) -> AudioT:
+        """Read source audio
 
-        :param t_id: Target ID
-        :return: Target audio
+        :param s_id: Source ID
+        :return: Source audio
         """
         from .audio import read_audio
 
-        return read_audio(self.target_file(t_id).name, self.use_cache)
-
-    def augmented_noise_audio(self, mixture: Mixture) -> AudioT:
-        """Get augmented noise audio
-
-        :param mixture: Mixture
-        :return: Augmented noise audio
-        """
-        from .audio import read_audio
-        from .augmentation import apply_augmentation
-
-        noise = self.noise_file(mixture.noise.file_id)
-        audio = read_audio(noise.name, self.use_cache)
-        audio = apply_augmentation(self, audio, mixture.noise.augmentation.pre)
-
-        return audio
+        return read_audio(self.source_file(s_id).name, self.use_cache)
 
     def mixture_class_indices(self, m_id: int) -> list[int]:
         class_indices: list[int] = []
-        for t_id in self.mixture(m_id).target_ids:
-            class_indices.extend(self.target_file(t_id).class_indices)
+        for s_id in self.mixture(m_id).source_ids.values():
+            class_indices.extend(self.source_file(s_id).class_indices)
         return sorted(set(class_indices))
 
-    def mixture_targets(self, m_id: int, force: bool = False) -> list[AudioT]:
-        """Get the list of augmented target audio data (one per target in the mixup) for the given mixture ID
+    def mixture_sources(self, m_id: int, force: bool = False, cache: bool = False) -> SourcesAudioT:
+        """Get the pre-truth source audio data (one per source in the mixture) for the given mixture ID
 
         :param m_id: Zero-based mixture ID
         :param force: Force computing data from original sources regardless of whether cached data exists
-        :return: List of augmented target audio data (one per target in the mixup)
+        :param cache: Cache result
+        :return: Dictionary of pre-truth source audio data (one per source in the mixture)
         """
-        from .augmentation import apply_augmentation
-        from .augmentation import apply_gain
-        from .augmentation import pad_audio_to_length
+        from .data_io import write_cached_data
+        from .effects import apply_effects
+        from .effects import conform_audio_to_length
 
         if not force:
-            targets_audio = self.read_mixture_data(m_id, "targets")
-            if targets_audio is not None:
-                return list(targets_audio)
+            sources = self.read_mixture_data(m_id, "sources")["sources"]
+            if sources is not None:
+                return sources
 
         mixture = self.mixture(m_id)
         if mixture is None:
             raise ValueError(f"Could not find mixture for m_id: {m_id}")
 
-        targets_audio = []
-        for target in mixture.targets:
-            target_audio = self.read_target_audio(target.file_id)
-            target_audio = apply_augmentation(
-                mixdb=self,
-                audio=target_audio,
-                augmentation=target.augmentation.pre,
-                frame_length=self.feature_step_samples,
+        sources = {}
+        for category, source in mixture.all_sources.items():
+            source = mixture.all_sources[category]
+            audio = self.read_source_audio(source.file_id)
+            audio = apply_effects(self, audio, source.effects, pre=True, post=False)
+            audio = conform_audio_to_length(audio, mixture.samples, source.repeat, source.start)
+            sources[category] = audio
+
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=mixture.name,
+                items={"sources": sources},
             )
-            target_audio = apply_gain(audio=target_audio, gain=mixture.target_snr_gain)
-            target_audio = pad_audio_to_length(audio=target_audio, length=mixture.samples)
-            targets_audio.append(target_audio)
 
-        return targets_audio
+        return sources
 
-    def mixture_targets_f(self, m_id: int, targets: list[AudioT] | None = None, force: bool = False) -> list[AudioF]:
-        """Get the list of augmented target transform data (one per target in the mixup) for the given mixture ID
+    def mixture_sources_f(
+        self,
+        m_id: int,
+        sources: SourcesAudioT | None = None,
+        force: bool = False,
+        cache: bool = False,
+    ) -> SourcesAudioF:
+        """Get the pre-truth source transform data (one per source in the mixture) for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup)
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
         :param force: Force computing data from original sources regardless of whether cached data exists
-        :return: List of augmented target transform data (one per target in the mixup)
+        :param cache: Cache result
+        :return: Dictionary of pre-truth source transform data (one per source in the mixture)
         """
+        from .data_io import write_cached_data
         from .helpers import forward_transform
 
-        if force or targets is None:
-            targets = self.mixture_targets(m_id, force)
+        if sources is None:
+            sources = self.mixture_sources(m_id, force)
 
-        return [forward_transform(target, self.ft_config) for target in targets]
+        sources_f = {category: forward_transform(sources[category], self.ft_config) for category in sources}
 
-    def mixture_target(self, m_id: int, targets: list[AudioT] | None = None, force: bool = False) -> AudioT:
-        """Get the augmented target audio data for the given mixture ID
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"sources_f": sources_f},
+            )
+
+        return sources_f
+
+    def mixture_source(
+        self,
+        m_id: int,
+        sources: SourcesAudioT | None = None,
+        force: bool = False,
+        cache: bool = False,
+    ) -> AudioT:
+        """Get the post-truth, summed, and gained source audio data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup)
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
         :param force: Force computing data from original sources regardless of whether cached data exists
-        :return: Augmented target audio data
+        :param cache: Cache result
+        :return: Post-truth, gained, and summed source audio data
         """
-        from .helpers import get_target
+        import numpy as np
+
+        from .data_io import write_cached_data
+        from .effects import apply_effects
 
         if not force:
-            target = self.read_mixture_data(m_id, "target")
-            if target is not None:
-                return target
+            source = self.read_mixture_data(m_id, "source")["source"]
+            if source is not None:
+                return source
+
+        if sources is None:
+            sources = self.mixture_sources(m_id, force)
+
+        mixture = self.mixture(m_id)
 
-        if force or targets is None:
-            targets = self.mixture_targets(m_id, force)
+        source = np.sum(
+            [
+                apply_effects(
+                    self,
+                    audio=sources[category],
+                    effects=mixture.all_sources[category].effects,
+                    pre=False,
+                    post=True,
+                )
+                * mixture.all_sources[category].snr_gain
+                for category in sources
+                if category != "noise"
+            ],
+            axis=0,
+        )
 
-        return get_target(self, self.mixture(m_id), targets)
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=mixture.name,
+                items={"source": source},
+            )
+
+        return source
 
-    def mixture_target_f(
+    def mixture_source_f(
         self,
         m_id: int,
-        targets: list[AudioT] | None = None,
-        target: AudioT | None = None,
+        sources: SourcesAudioT | None = None,
+        source: AudioT | None = None,
         force: bool = False,
+        cache: bool = False,
     ) -> AudioF:
-        """Get the augmented target transform data for the given mixture ID
+        """Get the post-truth, summed, and gained source transform data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup)
-        :param target: Augmented target audio for the given m_id
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
+        :param source: Post-truth, gained, and summed source audio for the given m_id
         :param force: Force computing data from original sources regardless of whether cached data exists
-        :return: Augmented target transform data
+        :param cache: Cache result
+        :return: Post-truth, gained, and summed source transform data
         """
+        from .data_io import write_cached_data
         from .helpers import forward_transform
 
-        if force or target is None:
-            target = self.mixture_target(m_id, targets, force)
+        if source is None:
+            source = self.mixture_source(m_id, sources, force)
 
-        return forward_transform(target, self.ft_config)
+        source_f = forward_transform(source, self.ft_config)
 
-    def mixture_noise(self, m_id: int, force: bool = False) -> AudioT:
-        """Get the augmented noise audio data for the given mixture ID
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"source_f": source_f},
+            )
+
+        return source_f
+
+    def mixture_noise(
+        self,
+        m_id: int,
+        sources: SourcesAudioT | None = None,
+        force: bool = False,
+        cache: bool = False,
+    ) -> AudioT:
+        """Get the post-truth and gained noise audio data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
         :param force: Force computing data from original sources regardless of whether cached data exists
-        :return: Augmented noise audio data
+        :param cache: Cache result
+        :return: Post-truth and gained noise audio data
         """
-        from .audio import get_next_noise
-        from .augmentation import apply_gain
+        from .data_io import write_cached_data
+        from .effects import apply_effects
 
         if not force:
-            noise = self.read_mixture_data(m_id, "noise")
+            noise = self.read_mixture_data(m_id, "noise")["noise"]
             if noise is not None:
                 return noise
 
-        mixture = self.mixture(m_id)
-        noise = self.augmented_noise_audio(mixture)
-        noise = get_next_noise(audio=noise, offset=mixture.noise_offset, length=mixture.samples)
-        return apply_gain(audio=noise, gain=mixture.noise_snr_gain)
+        if sources is None:
+            sources = self.mixture_sources(m_id, force)
 
-    def mixture_noise_f(self, m_id: int, noise: AudioT | None = None, force: bool = False) -> AudioF:
-        """Get the augmented noise transform for the given mixture ID
+        noise = self.mixture(m_id).noise
+        noise = apply_effects(self, sources["noise"], noise.effects, pre=False, post=True) * noise.snr_gain
+
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"noise": noise},
+            )
+
+        return noise
+
+    def mixture_noise_f(
+        self,
+        m_id: int,
+        sources: SourcesAudioT | None = None,
+        noise: AudioT | None = None,
+        force: bool = False,
+        cache: bool = False,
+    ) -> AudioF:
+        """Get the post-truth and gained noise transform for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param noise: Augmented noise audio data
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
+        :param noise: Post-truth and gained noise audio data
         :param force: Force computing data from original sources regardless of whether cached data exists
-        :return: Augmented noise transform data
+        :param cache: Cache result
+        :return: Post-truth and gained noise transform data
         """
+        from .data_io import write_cached_data
         from .helpers import forward_transform
 
         if force or noise is None:
-            noise = self.mixture_noise(m_id, force)
+            noise = self.mixture_noise(m_id, sources, force)
+
+        noise_f = forward_transform(noise, self.ft_config)
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"noise_f": noise_f},
+            )
 
-        return forward_transform(noise, self.ft_config)
+        return noise_f
 
     def mixture_mixture(
         self,
         m_id: int,
-        targets: list[AudioT] | None = None,
-        target: AudioT | None = None,
+        sources: SourcesAudioT | None = None,
+        source: AudioT | None = None,
         noise: AudioT | None = None,
         force: bool = False,
+        cache: bool = False,
     ) -> AudioT:
         """Get the mixture audio data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup)
-        :param target: Augmented target audio data
-        :param noise: Augmented noise audio data
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
+        :param source: Post-truth, gained, and summed source audio data
+        :param noise: Post-truth and gained noise audio data
         :param force: Force computing data from original sources regardless of whether cached data exists
+        :param cache: Cache result
         :return: Mixture audio data
         """
+        from .data_io import write_cached_data
+
         if not force:
-            mixture = self.read_mixture_data(m_id, "mixture")
+            mixture = self.read_mixture_data(m_id, "mixture")["mixture"]
             if mixture is not None:
                 return mixture
 
-        if force or target is None:
-            target = self.mixture_target(m_id, targets, force)
+        if source is None:
+            source = self.mixture_source(m_id, sources, force)
 
-        if force or noise is None:
-            noise = self.mixture_noise(m_id, force)
+        if noise is None:
+            noise = self.mixture_noise(m_id, sources, force)
+
+        mixture = source + noise
 
-        return target + noise
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"mixture": mixture},
+            )
+
+        return mixture
 
     def mixture_mixture_f(
         self,
         m_id: int,
-        targets: list[AudioT] | None = None,
-        target: AudioT | None = None,
+        sources: SourcesAudioT | None = None,
+        source: AudioT | None = None,
         noise: AudioT | None = None,
         mixture: AudioT | None = None,
         force: bool = False,
+        cache: bool = False,
     ) -> AudioF:
         """Get the mixture transform for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup)
-        :param target: Augmented target audio data
-        :param noise: Augmented noise audio data
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
+        :param source: Post-truth, gained, and summed source audio data
+        :param noise: Post-truth and gained noise audio data
         :param mixture: Mixture audio data
         :param force: Force computing data from original sources regardless of whether cached data exists
+        :param cache: Cache result
         :return: Mixture transform data
         """
+        from .data_io import write_cached_data
         from .helpers import forward_transform
         from .spectral_mask import apply_spectral_mask
 
-        if force or mixture is None:
-            mixture = self.mixture_mixture(m_id, targets, target, noise, force)
+        if mixture is None:
+            mixture = self.mixture_mixture(m_id, sources, source, noise, force)
 
         mixture_f = forward_transform(mixture, self.ft_config)
 
@@ -1040,80 +1140,79 @@ class MixtureDatabase:
                 seed=m.spectral_mask_seed,
             )
 
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"mixture_f": mixture_f},
+            )
+
         return mixture_f
 
-    def mixture_truth_t(
-        self,
-        m_id: int,
-        targets: list[AudioT] | None = None,
-        noise: AudioT | None = None,
-        mixture: AudioT | None = None,
-        force: bool = False,
-    ) -> list[TruthDict]:
+    def mixture_truth_t(self, m_id: int, force: bool = False, cache: bool = False) -> TruthsDict:
         """Get the truth_t data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup) for the given mixture ID
-        :param noise: Augmented noise audio data for the given mixture ID
-        :param mixture: Mixture audio data for the given mixture ID
         :param force: Force computing data from original sources regardless of whether cached data exists
+        :param cache: Cache result
         :return: list of truth_t data
         """
+        from .data_io import write_cached_data
         from .truth import truth_function
 
         if not force:
-            truth_t = self.read_mixture_data(m_id, "truth_t")
+            truth_t = self.read_mixture_data(m_id, "truth_t")["truth_t"]
             if truth_t is not None:
                 return truth_t
 
-        if force or targets is None:
-            targets = self.mixture_targets(m_id, force)
-
-        if force or noise is None:
-            noise = self.mixture_noise(m_id, force)
-
-        if force or mixture is None:
-            mixture = self.mixture_mixture(m_id, targets=targets, noise=noise, force=force)
-
-        if not all(len(target) == self.mixture(m_id).samples for target in targets):
-            raise ValueError("Lengths of targets do not match length of mixture")
+        truth_t = truth_function(self, m_id)
 
-        if len(noise) != self.mixture(m_id).samples:
-            raise ValueError("Length of noise does not match length of mixture")
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"truth_t": truth_t},
+            )
 
-        return truth_function(self, m_id)
+        return truth_t
 
     def mixture_segsnr_t(
         self,
         m_id: int,
-        targets: list[AudioT] | None = None,
-        target: AudioT | None = None,
+        sources: SourcesAudioT | None = None,
+        source: AudioT | None = None,
         noise: AudioT | None = None,
         force: bool = False,
+        cache: bool = False,
     ) -> Segsnr:
         """Get the segsnr_t data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup)
-        :param target: Augmented target audio data
-        :param noise: Augmented noise audio data
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
+        :param source: Post-truth, gained, and summed source audio data
+        :param noise: Post-truth and gained noise audio data
         :param force: Force computing data from original sources regardless of whether cached data exists
+        :param cache: Cache result
         :return: segsnr_t data
         """
         import numpy as np
         import torch
         from pyaaware import ForwardTransform
 
+        from .data_io import write_cached_data
+
         if not force:
-            segsnr_t = self.read_mixture_data(m_id, "segsnr_t")
+            segsnr_t = self.read_mixture_data(m_id, "segsnr_t")["segsnr_t"]
             if segsnr_t is not None:
                 return segsnr_t
 
-        if force or target is None:
-            target = self.mixture_target(m_id, targets, force)
+        if source is None:
+            source = self.mixture_source(m_id, sources, force)
 
-        if force or noise is None:
-            noise = self.mixture_noise(m_id, force)
+        if noise is None:
+            noise = self.mixture_noise(m_id, sources, force)
 
         ft = ForwardTransform(
             length=self.ft_config.length,
@@ -1127,13 +1226,13 @@ class MixtureDatabase:
 
         segsnr_t = np.empty(mixture.samples, dtype=np.float32)
 
-        target_energy = ft.execute_all(torch.from_numpy(target))[1].numpy()
+        source_energy = ft.execute_all(torch.from_numpy(source))[1].numpy()
         noise_energy = ft.execute_all(torch.from_numpy(noise))[1].numpy()
 
         offsets = range(0, mixture.samples, self.ft_config.overlap)
-        if len(target_energy) != len(offsets):
+        if len(source_energy) != len(offsets):
             raise ValueError(
-                f"Number of frames in energy, {len(target_energy)}, is not number of frames in mixture, {len(offsets)}"
+                f"Number of frames in energy, {len(source_energy)}, is not number of frames in mixture, {len(offsets)}"
             )
 
         for idx, offset in enumerate(offsets):
@@ -1142,187 +1241,242 @@ class MixtureDatabase:
             if noise_energy[idx] == 0:
                 snr = np.float32(np.inf)
             else:
-                snr = np.float32(target_energy[idx] / noise_energy[idx])
+                snr = np.float32(source_energy[idx] / noise_energy[idx])
 
             segsnr_t[indices] = snr
 
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=mixture.name,
+                items={"segsnr_t": segsnr_t},
+            )
+
         return segsnr_t
 
     def mixture_segsnr(
         self,
         m_id: int,
         segsnr_t: Segsnr | None = None,
-        targets: list[AudioT] | None = None,
-        target: AudioT | None = None,
+        sources: SourcesAudioT | None = None,
+        source: AudioT | None = None,
         noise: AudioT | None = None,
         force: bool = False,
+        cache: bool = False,
     ) -> Segsnr:
         """Get the segsnr data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
         :param segsnr_t: segsnr_t data
-        :param targets: List of augmented target audio data (one per target in the mixup)
-        :param target: Augmented target audio data
-        :param noise: Augmented noise audio data
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
+        :param source: Post-truth, gained, and summed source audio data
+        :param noise: Post-truth and gained noise audio data
         :param force: Force computing data from original sources regardless of whether cached data exists
+        :param cache: Cache result
         :return: segsnr data
         """
+        from .data_io import write_cached_data
+
         if not force:
-            segsnr = self.read_mixture_data(m_id, "segsnr")
+            segsnr = self.read_mixture_data(m_id, "segsnr")["segsnr"]
             if segsnr is not None:
                 return segsnr
 
-            segsnr_t = self.read_mixture_data(m_id, "segsnr_t")
-            if segsnr_t is not None:
-                return segsnr_t[0 :: self.ft_config.overlap]
+        if segsnr_t is None:
+            segsnr_t = self.mixture_segsnr_t(m_id, sources, source, noise, force)
 
-        if force or segsnr_t is None:
-            segsnr_t = self.mixture_segsnr_t(m_id, targets, target, noise, force)
+        segsnr = segsnr_t[0 :: self.ft_config.overlap]
 
-        return segsnr_t[0 :: self.ft_config.overlap]
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"segsnr": segsnr},
+            )
+
+        return segsnr
 
     def mixture_ft(
         self,
         m_id: int,
-        targets: list[AudioT] | None = None,
-        target: AudioT | None = None,
+        sources: SourcesAudioT | None = None,
+        source: AudioT | None = None,
         noise: AudioT | None = None,
         mixture_f: AudioF | None = None,
         mixture: AudioT | None = None,
-        truth_t: list[TruthDict] | None = None,
+        truth_t: TruthsDict | None = None,
         force: bool = False,
-    ) -> tuple[Feature, TruthDict]:
+        cache: bool = False,
+    ) -> tuple[Feature, TruthsDict]:
         """Get the feature and truth_f data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup)
-        :param target: Augmented target audio data
-        :param noise: Augmented noise audio data
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
+        :param source: Post-truth, gained, and summed source audio data
+        :param noise: Post-truth and gained noise audio data
         :param mixture_f: Mixture transform data
         :param mixture: Mixture audio data
         :param truth_t: truth_t
         :param force: Force computing data from original sources regardless of whether cached data exists
+        :param cache: Cache result
         :return: Tuple of (feature, truth_f) data
         """
         from pyaaware import FeatureGenerator
 
+        from .data_io import write_cached_data
         from .truth import truth_stride_reduction
 
         if not force:
-            feature, truth_f = self.read_mixture_data(m_id, ["feature", "truth_f"])
-            if feature is not None and truth_f is not None:
-                return feature, truth_f
+            ft = self.read_mixture_data(m_id, ["feature", "truth_f"])
+            if ft["feature"] is not None and ft["truth_f"] is not None:
+                return ft["feature"], ft["truth_f"]
 
-        if force or mixture_f is None:
+        if mixture_f is None:
             mixture_f = self.mixture_mixture_f(
                 m_id=m_id,
-                targets=targets,
-                target=target,
+                sources=sources,
+                source=source,
                 noise=noise,
                 mixture=mixture,
                 force=force,
             )
 
-        if force or truth_t is None:
-            truth_t = self.mixture_truth_t(m_id=m_id, targets=targets, noise=noise, force=force)
+        if truth_t is None:
+            truth_t = self.mixture_truth_t(m_id, force)
 
         fg = FeatureGenerator(self.fg_config.feature_mode, self.fg_config.truth_parameters)
 
-        # TODO: handle mixup in truth_t
-        feature, truth_f = fg.execute_all(mixture_f, truth_t[0])
+        feature, truth_f = fg.execute_all(mixture_f, truth_t)
         if truth_f is not None:
-            for key in self.truth_configs:
-                if self.truth_parameters[key] is not None:
-                    truth_f[key] = truth_stride_reduction(truth_f[key], self.truth_configs[key].stride_reduction)
+            truth_configs = self.mixture_truth_configs(m_id)
+            for category, configs in truth_configs.items():
+                for name, config in configs.items():
+                    if self.truth_parameters[category][name] is not None:
+                        truth_f[category][name] = truth_stride_reduction(
+                            truth_f[category][name], config.stride_reduction
+                        )
         else:
             raise TypeError("Unexpected truth of None from feature generator")
 
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"feature": truth_f, "truth_f": truth_f},
+            )
+
         return feature, truth_f
 
     def mixture_feature(
         self,
         m_id: int,
-        targets: list[AudioT] | None = None,
+        sources: SourcesAudioT | None = None,
         noise: AudioT | None = None,
         mixture: AudioT | None = None,
-        truth_t: list[TruthDict] | None = None,
+        truth_t: TruthsDict | None = None,
         force: bool = False,
+        cache: bool = False,
     ) -> Feature:
         """Get the feature data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup)
-        :param noise: Augmented noise audio data
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
+        :param noise: Post-truth and gained noise audio data
         :param mixture: Mixture audio data
         :param truth_t: truth_t
         :param force: Force computing data from original sources regardless of whether cached data exists
+        :param cache: Cache result
         :return: Feature data
         """
-        feature, _ = self.mixture_ft(
+        from .data_io import write_cached_data
+
+        feature = self.mixture_ft(
             m_id=m_id,
-            targets=targets,
+            sources=sources,
             noise=noise,
             mixture=mixture,
             truth_t=truth_t,
             force=force,
-        )
+        )[0]
+
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"feature": feature},
+            )
+
         return feature
 
     def mixture_truth_f(
         self,
         m_id: int,
-        targets: list[AudioT] | None = None,
+        sources: SourcesAudioT | None = None,
         noise: AudioT | None = None,
         mixture: AudioT | None = None,
-        truth_t: list[TruthDict] | None = None,
+        truth_t: TruthsDict | None = None,
         force: bool = False,
+        cache: bool = False,
     ) -> TruthDict:
         """Get the truth_f data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio data (one per target in the mixup)
-        :param noise: Augmented noise audio data
+        :param sources: Dictionary of pre-truth source audio data (one per source in the mixture)
+        :param noise: Post-truth and gained noise audio data
         :param mixture: Mixture audio data
         :param truth_t: truth_t
         :param force: Force computing data from original sources regardless of whether cached data exists
+        :param cache: Cache result
         :return: truth_f data
         """
-        _, truth_f = self.mixture_ft(
+        from .data_io import write_cached_data
+
+        truth_f = self.mixture_ft(
             m_id=m_id,
-            targets=targets,
+            sources=sources,
             noise=noise,
             mixture=mixture,
             truth_t=truth_t,
             force=force,
-        )
+        )[1]
+
+        if cache:
+            write_cached_data(
+                location=self.location,
+                name="mixture",
+                index=self.mixture(m_id).name,
+                items={"truth_f": truth_f},
+            )
+
         return truth_f
 
-    def mixture_class_count(
-        self,
-        m_id: int,
-        targets: list[AudioT] | None = None,
-        noise: AudioT | None = None,
-        truth_t: list[TruthDict] | None = None,
-    ) -> ClassCount:
+    def mixture_class_count(self, m_id: int, truth_t: TruthsDict | None = None) -> dict[str, ClassCount]:
         """Compute the number of frames for which each class index is active for the given mixture ID
 
         :param m_id: Zero-based mixture ID
-        :param targets: List of augmented target audio (one per target in the mixup)
-        :param noise: Augmented noise audio
         :param truth_t: truth_t
-        :return: List of class counts
+        :return: Dictionary of class counts
         """
         import numpy as np
 
         if truth_t is None:
-            truth_t = self.mixture_truth_t(m_id, targets, noise)
+            truth_t = self.mixture_truth_t(m_id)
 
-        class_count = [0] * self.num_classes
-        num_classes = self.num_classes
-        if "sed" in self.truth_configs:
-            for cl in range(num_classes):
-                # TODO: handle mixup in truth_t
-                class_count[cl] = int(np.sum(truth_t[0]["sed"][:, cl] >= self.class_weights_thresholds[cl]))
+        class_count: dict[str, ClassCount] = {}
+
+        truth_configs = self.mixture_truth_configs(m_id)
+        for category in truth_configs:
+            class_count[category] = [0] * self.num_classes
+            for configs in truth_configs[category]:
+                if "sed" in configs:
+                    for cl in range(self.num_classes):
+                        class_count[category][cl] = int(
+                            np.sum(truth_t[category]["sed"][:, cl] >= self.class_weights_thresholds[cl])
+                        )
 
         return class_count
 
@@ -1348,57 +1502,56 @@ class MixtureDatabase:
         return _speaker(self.db, s_id, tier, self.use_cache)
 
     def speech_metadata(self, tier: str) -> list[str]:
-        from .helpers import get_textgrid_tier_from_target_file
+        from .helpers import get_textgrid_tier_from_source_file
 
         results: set[str] = set()
         if tier in self.textgrid_metadata_tiers:
-            for target_file in self.target_files:
-                data = get_textgrid_tier_from_target_file(target_file.name, tier)
-                if data is None:
-                    continue
-                if isinstance(data, list):
-                    for item in data:
-                        results.add(item.label)
-                else:
-                    results.add(data)
+            for source_files in self.source_files.values():
+                for source_file in source_files:
+                    data = get_textgrid_tier_from_source_file(source_file.name, tier)
+                    if data is None:
+                        continue
+                    if isinstance(data, list):
+                        for item in data:
+                            results.add(item.label)
+                    else:
+                        results.add(data)
         elif tier in self.speaker_metadata_tiers:
-            for target_file in self.target_files:
-                data = self.speaker(target_file.speaker_id, tier)
-                if data is not None:
-                    results.add(data)
+            for source_files in self.source_files.values():
+                for source_file in source_files:
+                    data = self.speaker(source_file.speaker_id, tier)
+                    if data is not None:
+                        results.add(data)
 
         return sorted(results)
 
-    def mixture_speech_metadata(self, mixid: int, tier: str) -> list[SpeechMetadata]:
+    def mixture_speech_metadata(self, mixid: int, tier: str) -> dict[str, SpeechMetadata]:
         from praatio.utilities.constants import Interval
 
-        from .helpers import get_textgrid_tier_from_target_file
+        from .helpers import get_textgrid_tier_from_source_file
 
-        results: list[SpeechMetadata] = []
+        results: dict[str, SpeechMetadata] = {}
         is_textgrid = tier in self.textgrid_metadata_tiers
         if is_textgrid:
-            for target in self.mixture(mixid).targets:
-                data = get_textgrid_tier_from_target_file(self.target_file(target.file_id).name, tier)
+            for category, source in self.mixture(mixid).all_sources.items():
+                data = get_textgrid_tier_from_source_file(self.source_file(source.file_id).name, tier)
                 if isinstance(data, list):
-                    # Check for tempo augmentation and adjust Interval start and end data as needed
+                    # Check for tempo effect and adjust Interval start and end data as needed
                     entries = []
                     for entry in data:
-                        if target.augmentation.pre.tempo is not None:
-                            entries.append(
-                                Interval(
-                                    entry.start / target.augmentation.pre.tempo,
-                                    entry.end / target.augmentation.pre.tempo,
-                                    entry.label,
-                                )
+                        entries.append(
+                            Interval(
+                                entry.start / source.pre_tempo,
+                                entry.end / source.pre_tempo,
+                                entry.label,
                             )
-                        else:
-                            entries.append(entry)
-                    results.append(entries)
+                        )
+                    results[category] = entries
                 else:
-                    results.append(data)
+                    results[category] = data
         else:
-            for target in self.mixture(mixid).targets:
-                results.append(self.speaker(self.target_file(target.file_id).speaker_id, tier))
+            for category, source in self.mixture(mixid).all_sources.items():
+                results[category] = self.speaker(self.source_file(source.file_id).speaker_id, tier)
 
         return results
 
@@ -1407,7 +1560,7 @@ class MixtureDatabase:
         tier: str | None = None,
         value: str | None = None,
         where: str | None = None,
-    ) -> list[int]:
+    ) -> dict[str, list[int]]:
         """Get a list of mixture IDs for the given speech metadata tier.
 
         If 'where' is None, then include mixture IDs whose tier values are equal to the given 'value'.
@@ -1441,16 +1594,29 @@ class MixtureDatabase:
             results = c.execute(f"SELECT id FROM speaker WHERE {where}").fetchall()
             speaker_ids = ",".join(map(str, [i[0] for i in results]))
 
-            results = c.execute(f"SELECT id FROM target_file WHERE speaker_id IN ({speaker_ids})").fetchall()
-            target_file_ids = ",".join(map(str, [i[0] for i in results]))
+            results = c.execute(f"SELECT id, category FROM source_file WHERE speaker_id IN ({speaker_ids})").fetchall()
+            source_file_ids: dict[str, list[int]] = {}
+            for result in results:
+                source_file_id, category = result
+                if category not in source_file_ids:
+                    source_file_ids[category] = [source_file_id]
+                else:
+                    source_file_ids[category].append(source_file_id)
 
-            results = c.execute(
-                f"SELECT mixture_id FROM mixture_target WHERE mixture_target.target_id IN ({target_file_ids})"
-            ).fetchall()
+            mixids: dict[str, list[int]] = {}
+            for category in source_file_ids:
+                id_str = ",".join(map(str, source_file_ids[category]))
+                results = c.execute(f"SELECT id FROM source WHERE file_id IN ({id_str})").fetchall()
+                source_ids = ",".join(map(str, [i[0] for i in results]))
 
-        return [mixture_id[0] - 1 for mixture_id in results]
+                results = c.execute(
+                    f"SELECT mixture_id FROM mixture_source WHERE source_id IN ({source_ids})"
+                ).fetchall()
+                mixids[category] = [mixture_id[0] - 1 for mixture_id in results]
 
-    def mixture_all_speech_metadata(self, m_id: int) -> list[dict[str, SpeechMetadata]]:
+        return mixids
+
+    def mixture_all_speech_metadata(self, m_id: int) -> dict[str, dict[str, SpeechMetadata]]:
         from .helpers import mixture_all_speech_metadata
 
         return mixture_all_speech_metadata(self, self.mixture(m_id))
@@ -1483,63 +1649,65 @@ class MixtureDatabase:
         :param m_id: Zero-based mixture ID
         :param metrics: List of metrics to get
         :param force: Force computing data from original sources regardless of whether cached data exists
-        :return: List of metric data
+        :return: Dictionary of metric data
         """
         from collections.abc import Callable
 
         import numpy as np
         from pystoi import stoi
 
-        from sonusai.metrics import calc_audio_stats
-        from sonusai.metrics import calc_phase_distance
-        from sonusai.metrics import calc_segsnr_f
-        from sonusai.metrics import calc_segsnr_f_bin
-        from sonusai.metrics import calc_speech
-        from sonusai.metrics import calc_wer
-        from sonusai.metrics import calc_wsdr
-        from sonusai.mixture import SAMPLE_RATE
-        from sonusai.mixture import AudioStatsMetrics
-        from sonusai.mixture import SpeechMetrics
-        from sonusai.utils import calc_asr
-
-        def create_targets_audio() -> Callable[[], list[AudioT]]:
-            state: list[AudioT] | None = None
-
-            def get() -> list[AudioT]:
+        from ..constants import SAMPLE_RATE
+        from ..datatypes import AudioStatsMetrics
+        from ..datatypes import SpeechMetrics
+        from ..metrics.calc_audio_stats import calc_audio_stats
+        from ..metrics.calc_pesq import calc_pesq
+        from ..metrics.calc_phase_distance import calc_phase_distance
+        from ..metrics.calc_segsnr_f import calc_segsnr_f
+        from ..metrics.calc_segsnr_f import calc_segsnr_f_bin
+        from ..metrics.calc_speech import calc_speech
+        from ..metrics.calc_wer import calc_wer
+        from ..metrics.calc_wsdr import calc_wsdr
+        from ..utils.asr import calc_asr
+        from ..utils.db import linear_to_db
+
+        def create_sources_audio() -> Callable[[], dict[str, AudioT]]:
+            state: dict[str, AudioT] | None = None
+
+            def get() -> dict[str, AudioT]:
                 nonlocal state
                 if state is None:
-                    state = self.mixture_targets(m_id)
+                    state = self.mixture_sources(m_id)
                 return state
 
             return get
 
-        targets_audio = create_targets_audio()
+        sources_audio = create_sources_audio()
 
-        def create_target_audio() -> Callable[[], AudioT]:
+        def create_source_audio() -> Callable[[], AudioT]:
             state: AudioT | None = None
 
             def get() -> AudioT:
                 nonlocal state
                 if state is None:
-                    state = self.mixture_target(m_id)
+                    state = self.mixture_source(m_id)
                 return state
 
             return get
 
-        target_audio = create_target_audio()
+        source_audio = create_source_audio()
 
-        def create_target_f() -> Callable[[], AudioF]:
+        def create_source_f() -> Callable[[], AudioF]:
             state: AudioF | None = None
 
             def get() -> AudioF:
                 nonlocal state
                 if state is None:
-                    state = self.mixture_targets_f(m_id)[0]
+                    state = self.mixture_source_f(m_id)
                 return state
 
             return get
 
-        target_f = create_target_f()
+        source_f = create_source_f()
 
         def create_noise_audio() -> Callable[[], AudioT]:
             state: AudioT | None = None
@@ -1593,15 +1761,29 @@ class MixtureDatabase:
 
         segsnr_f = create_segsnr_f()
 
-        def create_speech() -> Callable[[], list[SpeechMetrics]]:
-            state: list[SpeechMetrics] | None = None
+        def create_pesq() -> Callable[[], dict[str, float]]:
+            state: dict[str, float] | None = None
 
-            def get() -> list[SpeechMetrics]:
+            def get() -> dict[str, float]:
                 nonlocal state
                 if state is None:
-                    state = []
-                    for audio in targets_audio():
-                        state.append(calc_speech(hypothesis=mixture_audio(), reference=audio))
+                    state = {category: calc_pesq(mixture_audio(), audio) for category, audio in sources_audio().items()}
+                return state
+
+            return get
+
+        pesq = create_pesq()
+
+        def create_speech() -> Callable[[], dict[str, SpeechMetrics]]:
+            state: dict[str, SpeechMetrics] | None = None
+
+            def get() -> dict[str, SpeechMetrics]:
+                nonlocal state
+                if state is None:
+                    state = {
+                        category: calc_speech(mixture_audio(), audio, pesq()[category])
+                        for category, audio in sources_audio().items()
+                    }
                 return state
 
             return get
@@ -1621,33 +1803,34 @@ class MixtureDatabase:
 
         mixture_stats = create_mixture_stats()
 
-        def create_targets_stats() -> Callable[[], list[AudioStatsMetrics]]:
-            state: list[AudioStatsMetrics] | None = None
+        def create_sources_stats() -> Callable[[], dict[str, AudioStatsMetrics]]:
+            state: dict[str, AudioStatsMetrics] | None = None
 
-            def get() -> list[AudioStatsMetrics]:
+            def get() -> dict[str, AudioStatsMetrics]:
                 nonlocal state
                 if state is None:
-                    state = []
-                    for audio in targets_audio():
-                        state.append(calc_audio_stats(audio, self.fg_info.ft_config.length / SAMPLE_RATE))
+                    state = {
+                        category: calc_audio_stats(audio, self.fg_info.ft_config.length / SAMPLE_RATE)
+                        for category, audio in sources_audio().items()
+                    }
                 return state
 
             return get
 
-        targets_stats = create_targets_stats()
+        sources_stats = create_sources_stats()
 
-        def create_target_stats() -> Callable[[], AudioStatsMetrics]:
+        def create_source_stats() -> Callable[[], AudioStatsMetrics]:
             state: AudioStatsMetrics | None = None
 
             def get() -> AudioStatsMetrics:
                 nonlocal state
                 if state is None:
-                    state = calc_audio_stats(target_audio(), self.fg_info.ft_config.length / SAMPLE_RATE)
+                    state = calc_audio_stats(source_audio(), self.fg_info.ft_config.length / SAMPLE_RATE)
                 return state
 
             return get
 
-        target_stats = create_target_stats()
+        source_stats = create_source_stats()
 
         def create_noise_stats() -> Callable[[], AudioStatsMetrics]:
             state: AudioStatsMetrics | None = None
@@ -1678,33 +1861,34 @@ class MixtureDatabase:
 
         asr_config = create_asr_config()
 
-        def create_targets_asr() -> Callable[[str], list[str]]:
-            state: dict[str, list[str]] = {}
+        def create_sources_asr() -> Callable[[str], dict[str, str]]:
+            state: dict[str, dict[str, str]] = {}
 
-            def get(asr_name) -> list[str]:
+            def get(asr_name) -> dict[str, str]:
                 nonlocal state
                 if asr_name not in state:
-                    state[asr_name] = []
-                    for audio in targets_audio():
-                        state[asr_name].append(calc_asr(audio, **asr_config(asr_name)).text)
+                    state[asr_name] = {
+                        category: calc_asr(audio, **asr_config(asr_name)).text
+                        for category, audio in sources_audio().items()
+                    }
                 return state[asr_name]
 
             return get
 
-        targets_asr = create_targets_asr()
+        sources_asr = create_sources_asr()
 
-        def create_target_asr() -> Callable[[str], str]:
+        def create_source_asr() -> Callable[[str], str]:
             state: dict[str, str] = {}
 
             def get(asr_name) -> str:
                 nonlocal state
                 if asr_name not in state:
-                    state[asr_name] = calc_asr(target_audio(), **asr_config(asr_name)).text
+                    state[asr_name] = calc_asr(source_audio(), **asr_config(asr_name)).text
                 return state[asr_name]
 
             return get
 
-        target_asr = create_target_asr()
+        source_asr = create_source_asr()
 
         def create_mixture_asr() -> Callable[[str], str]:
             state: dict[str, str] = {}
@@ -1728,11 +1912,11 @@ class MixtureDatabase:
 
         def calc(m: str) -> Any:
             if m == "mxsnr":
-                return self.mixture(m_id).snr
+                return {category: source.snr for category, source in self.mixture(m_id).all_sources.items()}
 
             # Get cached data first, if exists
             if not force:
-                value = self.read_mixture_data(m_id, m)
+                value = self.read_mixture_data(m_id, m)[m]
                 if value is not None:
                     return value
 
@@ -1744,8 +1928,8 @@ class MixtureDatabase:
                     # noise only, ignore/reset target asr
                     return float("nan")
 
-                if target_asr(asr_name):
-                    return calc_wer(mixture_asr(asr_name), target_asr(asr_name)).wer * 100
+                if source_asr(asr_name):
+                    return calc_wer(mixture_asr(asr_name), source_asr(asr_name)).wer * 100
 
                 # TODO: should this be NaN like above?
                 return float(0)
@@ -1753,12 +1937,14 @@ class MixtureDatabase:
             if m.startswith("basewer"):
                 asr_name = get_asr_name(m)
 
-                text = self.mixture_speech_metadata(m_id, "text")[0]
-                if not isinstance(text, str):
-                    # TODO: should this be NaN like above?
-                    return [float(0)] * len(targets_audio())
-
-                return [calc_wer(t, text).wer * 100 for t in targets_asr(asr_name)]
+                text = self.mixture_speech_metadata(m_id, "text")
+                base_wer: dict[str, float] = {}
+                for category, source in sources_asr(asr_name).items():
+                    if isinstance(text[category], str):
+                        base_wer[category] = calc_wer(source, str(text[category])).wer * 100
+                    else:
+                        base_wer[category] = 0
+                return base_wer
 
             if m.startswith("mxasr"):
                 return mixture_asr(get_asr_name(m))
@@ -1769,6 +1955,18 @@ class MixtureDatabase:
             if m == "mxssnr_std":
                 return calc_segsnr_f(segsnr_f()).std
 
+            if m == "mxssnr_avg_db":
+                val = calc_segsnr_f(segsnr_f()).avg
+                if val is not None:
+                    return linear_to_db(val)
+                return None
+
+            if m == "mxssnr_std_db":
+                val = calc_segsnr_f(segsnr_f()).std
+                if val is not None:
+                    return linear_to_db(val)
+                return None
+
             if m == "mxssnrdb_avg":
                 return calc_segsnr_f(segsnr_f()).db_avg
 
@@ -1776,40 +1974,40 @@ class MixtureDatabase:
                 return calc_segsnr_f(segsnr_f()).db_std
 
             if m == "mxssnrf_avg":
-                return calc_segsnr_f_bin(target_f(), noise_f()).avg
+                return calc_segsnr_f_bin(source_f(), noise_f()).avg
 
             if m == "mxssnrf_std":
-                return calc_segsnr_f_bin(target_f(), noise_f()).std
+                return calc_segsnr_f_bin(source_f(), noise_f()).std
 
             if m == "mxssnrdbf_avg":
-                return calc_segsnr_f_bin(target_f(), noise_f()).db_avg
+                return calc_segsnr_f_bin(source_f(), noise_f()).db_avg
 
             if m == "mxssnrdbf_std":
-                return calc_segsnr_f_bin(target_f(), noise_f()).db_std
+                return calc_segsnr_f_bin(source_f(), noise_f()).db_std
 
             if m == "mxpesq":
                 if self.mixture(m_id).is_noise_only:
-                    return [0] * len(speech())
-                return [s.pesq for s in speech()]
+                    return dict.fromkeys(pesq(), 0)
+                return pesq()
 
             if m == "mxcsig":
                 if self.mixture(m_id).is_noise_only:
-                    return [0] * len(speech())
-                return [s.csig for s in speech()]
+                    return dict.fromkeys(speech(), 0)
+                return {category: s.csig for category, s in speech().items()}
 
             if m == "mxcbak":
                 if self.mixture(m_id).is_noise_only:
-                    return [0] * len(speech())
-                return [s.cbak for s in speech()]
+                    return dict.fromkeys(speech(), 0)
+                return {category: s.cbak for category, s in speech().items()}
 
             if m == "mxcovl":
                 if self.mixture(m_id).is_noise_only:
-                    return [0] * len(speech())
-                return [s.covl for s in speech()]
+                    return dict.fromkeys(speech(), 0)
+                return {category: s.covl for category, s in speech().items()}
 
             if m == "mxwsdr":
                 mixture = mixture_audio()[:, np.newaxis]
-                target = target_audio()[:, np.newaxis]
+                target = source_audio()[:, np.newaxis]
                 noise = noise_audio()[:, np.newaxis]
                 return calc_wsdr(
                     hypothesis=np.concatenate((mixture, noise), axis=1),
@@ -1819,11 +2017,11 @@ class MixtureDatabase:
 
             if m == "mxpd":
                 mixture_f = self.mixture_mixture_f(m_id)
-                return calc_phase_distance(hypothesis=mixture_f, reference=target_f())[0]
+                return calc_phase_distance(hypothesis=mixture_f, reference=source_f())[0]
 
             if m == "mxstoi":
                 return stoi(
-                    x=target_audio(),
+                    x=source_audio(),
                     y=mixture_audio(),
                     fs_sig=SAMPLE_RATE,
                     extended=False,
@@ -1860,70 +2058,70 @@ class MixtureDatabase:
                 return mixture_stats().pkc
 
             if m == "mxtdco":
-                return target_stats().dco
+                return source_stats().dco
 
             if m == "mxtmin":
-                return target_stats().min
+                return source_stats().min
 
             if m == "mxtmax":
-                return target_stats().max
+                return source_stats().max
 
             if m == "mxtpkdb":
-                return target_stats().pkdb
+                return source_stats().pkdb
 
             if m == "mxtlrms":
-                return target_stats().lrms
+                return source_stats().lrms
 
             if m == "mxtpkr":
-                return target_stats().pkr
+                return source_stats().pkr
 
             if m == "mxttr":
-                return target_stats().tr
+                return source_stats().tr
 
             if m == "mxtcr":
-                return target_stats().cr
+                return source_stats().cr
 
             if m == "mxtfl":
-                return target_stats().fl
+                return source_stats().fl
 
             if m == "mxtpkc":
-                return target_stats().pkc
+                return source_stats().pkc
 
-            if m == "tdco":
-                return [t.dco for t in targets_stats()]
+            if m == "sdco":
+                return {category: s.dco for category, s in sources_stats().items()}
 
-            if m == "tmin":
-                return [t.min for t in targets_stats()]
+            if m == "smin":
+                return {category: s.min for category, s in sources_stats().items()}
 
-            if m == "tmax":
-                return [t.max for t in targets_stats()]
+            if m == "smax":
+                return {category: s.max for category, s in sources_stats().items()}
 
-            if m == "tpkdb":
-                return [t.pkdb for t in targets_stats()]
+            if m == "spkdb":
+                return {category: s.pkdb for category, s in sources_stats().items()}
 
-            if m == "tlrms":
-                return [t.lrms for t in targets_stats()]
+            if m == "slrms":
+                return {category: s.lrms for category, s in sources_stats().items()}
 
-            if m == "tpkr":
-                return [t.pkr for t in targets_stats()]
+            if m == "spkr":
+                return {category: s.pkr for category, s in sources_stats().items()}
 
-            if m == "ttr":
-                return [t.tr for t in targets_stats()]
+            if m == "str":
+                return {category: s.tr for category, s in sources_stats().items()}
 
-            if m == "tcr":
-                return [t.cr for t in targets_stats()]
+            if m == "scr":
+                return {category: s.cr for category, s in sources_stats().items()}
 
-            if m == "tfl":
-                return [t.fl for t in targets_stats()]
+            if m == "sfl":
+                return {category: s.fl for category, s in sources_stats().items()}
 
-            if m == "tpkc":
-                return [t.pkc for t in targets_stats()]
+            if m == "spkc":
+                return {category: s.pkc for category, s in sources_stats().items()}
 
-            if m.startswith("tasr"):
-                return targets_asr(get_asr_name(m))
+            if m.startswith("sasr"):
+                return sources_asr(get_asr_name(m))
 
-            if m.startswith("mxtasr"):
-                return target_asr(get_asr_name(m))
+            if m.startswith("mxsasr"):
+                return source_asr(get_asr_name(m))
 
             if m == "ndco":
                 return noise_stats().dco
@@ -2003,16 +2201,7 @@ def __spectral_mask(db: partial, sm_id: int) -> SpectralMask:
     from .db_datatypes import SpectralMaskRecord
 
     with db() as c:
-        spectral_mask = SpectralMaskRecord(
-            *c.execute(
-                """
-                SELECT *
-                FROM spectral_mask
-                WHERE ? = spectral_mask.id
-                """,
-                (sm_id,),
-            ).fetchone()
-        )
+        spectral_mask = SpectralMaskRecord(*c.execute("SELECT * FROM spectral_mask WHERE ? = id", (sm_id,)).fetchone())
         return SpectralMask(
             f_max_width=spectral_mask.f_max_width,
             f_num=spectral_mask.f_num,
@@ -2022,82 +2211,72 @@ def __spectral_mask(db: partial, sm_id: int) -> SpectralMask:
         )
 
 
-def _target_file(db: partial, t_id: int, use_cache: bool = True) -> TargetFile:
-    """Get target file with ID from db
+def _num_source_files(db: partial, category: str, use_cache: bool = True) -> int:
+    """Get number of source files from category from db
 
     :param db: Database context
-    :param t_id: Target file ID
+    :param category: Source category
     :param use_cache: If true, use LRU caching
-    :return: Target file
+    :return: Number of source files
     """
     if use_cache:
-        return __target_file(db, t_id, use_cache)
-    return __target_file.__wrapped__(db, t_id, use_cache)
+        return __num_source_files(db, category)
+    return __num_source_files.__wrapped__(db, category)
 
 
 @lru_cache
-def __target_file(db: partial, t_id: int, use_cache: bool = True) -> TargetFile:
-    """Get target file with ID from db
+def __num_source_files(db: partial, category: str) -> int:
+    """Get number of source files from category from db
 
     :param db: Database context
-    :param t_id: Target file ID
-    :param use_cache: If true, use LRU caching
-    :return: Target file
+    :param category: Source category
+    :return: Number of source files
     """
-    import json
-
-    from .db_datatypes import TargetFileRecord
-
     with db() as c:
-        target_file = TargetFileRecord(
-            *c.execute(
-                """
-                SELECT *
-                FROM target_file
-                WHERE ? = target_file.id
-                """,
-                (t_id,),
-            ).fetchone()
-        )
-
-        return TargetFile(
-            name=target_file.name,
-            samples=target_file.samples,
-            class_indices=json.loads(target_file.class_indices),
-            level_type=target_file.level_type,
-            truth_configs=_target_truth_configs(db, t_id, use_cache),
-            speaker_id=target_file.speaker_id,
-        )
+        return int(c.execute("SELECT count(id) FROM source_file WHERE ? = category", (category,)).fetchone()[0])
 
 
-def _noise_file(db: partial, n_id: int, use_cache: bool = True) -> NoiseFile:
-    """Get noise file with ID from db
+def _source_file(db: partial, s_id: int, use_cache: bool = True) -> SourceFile:
+    """Get source file with ID from db
 
     :param db: Database context
-    :param n_id: Noise file ID
+    :param s_id: Source file ID
     :param use_cache: If true, use LRU caching
-    :return: Noise file
+    :return: Source file
     """
     if use_cache:
-        return __noise_file(db, n_id)
-    return __noise_file.__wrapped__(db, n_id)
+        return __source_file(db, s_id, use_cache)
+    return __source_file.__wrapped__(db, s_id, use_cache)
 
 
 @lru_cache
-def __noise_file(db: partial, n_id: int) -> NoiseFile:
+def __source_file(db: partial, s_id: int, use_cache: bool = True) -> SourceFile:
+    """Get source file with ID from db
+
+    :param db: Database context
+    :param s_id: Source file ID
+    :param use_cache: If true, use LRU caching
+    :return: Source file
+    """
+    import json
+
+    from .db_datatypes import SourceFileRecord
+
     with db() as c:
-        noise = c.execute(
-            """
-            SELECT noise_file.name, samples
-            FROM noise_file
-            WHERE ? = noise_file.id
-            """,
-            (n_id,),
-        ).fetchone()
-        return NoiseFile(name=noise[0], samples=noise[1])
+        source_file = SourceFileRecord(*c.execute("SELECT * FROM source_file WHERE ? = id", (s_id,)).fetchone())
+
+        return SourceFile(
+            category=source_file.category,
+            name=source_file.name,
+            samples=source_file.samples,
+            class_indices=json.loads(source_file.class_indices),
+            level_type=source_file.level_type,
+            truth_configs=_source_truth_configs(db, s_id, use_cache),
+            speaker_id=source_file.speaker_id,
+        )
 
 
-def _impulse_response_file(db: partial, ir_id: int, use_cache: bool = True) -> str:
+def _ir_file(db: partial, ir_id: int, use_cache: bool = True) -> str:
     """Get impulse response file name with ID from db
 
     :param db: Database context
@@ -2106,26 +2285,17 @@ def _impulse_response_file(db: partial, ir_id: int, use_cache: bool = True) -> s
     :return: Impulse response file name
     """
     if use_cache:
-        return __impulse_response_file(db, ir_id)
-    return __impulse_response_file.__wrapped__(db, ir_id)
+        return __ir_file(db, ir_id)
+    return __ir_file.__wrapped__(db, ir_id)
 
 
 @lru_cache
-def __impulse_response_file(db: partial, ir_id: int) -> str:
+def __ir_file(db: partial, ir_id: int) -> str:
     with db() as c:
-        return str(
-            c.execute(
-                """
-                SELECT impulse_response_file.file
-                FROM impulse_response_file
-                WHERE ? = impulse_response_file.id
-                """,
-                (ir_id + 1,),
-            ).fetchone()[0]
-        )
+        return str(c.execute("SELECT name FROM ir_file WHERE ? = id ", (ir_id + 1,)).fetchone()[0])
 
 
-def _impulse_response_delay(db: partial, ir_id: int, use_cache: bool = True) -> int:
+def _ir_delay(db: partial, ir_id: int, use_cache: bool = True) -> int:
     """Get impulse response delay with ID from db
 
     :param db: Database context
@@ -2134,23 +2304,14 @@ def _impulse_response_delay(db: partial, ir_id: int, use_cache: bool = True) ->
     :return: Impulse response delay
     """
     if use_cache:
-        return __impulse_response_delay(db, ir_id)
-    return __impulse_response_delay.__wrapped__(db, ir_id)
+        return __ir_delay(db, ir_id)
+    return __ir_delay.__wrapped__(db, ir_id)
 
 
 @lru_cache
-def __impulse_response_delay(db: partial, ir_id: int) -> int:
+def __ir_delay(db: partial, ir_id: int) -> int:
     with db() as c:
-        return int(
-            c.execute(
-                """
-                SELECT impulse_response_file.delay
-                FROM impulse_response_file
-                WHERE ? = impulse_response_file.id
-                """,
-                (ir_id + 1,),
-            ).fetchone()[0]
-        )
+        return int(c.execute("SELECT delay FROM ir_file WHERE ? = id", (ir_id + 1,)).fetchone()[0])
 
 
 def _mixture(db: partial, m_id: int, use_cache: bool = True) -> Mixture:
@@ -2169,35 +2330,27 @@ def _mixture(db: partial, m_id: int, use_cache: bool = True) -> Mixture:
 @lru_cache
 def __mixture(db: partial, m_id: int) -> Mixture:
     from .db_datatypes import MixtureRecord
-    from .db_datatypes import TargetRecord
+    from .db_datatypes import SourceRecord
     from .helpers import to_mixture
-    from .helpers import to_target
+    from .helpers import to_source
 
     with db() as c:
-        mixture = MixtureRecord(
-            *c.execute(
-                """
-                SELECT *
-                FROM mixture
-                WHERE ? = mixture.id
-                """,
-                (m_id + 1,),
-            ).fetchone()
-        )
+        mixture = MixtureRecord(*c.execute("SELECT * FROM mixture WHERE ? = id", (m_id + 1,)).fetchone())
 
-        targets = [
-            to_target(TargetRecord(*target))
-            for target in c.execute(
-                """
-                SELECT target.*
-                FROM target, mixture_target
-                WHERE ? = mixture_target.mixture_id AND target.id = mixture_target.target_id
+        sources: Sources = {}
+        for source in c.execute(
+            """
+                SELECT source.*
+                FROM source, mixture_source
+                WHERE ? = mixture_source.mixture_id AND source.id = mixture_source.source_id
                 """,
-                (mixture.id,),
-            ).fetchall()
-        ]
+            (mixture.id,),
+        ).fetchall():
+            s = SourceRecord(*source)
+            category = c.execute("SELECT category FROM source_file WHERE ? = id", (s.file_id,)).fetchone()[0]
+            sources[category] = to_source(s)
 
-        return to_mixture(mixture, targets)
+        return to_mixture(mixture, sources)
 
 
 def _speaker(db: partial, s_id: int | None, tier: str, use_cache: bool = True) -> str | None:
@@ -2220,27 +2373,55 @@ def __speaker(db: partial, s_id: int | None, tier: str) -> str | None:
         return data[0]
 
 
-def _target_truth_configs(db: partial, t_id: int, use_cache: bool = True) -> TruthConfigs:
+def _category_truth_configs(db: partial, category: str, use_cache: bool = True) -> dict[str, str]:
+    if use_cache:
+        return __category_truth_configs(db, category)
+    return __category_truth_configs.__wrapped__(db, category)
+
+
+@lru_cache
+def __category_truth_configs(db: partial, category: str) -> dict[str, str]:
+    import json
+
+    truth_configs: dict[str, str] = {}
+    with db() as c:
+        s_ids = c.execute("SELECT id FROM source_file WHERE ? = category", (category,)).fetchall()
+
+        for s_id in s_ids:
+            for truth_config_record in c.execute(
+                """
+                SELECT truth_config.config
+                FROM truth_config, source_file_truth_config
+                WHERE ? = source_file_truth_config.source_file_id AND truth_config.id = source_file_truth_config.truth_config_id
+                """,
+                (s_id[0],),
+            ).fetchall():
+                truth_config = json.loads(truth_config_record[0])
+                truth_configs[truth_config["name"]] = truth_config["function"]
+    return truth_configs
+
+
+def _source_truth_configs(db: partial, s_id: int, use_cache: bool = True) -> TruthConfigs:
     if use_cache:
-        return __target_truth_configs(db, t_id)
-    return __target_truth_configs.__wrapped__(db, t_id)
+        return __source_truth_configs(db, s_id)
+    return __source_truth_configs.__wrapped__(db, s_id)
 
 
 @lru_cache
-def __target_truth_configs(db: partial, t_id: int) -> TruthConfigs:
+def __source_truth_configs(db: partial, s_id: int) -> TruthConfigs:
     import json
 
-    from .datatypes import TruthConfig
+    from ..datatypes import TruthConfig
 
     truth_configs: TruthConfigs = {}
     with db() as c:
         for truth_config_record in c.execute(
             """
             SELECT truth_config.config
-            FROM truth_config, target_file_truth_config
-            WHERE ? = target_file_truth_config.target_file_id AND truth_config.id = target_file_truth_config.truth_config_id
+            FROM truth_config, source_file_truth_config
+            WHERE ? = source_file_truth_config.source_file_id AND truth_config.id = source_file_truth_config.truth_config_id
             """,
-            (t_id,),
+            (s_id,),
         ).fetchall():
             truth_config = json.loads(truth_config_record[0])
             truth_configs[truth_config["name"]] = TruthConfig(