Soloing

generator/solo/scoring.py

@@ -0,0 +1,102 @@
+"""Duration-normalized musical evaluation, independent of search/notation chunks."""
+from __future__ import annotations
+
+import fractions
+
+import generator.solo.policy
+import generator.solo.types
+
+def passages(plan):
+  if plan.passages:
+    return plan.passages
+  end = plan.end - plan.release
+  active = (generator.solo.types.Passage(plan.start, end, 'active', plan.activity, fractions.Fraction(3, 4)),) if end > plan.start else ()
+  return active + ((generator.solo.types.Passage(end, plan.end, 'space', fractions.Fraction(), fractions.Fraction()),) if plan.release else ())
+
+def intervals(choices, start, end):
+  return tuple((max(start, c.span.start), min(end, c.span.end)) for c in choices if c.scale and c.span.start < end and c.span.end > start)
+
+def overlap(start, end, intervals):
+  return sum((max(0, min(end, b) - max(start, a)) for a, b in intervals), fractions.Fraction())
+
+def corridor(pitch, low, high):
+  return max(low - pitch, 0, pitch - high)
+
+def motif_fidelity(notes, motif, treatment):
+  if treatment in ('quote', 'exact_quote', 'rhythmic_reference'):
+    return 0.0
+  actual = tuple(b.pitch.number() - a.pitch.number() for a, b in zip(notes, notes[1:]))
+  expected = motif.contour()
+  if not actual or not expected:
+    return 0.0 if len(notes) >= min(1, len(motif.notes)) else 1.0
+  count = min(2, len(actual), len(expected)) if treatment == 'opening_reference' else max(1, len(actual) // 2) if treatment == 'answer' else len(actual)
+  errors = []
+  for index in range(count):
+    reference = expected[min(len(expected) - 1, index * len(expected) // max(1, len(actual)))]
+    motion = actual[index]
+    direction = ((reference > 0) - (reference < 0)) != ((motion > 0) - (motion < 0))
+    errors.append(0.75 * direction + 0.25 * min(1, abs(motion - reference) / 12))
+  return sum(errors) / len(errors)
+
+class Evaluation:
+  """Prepare fixed harmonic windows once; only soft penalties use float time."""
+  def __init__(self, plan, choices, until=None):
+    self.plan = plan
+    self.until = plan.end if until is None else until
+    self.duration = max(float(self.until - plan.start), 0.001)
+    self.windows = []
+    self.required = []
+    for passage in passages(plan):
+      end = min(passage.end, self.until)
+      if end <= passage.start:
+        continue
+      active = intervals(choices, passage.start, end)
+      length = float(sum((b - a for a, b in active), fractions.Fraction()))
+      if length:
+        self.windows.append((float(passage.start), float(end), tuple((float(a), float(b)) for a, b in active), length, float(passage.activity) * length, float(passage.occupancy), 0.5 if self.until < passage.end else 0))
+      if passage.end <= self.until:
+        protected = plan.treatment in ('quote', 'exact_quote', 'rhythmic_reference') and passage.end <= plan.start + plan.motif.duration
+        authored_silence = protected and not any(overlap(plan.start + n.start, plan.start + n.end, active) for n in plan.motif.notes)
+        self.required.append((passage, active, authored_silence))
+    self.landmarks = tuple((float(p.earliest), float(p.latest), p.low, p.high, p.direction) for p in plan.landmarks if p.latest <= self.until)
+  def feasible(self, notes):
+    # Hard silence/space requirements retain exact rational boundaries.
+    for passage, active, authored_silence in self.required:
+      if passage.intent == 'space':
+        if any(n.start < passage.end and n.end > passage.start for n in notes):
+          return False
+      elif active and not authored_silence and not any(n.start < b and n.end > a for n in notes for a, b in active):
+        return False
+    return True
+  def features(self, notes, *, previous=None, movement=0):
+    notes = generator.solo.types.sounding_notes(notes)
+    sounded = tuple((float(n.start), float(n.end), n.pitch.number()) for n in notes)
+    activity, occupancy = 0.0, 0.0
+    for start, end, active, length, expected, occupied_goal, tolerance in self.windows:
+      attacks = sum(start <= a < end and any(x <= a < y for x, y in active) for a, _, _ in sounded)
+      occupied = sum(max(0, min(b, y) - max(a, x)) for a, b, _ in sounded for x, y in active)
+      deviation = max(0, abs(attacks - expected) - tolerance)
+      activity += length * min(1, deviation / max(1, expected))
+      occupancy += length * abs(occupied / length - occupied_goal)
+    start, end = float(self.plan.start), float(self.until)
+    durations = [max(0, min(b, end) - max(a, start)) for a, b, _ in sounded]
+    register = sum(length * min(1, corridor(pitch, *self.plan.register) / 12) for (_, _, pitch), length in zip(sounded, durations)) / max(sum(durations), 0.001)
+    motions = [b[2] - a[2] for a, b in zip(sounded, sounded[1:])]
+    contour = sum(min(1, max(0, abs(m) - 5) / 12) for m in motions) / max(1, len(motions))
+    repetition = sum(a == b == 0 for a, b in zip(motions, motions[1:])) / max(1, len(motions) - 1)
+    landmarks = []
+    for earliest, latest, low, high, direction in self.landmarks:
+      prior = next((n for n in reversed(sounded) if n[0] < earliest), None)
+      landmarks.append(min((0.75 * min(1, corridor(n[2], low, high) / 12) + 0.25 * bool(prior and direction and (n[2] - prior[2]) * direction <= 0) for n in sounded if earliest <= n[0] <= latest), default=1))
+    motif_notes = tuple(n for n in notes if n.role in ('motif', 'quote'))
+    connection = min(1, abs(sounded[0][2] - previous.pitch.number()) / 12) if sounded and previous else 0
+    return {'activity': activity / self.duration, 'occupancy': occupancy / self.duration, 'register': register, 'contour': contour, 'repetition': repetition, 'landmarks': sum(landmarks) / max(1, len(landmarks)), 'connection': connection, 'movement': min(1, movement / max(1, len(notes)) / 2000), 'fidelity': motif_fidelity(motif_notes, self.plan.motif, self.plan.treatment) if motif_notes else 0}
+
+def features(plan, notes, choices, *, until=None, previous=None, movement=0):
+  return Evaluation(plan, choices, until).features(notes, previous=previous, movement=movement)
+
+def value(features):
+  return sum(weight * features.get(name, 0) for name, weight in generator.solo.policy.DEFAULT.weights)
+
+def feasible(plan, notes, choices, until):
+  return Evaluation(plan, choices, until).feasible(notes)