連続的概念とシェパードの法則

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

import jax
import jax.numpy as jnp

# A grid of candidate endpoints (and query positions) along a 1-D axis, 0 to 20, step 0.25.
GRID = jnp.linspace(0.0, 20.0, 81)

def all_intervals(grid):
    """Every interval [lo, hi] with endpoints on the grid and hi > lo."""
    # jnp.meshgrid builds every combination of a lo-endpoint and a hi-endpoint;
    # .reshape(-1) then flattens those grids into two long parallel lists of lo's and hi's.
    # (indexing="ij" just fixes the row/column convention; the order doesn't matter here
    # because we flatten both grids anyway.)
    los, his = jnp.meshgrid(grid, grid, indexing="ij")
    lo = los.reshape(-1)
    hi = his.reshape(-1)
    proper = hi > lo                                      # True for real intervals (hi above lo)
    # Indexing an array with a boolean mask keeps only the entries where the mask is True --
    # here, only the proper intervals.
    return lo[proper], hi[proper]

def gradient(observed, exp_rate=None, grid=GRID):
    """Generalization gradient over the grid, by enumerating interval hypotheses.

    exp_rate=None gives a flat/uniform prior over intervals; a number gives an
    exponential prior on interval length (see the next section).
    """
    lo, hi = all_intervals(grid)
    length = hi - lo                              # |h| for an interval is its length
    n = observed.shape[0]

    # Which intervals contain ALL observed examples? (consistent, like §5/§6)
    contains_all = jnp.ones(lo.shape, dtype=bool)
    for x in observed:
        contains_all = contains_all & (lo <= x) & (x <= hi)

    # Strong-sampling likelihood (1/length)^n, in log space; inconsistent intervals -> log 0.
    log_like = jnp.where(contains_all, -n * jnp.log(length), -jnp.inf)
    # Prior over intervals: flat for now (exponential prior comes next section).
    log_prior = jnp.zeros(lo.shape) if exp_rate is None else -exp_rate * length

    log_post = log_prior + log_like
    log_post = log_post - jnp.max(log_post)      # numerical stability, as before
    post = jnp.exp(log_post)
    post = post / post.sum()

    # Posterior-weighted vote at each query position y: sum the posterior of intervals containing y.
    def vote(y):
        contains_y = (lo <= y) & (y <= hi)
        return jnp.sum(jnp.where(contains_y, post, 0.0))
    return jax.vmap(vote)(grid)

observed = jnp.array([9.0, 10.0, 11.0])
g = gradient(observed)                            # flat prior over intervals

for y in [10.0, 12.0, 13.0, 15.0, 18.0]:
    i = int(jnp.argmin(jnp.abs(GRID - y)))        # nearest grid point to y
    print(f"  g({y:4.1f}) = {round(float(g[i]), 3)}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import jax.numpy as jnp

# Walk outward from the edge of the data (which ends at position 11) and, at each step,
# print g and its ratio to the previous step. A roughly CONSTANT ratio == exponential decay.
print("distance past data | g      | ratio to previous")
previous = None
for d in range(1, 7):
    y = 11.0 + d
    i = int(jnp.argmin(jnp.abs(GRID - y)))        # nearest grid point to y
    g_d = float(g[i])
    ratio = "  (first point)" if previous is None else f"{g_d / previous:.3f}"
    print(f"        {d}          | {g_d:.4f} | {ratio}")
    previous = g_d

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import jax.numpy as jnp

observed = jnp.array([9.0, 10.0, 11.0])
g_flat = gradient(observed, exp_rate=None)     # flat prior over intervals
g_exp  = gradient(observed, exp_rate=0.5)      # exponential prior on length, rate 0.5

print("       distance:   +1     +2     +4     +7")
for label, grad in [("flat ", g_flat), ("exp  ", g_exp)]:
    vals = []
    for y in [12.0, 13.0, 15.0, 18.0]:
        i = int(jnp.argmin(jnp.abs(GRID - y)))
        vals.append(round(float(grad[i]), 3))
    print(f"  {label} prior:  {vals[0]:<6} {vals[1]:<6} {vals[2]:<6} {vals[3]:<6}")