每一帧最像空白，为什么整段最可能读出 a？

"""Enumerate tiny CTC alignments and independently check a forward recurrence."""
from collections import defaultdict
from itertools import product
import json
import math
from pathlib import Path

SYMBOLS = ('_', 'a', 'b')
BLANK = '_'


def collapse(path):
    merged = [symbol for i,symbol in enumerate(path) if i == 0 or symbol != path[i-1]]
    return ''.join(symbol for symbol in merged if symbol != BLANK)


def enumerate_labels(emissions):
    masses = defaultdict(float)
    for indices in product(range(len(SYMBOLS)), repeat=len(emissions)):
        path = tuple(SYMBOLS[i] for i in indices)
        mass = math.prod(emissions[t][i] for t,i in enumerate(indices))
        masses[collapse(path)] += mass
    return dict(masses)


def forward_probability(emissions, label):
    if any(ch not in SYMBOLS[1:] for ch in label):
        raise ValueError('Target must exclude blank and unknown symbols.')
    extended = [BLANK]
    for ch in label:
        extended.extend([ch, BLANK])
    if not emissions:
        return float(not label)
    prev = [0.0] * len(extended)
    prev[0] = emissions[0][0]
    if label:
        prev[1] = emissions[0][SYMBOLS.index(label[0])]
    for frame in emissions[1:]:
        current = [0.0] * len(extended)
        for s,symbol in enumerate(extended):
            incoming = prev[s]
            if s > 0:
                incoming += prev[s-1]
            if s > 1 and symbol != BLANK and symbol != extended[s-2]:
                incoming += prev[s-2]
            current[s] = incoming * frame[SYMBOLS.index(symbol)]
        prev = current
    return prev[-1] + (prev[-2] if label else 0.0)


def minimum_frames(label):
    return len(label) + sum(a == b for a,b in zip(label,label[1:]))


def main():
    emissions = [[0.5,0.4,0.1], [0.5,0.4,0.1]]
    assert all(math.isclose(sum(frame),1.0) for frame in emissions)
    masses = enumerate_labels(emissions)
    assert math.isclose(sum(masses.values()),1.0)
    greedy = tuple(SYMBOLS[max(range(3), key=lambda i: frame[i])] for frame in emissions)
    best = max(masses, key=masses.get)
    assert collapse(greedy) == '' and best == 'a'
    print('greedy frame path=' + ''.join(greedy) + '; collapsed=<empty>; path probability=0.250000')
    for label,mass in sorted(masses.items(), key=lambda pair:(-pair[1],pair[0])):
        print(f'label={label or "<empty>"}: summed probability={mass:.6f}')
    print('collapse a_a=' + collapse(('a','_','a')) + '; collapse aa_=' + collapse(('a','a','_')))
    assert collapse(('a','_','a')) == 'aa'
    assert collapse(('a','a','_')) == 'a'
    assert masses.get('aa',0.0) == 0.0
    repeated = [[0.2,0.7,0.1],[0.6,0.3,0.1],[0.2,0.7,0.1]]
    repeat_prob = forward_probability(repeated,'aa')
    assert math.isclose(repeat_prob,0.7*0.6*0.7,abs_tol=1e-12)
    print(f'target aa: minimum frames={minimum_frames("aa")}; T=2 probability=0.000000; T=3 probability={repeat_prob:.6f}')
    checked = 0
    for frames in [[],emissions[:1],emissions,repeated,repeated+[[0.3,0.2,0.5]]]:
        all_masses = enumerate_labels(frames)
        assert math.isclose(sum(all_masses.values()),1.0,abs_tol=1e-12)
        for length in range(4):
            for chars in product('ab',repeat=length):
                label = ''.join(chars)
                expected = all_masses.get(label,0.0)
                actual = forward_probability(frames,label)
                assert math.isclose(actual,expected,abs_tol=1e-12)
                if len(frames) < minimum_frames(label):
                    assert actual == 0.0
                checked += 1
    report = {'emissions':emissions,'greedy_path':greedy,'greedy_label':collapse(greedy),
        'label_probabilities':masses,'best_label':best,'repeated_label_T3':repeat_prob,
        'forward_enumeration_pairs_checked':checked,
        'scope':'Specified frame probabilities; no acoustic model, tokenizer, language model or framework execution.'}
    Path('report.json').write_text(json.dumps(report,indent=2,allow_nan=False)+'\n',encoding='utf-8')
    print(f'checks passed: collapse order, total mass, minimum frames, {checked} forward/enumeration pairs')


if __name__ == '__main__':
    main()

"""Actual CPU CTCLoss versus exhaustive paths; fixed inputs, no training."""
from collections import defaultdict
from fractions import Fraction
from itertools import product
import json
import math
from pathlib import Path
import platform
import sys
import torch

torch.set_num_threads(1)
SYMBOLS = ('_', 'a', 'b')
FRAME = (Fraction(1, 2), Fraction(2, 5), Fraction(1, 10))


def enumerate_fixed_frames(frame_count):
    masses = defaultdict(Fraction)
    for indices in product(range(3), repeat=frame_count):
        path = tuple(SYMBOLS[index] for index in indices)
        merged = [symbol for i, symbol in enumerate(path) if i == 0 or symbol != path[i - 1]]
        label = ''.join(symbol for symbol in merged if symbol != '_')
        masses[label] += math.prod(FRAME[index] for index in indices)
    assert sum(masses.values()) == 1
    return dict(masses)


def framework_loss(frame_count, label, zero_infinity=False):
    probabilities = torch.tensor([float(value) for value in FRAME], dtype=torch.float64, device='cpu')
    log_probs = probabilities.log().repeat(frame_count, 1).unsqueeze(1)
    targets = torch.tensor([SYMBOLS.index(char) for char in label], dtype=torch.long, device='cpu')
    input_lengths = torch.tensor([frame_count], dtype=torch.long, device='cpu')
    target_lengths = torch.tensor([len(label)], dtype=torch.long, device='cpu')
    loss = torch.nn.CTCLoss(blank=0, reduction='none', zero_infinity=zero_infinity)(
        log_probs, targets, input_lengths, target_lengths)
    assert list(log_probs.shape) == [frame_count, 1, 3]
    assert list(loss.shape) == [1]
    return loss.item()


def main():
    print(f'Python {platform.python_version()}; torch {torch.__version__}; device=cpu; dtype=float64; threads=1')
    print('each frame: blank=0.5, a=0.4, b=0.1; blank index=0; reduction=none; batch size=1')
    cases = []
    for frame_count in [2, 3]:
        reference = enumerate_fixed_frames(frame_count)
        for label in ['a', 'aa', '']:
            expected = reference.get(label, Fraction(0))
            loss = framework_loss(frame_count, label)
            recovered = math.exp(-loss)
            error = abs(recovered - float(expected))
            assert error < 1e-12
            if expected == 0:
                assert math.isinf(loss) and loss > 0
            else:
                assert math.isfinite(loss)
            loss_text = f'{loss:.6f}' if math.isfinite(loss) else 'inf'
            print(f'T={frame_count} target={label or "<empty>"}: loss={loss_text}; exp(-loss)={recovered:.6f}; '
                  f'enumerated={float(expected):.6f} ({expected}); error={error:.3e}')
            cases.append({'frames': frame_count, 'target': label,
                          'loss': loss if math.isfinite(loss) else 'Infinity',
                          'exp_negative_loss': recovered, 'enumerated_probability': float(expected),
                          'exact_probability_fraction': str(expected), 'absolute_error': error})
    assert enumerate_fixed_frames(2).get('aa', Fraction(0)) == 0
    assert enumerate_fixed_frames(3)['aa'] == Fraction(2, 25)
    zeroed_loss = framework_loss(2, 'aa', zero_infinity=True)
    assert zeroed_loss == 0.0
    raw_exponent_of_zeroed = math.exp(-zeroed_loss)
    assert raw_exponent_of_zeroed == 1.0
    assert enumerate_fixed_frames(2).get('aa', Fraction(0)) == 0
    print('T=2 target=aa with zero_infinity=True: loss=0.000000; exp(-zeroed loss)=1.000000; actual path probability remains 0.000000')
    print('zero_infinity changes the loss value; exp(-zeroed loss) is not the impossible target probability')
    print('checks passed: 6 CPU CTCLoss/path comparisons, empty targets, repeated-label reachability, zero_infinity distinction')
    report = {'python': sys.version, 'executable': sys.executable, 'torch': torch.__version__,
              'torch_path': torch.__file__, 'device': 'cpu', 'dtype': 'float64',
              'threads': torch.get_num_threads(), 'frame_probabilities_blank_a_b': [0.5, 0.4, 0.1],
              'blank': 0, 'reduction': 'none', 'cases': cases,
              'max_probability_error': max(case['absolute_error'] for case in cases),
              'zero_infinity_case': {'frames': 2, 'target': 'aa', 'raw_loss': 'Infinity',
                                     'zeroed_loss': zeroed_loss,
                                     'exp_negative_zeroed_loss': raw_exponent_of_zeroed,
                                     'enumerated_probability_unchanged': 0.0},
              'scope': 'Actual CPU PyTorch CTCLoss on fixed 2/3-frame probabilities and targets a/aa/empty, reduction none; exact rational path enumeration and zero_infinity comparison. No acoustic model, optimizer, training, GPU, decoding benchmark or gradient evaluation.'}
    Path('ctc-torch-report.json').write_text(json.dumps(report, indent=2, allow_nan=False) + '\n', encoding='utf-8')


if __name__ == '__main__':
    main()