同一个卷积窗口，输入挪一格，输出为什么不只跟着挪？

"""Exact finite 1-D cross-correlation: circular shift, stride and zero boundary."""
import csv
import json
from fractions import Fraction as F
from itertools import product
from pathlib import Path

ROOT = Path(__file__).resolve().parent
KERNEL = [1, 2, 3]  # Left, center, right: no kernel reversal.
INPUTS = {'impulse': [1, 0, 0, 0, 0, 0, 0, 0],
          'ramp': list(range(8)), 'constant': [2] * 8}


def shift(values, distance, boundary):
    if not values or type(distance) is not int or boundary not in ('circular', 'zeros'):
        raise ValueError('nonempty values, integer shift and known boundary required')
    n = len(values)
    return [values[(i-distance) % n] if boundary == 'circular' else
            values[i-distance] if 0 <= i-distance < n else 0 for i in range(n)]


def correlate(values, kernel, stride, boundary):
    if not values or len(kernel) != 3 or type(stride) is not int or stride not in (1, 2):
        raise ValueError('nonempty input, three weights and stride 1/2 required')
    if len(values) % stride or boundary not in ('circular', 'zeros'):
        raise ValueError('length must be divisible by stride; boundary must be known')
    result = []
    for center in range(0, len(values), stride):
        total = 0
        for j, weight in enumerate(kernel):
            index = center+j-1
            value = values[index % len(values)] if boundary == 'circular' else values[index] if 0 <= index < len(values) else 0
            total += weight*value
        result.append(total)
    return result


def main():
    rows, summaries = [], []
    for name, values in INPUTS.items():
        for stride in (1, 2):
            base = correlate(values, KERNEL, stride, 'circular')
            for distance in range(len(values)):
                moved = shift(values, distance, 'circular')
                actual = correlate(moved, KERNEL, stride, 'circular')
                rotations = [k for k in range(len(base)) if shift(base, k, 'circular') == actual]
                expected_shift = distance//stride if distance % stride == 0 else None
                expected = shift(base, expected_shift, 'circular') if expected_shift is not None else None
                if expected is not None:
                    assert actual == expected
                mean = F(sum(actual), len(actual))
                if stride == 1:
                    assert mean == F(sum(base), len(base))
                record = {'input': name, 'stride': stride, 'input_shift': distance,
                          'base_output': base, 'shifted_input': moved, 'actual_output': actual,
                          'expected_output_shift': expected_shift, 'expected_output': expected,
                          'matching_output_rotations': rotations, 'mean': str(mean)}
                summaries.append(record)
                for i, value in enumerate(actual):
                    rows.append({'input': name, 'stride': stride, 'input_shift': distance,
                                 'output_index': i, 'center': i*stride, 'actual': value,
                                 'expected_if_divisible': '' if expected is None else expected[i]})
    impulse = [s for s in summaries if s['input'] == 'impulse' and s['stride'] == 2]
    assert impulse[0]['actual_output'] == [2, 0, 0, 0]
    assert impulse[1]['actual_output'] == [3, 1, 0, 0]
    assert all(s['matching_output_rotations'] == [] for s in impulse if s['input_shift'] % 2)
    assert [s['mean'] for s in impulse] == ['1/2', '1']*4
    # Exhaust all 256 binary length-eight inputs; no random testing or seed.
    exhaustive = {'input_vectors': 0, 'stride1_shift_checks': 0, 'stride2_even_shift_checks': 0}
    for values in product((0, 1), repeat=8):
        exhaustive['input_vectors'] += 1
        for stride in (1, 2):
            base = correlate(values, KERNEL, stride, 'circular')
            for distance in range(0, 8, stride):
                assert correlate(shift(values, distance, 'circular'), KERNEL, stride, 'circular') == shift(base, distance//stride, 'circular')
                key = 'stride1_shift_checks' if stride == 1 else 'stride2_even_shift_checks'
                exhaustive[key] += 1
    boundaries = []
    for name, values in [('edge_impulse', INPUTS['impulse']), ('interior_impulse', [0,0,0,1,0,0,0,0])]:
        base = correlate(values, KERNEL, 1, 'zeros')
        moved = shift(values, 1, 'zeros')
        actual = correlate(moved, KERNEL, 1, 'zeros')
        expected = shift(base, 1, 'zeros')
        mismatch = [i for i,(a,b) in enumerate(zip(actual,expected)) if a != b]
        boundaries.append({'case':name,'input':values,'base_output':base,'shifted_input':moved,
                           'actual_output':actual,'shift_of_base_output':expected,'mismatch_positions':mismatch})
    assert boundaries[0]['mismatch_positions'] == [0] and boundaries[1]['mismatch_positions'] == []
    rejected = []
    for name,args in [('empty',([],KERNEL,1,'circular')),('even_kernel',([1,2],[1,2],1,'circular')),
                      ('stride_zero',([1,2],KERNEL,0,'circular')),('odd_length_stride2',([1,2,3],KERNEL,2,'circular')),
                      ('unknown_boundary',([1,2],KERNEL,1,'unknown'))]:
        try:
            correlate(*args)
        except ValueError:
            rejected.append(name)
        else:
            raise AssertionError(name)
    inputs={'kernel':KERNEL,'kernel_direction':'left center right; cross-correlation, no reversal',
            'inputs':INPUTS,'strides':[1,2],'circular_shifts':list(range(8)),
            'zero_boundary_cases':{'edge_impulse':INPUTS['impulse'],'interior_impulse':[0,0,0,1,0,0,0,0]},
            'zero_boundary_shift':1,'centers':'0, stride, 2*stride, ... < length; symmetric one-position padding'}
    report={'scope':'Exact finite integer operators; no learned CNN, framework execution, anti-alias filter or accuracy experiment',
            'circular_cases':summaries,'output_rows':len(rows),'boundary_cases':boundaries,'exhaustive':exhaustive,'rejected_inputs':rejected}
    (ROOT/'shift-inputs.json').write_text(json.dumps(inputs,indent=2)+'\n',encoding='utf-8')
    (ROOT/'shift-report.json').write_text(json.dumps(report,indent=2)+'\n',encoding='utf-8')
    with (ROOT/'shift-outputs.csv').open('w',encoding='utf-8',newline='') as handle:
        writer=csv.DictWriter(handle,fieldnames=list(rows[0]));writer.writeheader();writer.writerows(rows)
    print(f'PASS shift_correlation: {len(summaries)} circular cases, {len(rows)} output rows, 2 boundary cases, 3072 exhaustive identities')


if __name__ == '__main__':
    main()