Spaces:
Sleeping
Sleeping
Download utils/sampling_utils.py from hephaestusonfire/Music_Generator: direct link, hf CLI and curl.
- Browser
- Download file 9 kB
-
https://huggingface.co/spaces/hephaestusonfire/Music_Generator/resolve/main/utils/sampling_utils.py
- Command line
-
hf download hf://spaces/hephaestusonfire/Music_Generator/utils/sampling_utils.py
-
curl -L -o sampling_utils.py https://huggingface.co/spaces/hephaestusonfire/Music_Generator/resolve/main/utils/sampling_utils.py
9 kB
| """ | |
| Sampling and bar-level constraints for music generation. | |
| """ | |
| from typing import Dict | |
| import numpy as np | |
| import torch | |
| import torch.nn.functional as F # noqa: F401 | |
| import config | |
| # ========================= | |
| # Simple music-theory rules | |
| # ========================= | |
| # C major scale degrees within one octave (0–11): | |
| # C, D, E, F, G, A, B | |
| C_MAJOR_INDICES = [0, 2, 4, 5, 7, 9, 11] | |
| def enforce_scale( | |
| bar: Dict[str, np.ndarray], | |
| allowed_indices=C_MAJOR_INDICES, | |
| ) -> Dict[str, np.ndarray]: | |
| """ | |
| Zero out melodic pitches not in the allowed scale for each melodic family. | |
| Args: | |
| bar: dict with keys "strings", "woodwinds", "brass", "perc". | |
| allowed_indices: list of pitch indices (0–11) allowed in the scale. | |
| Returns: | |
| bar with non-scale pitches zeroed for melodic families. | |
| """ | |
| mask = np.zeros((config.PITCHES_MELODIC,), dtype=np.float32) | |
| mask[allowed_indices] = 1.0 | |
| for key in ["strings", "woodwinds", "brass"]: | |
| grid = bar[key] # [T, 12] | |
| bar[key] = grid * mask # broadcast over time | |
| return bar | |
| def limit_notes_per_step( | |
| bar: Dict[str, np.ndarray], | |
| max_notes_per_step: int = 4, | |
| ) -> Dict[str, np.ndarray]: | |
| """ | |
| For each melodic family and time step, restrict to at most max_notes_per_step notes. | |
| This reduces dense vertical clusters and produces simpler chords. | |
| """ | |
| for key in ["strings", "woodwinds", "brass"]: | |
| grid = bar[key] # [T, pitches] | |
| T, P = grid.shape | |
| for t in range(T): | |
| on_indices = np.where(grid[t] > 0.5)[0] | |
| if len(on_indices) > max_notes_per_step: | |
| # Keep the first few; zero out the rest | |
| to_keep = on_indices[:max_notes_per_step] | |
| mask = np.zeros_like(grid[t]) | |
| mask[to_keep] = 1.0 | |
| grid[t] = mask | |
| bar[key] = grid | |
| return bar | |
| def count_total_notes( | |
| bar: Dict[str, np.ndarray], | |
| ) -> int: | |
| """ | |
| Count total number of "on" notes across all instrument families in a bar. | |
| """ | |
| total = 0 | |
| for key in ["strings", "woodwinds", "brass", "perc"]: | |
| total += np.count_nonzero(bar[key] > 0.5) | |
| return int(total) | |
| def emphasize_strong_beats( | |
| bar: Dict[str, np.ndarray], | |
| ) -> Dict[str, np.ndarray]: | |
| """ | |
| Encourage notes on strong beats (0, 2, 4, 6) for melodic families. | |
| If a strong beat has no note in a family, randomly turn one on. | |
| """ | |
| strong_steps = [0, 2, 4, 6] | |
| for key in ["strings", "woodwinds", "brass"]: | |
| grid = bar[key] # [T, 12] | |
| T, P = grid.shape | |
| for t in strong_steps: | |
| if t >= T: | |
| continue | |
| if np.sum(grid[t] > 0.5) == 0: | |
| p = np.random.randint(0, P) | |
| grid[t, p] = 1.0 | |
| bar[key] = grid | |
| return bar | |
| # ========================= | |
| # Logit → binary grid sampling | |
| # ========================= | |
| def sample_binary_from_logits( | |
| logits: torch.Tensor, | |
| temperature: float = 1.0, | |
| top_k: int = 0, | |
| ) -> torch.Tensor: | |
| """ | |
| Sample binary activations from logits for one instrument. | |
| Args: | |
| logits: [T, P] tensor (time steps, pitches). | |
| temperature: Temperature for scaling; >1.0 → more random. | |
| top_k: If >0, keep only top_k logits per time step before sampling. | |
| Returns: | |
| activations: [T, P] tensor of 0/1 (float). | |
| """ | |
| if temperature <= 0: | |
| raise ValueError("temperature must be > 0") | |
| # Scale by temperature | |
| scaled_logits = logits / temperature | |
| # Optional top-k per time step | |
| if top_k > 0: | |
| # Clamp k so it never exceeds number of pitches for this instrument | |
| num_pitches = scaled_logits.shape[-1] | |
| k = min(top_k, num_pitches) | |
| values, indices = torch.topk(scaled_logits, k=k, dim=-1) | |
| mask = torch.full_like(scaled_logits, float("-inf")) | |
| mask.scatter_(-1, indices, values) | |
| scaled_logits = mask | |
| # Convert to probabilities | |
| probs = torch.sigmoid(scaled_logits) # [T, P] | |
| # Bernoulli sampling | |
| bernoulli_samples = torch.bernoulli(probs) | |
| return bernoulli_samples | |
| def sample_bar_from_logits_dict( | |
| logits_dict: Dict[str, torch.Tensor], | |
| temperature: float = 1.0, | |
| top_k: int = 0, | |
| ) -> Dict[str, np.ndarray]: | |
| """ | |
| Sample a full bar (all instruments) from per-instrument logits. | |
| Args: | |
| logits_dict: | |
| "strings": [T, 12], | |
| "woodwinds": [T, 12], | |
| "brass": [T, 12], | |
| "perc": [T, 3], | |
| where T should be config.STEPS_PER_BAR. | |
| temperature: Temperature for sampling. | |
| top_k: top-k filter per instrument per time step. | |
| Returns: | |
| Dict of numpy arrays with shape [STEPS_PER_BAR, pitches] and 0/1 values. | |
| """ | |
| bar_grids: Dict[str, np.ndarray] = {} | |
| for name, logits in logits_dict.items(): | |
| # Expect [T, P] | |
| if logits.dim() == 3: | |
| logits = logits.squeeze(0) # [T, P] | |
| assert logits.shape[0] == config.STEPS_PER_BAR, f"{name}: wrong T" | |
| samples = sample_binary_from_logits( | |
| logits=logits, | |
| temperature=temperature, | |
| top_k=top_k, | |
| ) # [T, P] | |
| bar_grids[name] = samples.cpu().numpy().astype(np.float32) | |
| return bar_grids | |
| # ========================= | |
| # Bar similarity and resampling | |
| # ========================= | |
| def bar_similarity( | |
| bar1: Dict[str, np.ndarray], | |
| bar2: Dict[str, np.ndarray], | |
| ) -> float: | |
| """ | |
| Compute normalized similarity between two bars. | |
| Both bars are dicts: | |
| "strings": [STEPS_PER_BAR, 12], | |
| "woodwinds": [STEPS_PER_BAR, 12], | |
| "brass": [STEPS_PER_BAR, 12], | |
| "perc": [STEPS_PER_BAR, 3], | |
| Similarity is defined as: | |
| 1 - (Hamming distance / total_cells) | |
| """ | |
| flat1_list = [] | |
| flat2_list = [] | |
| for key in ["strings", "woodwinds", "brass", "perc"]: | |
| g1 = bar1[key].astype(np.float32) | |
| g2 = bar2[key].astype(np.float32) | |
| flat1_list.append(g1.reshape(-1)) | |
| flat2_list.append(g2.reshape(-1)) | |
| flat1 = np.concatenate(flat1_list) | |
| flat2 = np.concatenate(flat2_list) | |
| total_cells = flat1.size | |
| if total_cells == 0: | |
| return 0.0 | |
| diff = np.abs(flat1 - flat2) | |
| hamming = np.count_nonzero(diff) | |
| similarity = 1.0 - (hamming / float(total_cells)) | |
| return float(similarity) | |
| def count_active_families( | |
| bar: Dict[str, np.ndarray], | |
| ) -> int: | |
| """ | |
| Count how many instrument families have at least one active note in the bar. | |
| """ | |
| active_count = 0 | |
| for key in ["strings", "woodwinds", "brass", "perc"]: | |
| grid = bar[key] | |
| if np.any(grid > 0.5): | |
| active_count += 1 | |
| return active_count | |
| def resample_bar_if_needed( | |
| prev_bar: Dict[str, np.ndarray], | |
| logits_dict: Dict[str, torch.Tensor], | |
| temperature: float, | |
| top_k: int, | |
| similarity_threshold: float = config.BAR_SIMILARITY_THRESHOLD, | |
| max_attempts: int = config.MAX_RESAMPLE_ATTEMPTS_PER_BAR, | |
| min_active_families: int = config.MIN_ACTIVE_FAMILIES_PER_BAR, | |
| min_notes_per_bar: int = 2, | |
| max_notes_per_step: int = 4, | |
| ) -> Dict[str, np.ndarray]: | |
| """ | |
| Sample a bar from logits, enforcing: | |
| - Not too similar to prev_bar (if prev_bar is provided). | |
| - At least min_active_families have notes. | |
| - At least min_notes_per_bar total notes. | |
| - At most max_notes_per_step notes per step per melodic family. | |
| """ | |
| attempt = 0 | |
| best_bar = None | |
| best_similarity = -1.0 | |
| while attempt < max_attempts: | |
| attempt += 1 | |
| # Sample raw bar | |
| candidate_bar = sample_bar_from_logits_dict( | |
| logits_dict=logits_dict, | |
| temperature=temperature, | |
| top_k=top_k, | |
| ) | |
| # Apply theory rules | |
| candidate_bar = enforce_scale(candidate_bar) | |
| candidate_bar = emphasize_strong_beats(candidate_bar) | |
| candidate_bar = limit_notes_per_step(candidate_bar, max_notes_per_step=max_notes_per_step) | |
| # Activity and density | |
| active = count_active_families(candidate_bar) | |
| total_notes = count_total_notes(candidate_bar) | |
| # If no prev_bar, only activity + density constraints | |
| if prev_bar is None: | |
| if active >= min_active_families and total_notes >= min_notes_per_bar: | |
| return candidate_bar | |
| if best_bar is None: | |
| best_bar = candidate_bar | |
| continue | |
| # Compare to previous bar | |
| sim = bar_similarity(candidate_bar, prev_bar) | |
| # Track best candidate for fallback | |
| if sim > best_similarity: | |
| best_similarity = sim | |
| best_bar = candidate_bar | |
| # Check constraints: not too similar, enough active families, enough notes | |
| if (sim <= similarity_threshold) and (active >= min_active_families) and (total_notes >= min_notes_per_bar): | |
| return candidate_bar | |
| # Fallback | |
| return best_bar |