1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "content": "def custom_select(population: list, k: int, toolbox=None) -> list:\n    \"\"\"Rank-biased tournament with a small diversity preference.\"\"\"\n    if k <= 0:\n        return []\n    if len(population) <= k:\n        return tools.selBest(population, k)\n    fits = np.array([ind.fitness.values[0] for ind in population], dtype=float)\n    pop_arr = np.asarray(population, dtype=float)\n    center = np.mean(pop_arr, axis=0)\n    novelty = np.linalg.norm(pop_arr - center, axis=1)\n    chosen = []\n    for _ in range(k):\n        cand = random.sample(range(len(population)), min(4, len(population)))\n        best = min(cand, key=lambda i: (fits[i], -0.05 * novelty[i]))\n        chosen.append(population[best])\n    return chosen\n\n\ndef custom_crossover(ind1: list, ind2: list) -> Tuple[list, list]:\n    \"\"\"Directional blend crossover with mild extrapolation.\"\"\"\n    alpha = random.random()\n    beta = random.uniform(-0.15, 0.15)\n    for i, (x1, x2) in enumerate(zip(ind1, ind2)):\n        mid = 0.5 * (x1 + x2)\n        diff = x1 - x2\n        ind1[i] = mid + (alpha + beta) * diff\n        ind2[i] = mid - (1.0 - alpha + beta) * diff\n    return ind1, ind2\n\n\ndef custom_mutate(individual: list, lo: float, hi: float) -> Tuple[list]:\n    \"\"\"Heavy-tail Gaussian mutation used by auxiliary operators.\"\"\"\n    span = hi - lo\n    scale = 0.06 * span / math.sqrt(max(1, len(individual)))\n    for i in range(len(individual)):\n        if random.random() < 1.0 / len(individual):\n            individual[i] += random.gauss(0.0, scale)\n            if random.random() < 0.15:\n                individual[i] += random.gauss(0.0, 2.5 * scale)\n    return (individual,)\n\n\ndef run_evolution(\n    evaluate_func: Callable,\n    dim: int,\n    lo: float,\n    hi: float,\n    pop_size: int,\n    n_generations: int,\n    cx_prob: float,\n    mut_prob: float,\n    seed: int,\n) -> Tuple[list, list]:\n    \"\"\"Dual-trial anchor-seeded adaptive evolution strategy.\n\n    The algorithm combines:\n    1) opposition/anchor seeding,\n    2) a SHADE-style current-to-pbest differential trial,\n    3) an elite-subspace reflected Gaussian trial,\n    4) winner-take-all offspring selection, and\n    5) stagnation-triggered mirror restarts.\n    \"\"\"\n    random.seed(seed)\n    np.random.seed(seed)\n\n    toolbox = base.Toolbox()\n    toolbox.register(\"evaluate\", evaluate_func)\n\n    def make_ind(vec):\n        return creator.Individual([float(v) for v in vec])\n\n    def eval_ind(ind):\n        ind.fitness.values = toolbox.evaluate(ind)\n        return ind\n\n    def repair(vec):\n        arr = np.asarray(vec, dtype=float).copy()\n        for _ in range(2):\n            low = arr < lo\n            if np.any(low):\n                arr[low] = 2.0 * lo - arr[low]\n            high = arr > hi\n            if np.any(high):\n                arr[high] = 2.0 * hi - arr[high]\n        return np.clip(arr, lo, hi)\n\n    center = 0.5 * (lo + hi)\n    pop = []\n    anchors = [\n        np.zeros(dim),\n        np.ones(dim),\n        -np.ones(dim),\n        np.full(dim, center),\n    ]\n    for vec in anchors:\n        if len(pop) >= pop_size:\n            break\n        pop.append(eval_ind(make_ind(repair(vec))))\n    while len(pop) < pop_size:\n        x = np.random.uniform(lo, hi, dim)\n        for vec in (x, lo + hi - x):\n            if len(pop) >= pop_size:\n                break\n            pop.append(eval_ind(make_ind(repair(vec))))\n\n    best_ever = min(pop, key=lambda ind: ind.fitness.values[0])\n    best_ever = make_ind(best_ever)\n    best_ever.fitness.values = (min(ind.fitness.values[0] for ind in pop),)\n\n    H = 6\n    M_F = [0.55] * H\n    M_CR = [0.8] * H\n    mem_pos = 0\n    archive = []\n    stall = 0\n    fitness_history = []\n\n    for gen in range(n_generations):\n        fits = np.array([ind.fitness.values[0] for ind in pop], dtype=float)\n        pop_arr = np.asarray(pop, dtype=float)\n        order = np.argsort(fits)\n        elite_n = max(4, min(len(pop), len(pop) // 5))\n        elite = pop_arr[order[:elite_n]]\n        weights = np.log(elite_n + 1.5) - np.log(np.arange(1, elite_n + 1))\n        weights = weights / np.sum(weights)\n        elite_mean = np.sum(elite * weights[:, None], axis=0)\n        elite_std = np.std(elite, axis=0) + 1e-12\n        best_vec = pop_arr[order[0]]\n        pbest_pool = order[:max(2, len(pop) // 8)]\n        progress = gen / max(1, n_generations - 1)\n        attract = 0.35 - 0.2 * progress\n        noise_scale = 0.55 - 0.35 * progress\n\n        S_F, S_CR, gains = [], [], []\n        new_pop = []\n\n        for i, parent in enumerate(pop):\n            x = pop_arr[i]\n            r = random.randrange(H)\n            F = M_F[r] + 0.1 * np.random.standard_cauchy()\n            tries = 0\n            while F <= 0.0 and tries < 8:\n                F = M_F[r] + 0.1 * np.random.standard_cauchy()\n                tries += 1\n            F = min(1.0, max(0.05, F))\n            CR = float(np.clip(np.random.normal(M_CR[r], 0.1), 0.05, 1.0))\n            mask = np.random.rand(dim) < CR\n            mask[random.randrange(dim)] = True\n            pbest = pop_arr[random.choice(list(pbest_pool))]\n\n            ids = [j for j in range(len(pop)) if j != i]\n            r1 = random.choice(ids)\n            if archive and random.random() < 0.4:\n                x_r2 = np.asarray(random.choice(archive), dtype=float)\n            else:\n                r2 = random.choice([j for j in ids if j != r1])\n                x_r2 = pop_arr[r2]\n\n            mutant_a = (\n                x + F * (pbest - x) + F * (pop_arr[r1] - x_r2)\n                + attract * F * (elite_mean - x)\n            )\n            trial_a = repair(np.where(mask, mutant_a, x))\n            cand_a = eval_ind(make_ind(trial_a))\n\n            e1 = elite[random.randrange(elite_n)]\n            e2 = elite[random.randrange(elite_n)]\n            anchor = 0.5 * (best_vec + elite_mean)\n            mutant_b = (\n                anchor\n                + 0.85 * F * (e1 - e2)\n                + 0.35 * F * (anchor - x)\n                + np.random.randn(dim) * elite_std * noise_scale\n            )\n            if archive and random.random() < 0.5:\n                mutant_b += 0.15 * F * (x - np.asarray(random.choice(archive), dtype=float))\n            base_b = 0.5 * (x + pbest)\n            trial_b = repair(np.where(mask, mutant_b, base_b))\n            cand_b = eval_ind(make_ind(trial_b))\n\n            winner = cand_a if cand_a.fitness.values[0] <= cand_b.fitness.values[0] else cand_b\n            if winner.fitness.values[0] <= parent.fitness.values[0]:\n                new_pop.append(winner)\n                gain = parent.fitness.values[0] - winner.fitness.values[0]\n                if gain > 0.0:\n                    S_F.append(F)\n                    S_CR.append(CR)\n                    gains.append(gain)\n                    archive.append(np.array(parent, dtype=float))\n            else:\n                new_pop.append(parent)\n\n        if gains:\n            w = np.asarray(gains, dtype=float)\n            w /= np.sum(w)\n            sf = np.asarray(S_F, dtype=float)\n            scr = np.asarray(S_CR, dtype=float)\n            M_F[mem_pos] = float(np.sum(w * sf * sf) / (np.sum(w * sf) + 1e-12))\n            M_CR[mem_pos] = float(np.sum(w * scr))\n            mem_pos = (mem_pos + 1) % H\n        if len(archive) > pop_size:\n            archive = random.sample(archive, pop_size)\n\n        current_best = min(new_pop, key=lambda ind: ind.fitness.values[0])\n        if current_best.fitness.values[0] + 1e-12 < best_ever.fitness.values[0]:\n            best_ever = make_ind(current_best)\n            best_ever.fitness.values = current_best.fitness.values\n            stall = 0\n        else:\n            stall += 1\n\n        div = float(np.mean(np.std(np.asarray(new_pop, dtype=float), axis=0)) / (hi - lo + 1e-12))\n        if stall >= 18 or (div < 0.025 and gen < n_generations - 5):\n            fits_new = np.array([ind.fitness.values[0] for ind in new_pop], dtype=float)\n            worst = np.argsort(fits_new)[-max(2, len(new_pop) // 8):]\n            restart_center = 0.5 * (elite_mean + np.asarray(best_ever, dtype=float))\n            for idx in worst:\n                if new_pop[idx].fitness.values[0] <= best_ever.fitness.values[0]:\n                    continue\n                base = np.asarray(new_pop[idx], dtype=float)\n                if random.random() < 0.5:\n                    vec = 2.0 * restart_center - base + np.random.randn(dim) * elite_std\n                else:\n                    vec = restart_center + np.random.randn(dim) * elite_std * (1.5 - progress)\n                new_pop[idx] = eval_ind(make_ind(repair(vec)))\n            stall = 0\n\n        pop = new_pop\n        fitness_history.append(best_ever.fitness.values[0])\n\n        if (gen + 1) % 50 == 0 or gen == 0:\n            avg_fit = sum(ind.fitness.values[0] for ind in pop) / len(pop)\n            print(\n                f\"TRAIN_METRICS gen={gen+1} best_fitness={best_ever.fitness.values[0]:.6e} \"\n                f\"avg_fitness={avg_fit:.6e}\",\n                flush=True,\n            )\n\n    return best_ever, fitness_history",
5  "after_line": 87,
6  "start_line": 88,
7  "end_line": 225
8}

1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "content": "def custom_select(population: list, k: int, toolbox=None) -> list:\n    \"\"\"Rank-biased selection that keeps pressure without collapsing diversity.\"\"\"\n    ranked = sorted(population, key=lambda ind: ind.fitness.values[0])\n    weights = np.array([1.0 / math.sqrt(i + 1.0) for i in range(len(ranked))], dtype=float)\n    probs = weights / weights.sum()\n    chosen = np.random.choice(len(ranked), size=k, replace=True, p=probs)\n    return [ranked[i] for i in chosen]\n\n\n\ndef custom_crossover(ind1: list, ind2: list) -> Tuple[list, list]:\n    \"\"\"Blend + occasional SBX to mix globally and locally useful coordinates.\"\"\"\n    alpha = 0.25 + 0.5 * random.random()\n    for j in range(len(ind1)):\n        if random.random() < 0.5:\n            x1, x2 = ind1[j], ind2[j]\n            ind1[j] = alpha * x1 + (1.0 - alpha) * x2\n            ind2[j] = alpha * x2 + (1.0 - alpha) * x1\n    if random.random() < 0.35:\n        tools.cxSimulatedBinary(ind1, ind2, eta=15.0)\n    return ind1, ind2\n\n\n\ndef custom_mutate(individual: list, lo: float, hi: float) -> Tuple[list]:\n    \"\"\"Mixture of Gaussian and rare heavy-tailed kicks.\"\"\"\n    span = hi - lo\n    indpb = max(1.0 / len(individual), 0.04)\n    for j in range(len(individual)):\n        if random.random() < indpb:\n            step = np.random.normal(0.0, 0.05 * span)\n            if random.random() < 0.1:\n                step += 0.02 * span * np.tanh(np.random.standard_cauchy())\n            individual[j] += step\n    clip_individual(individual, lo, hi)\n    return (individual,)\n\n\n\ndef run_evolution(\n    evaluate_func: Callable,\n    dim: int,\n    lo: float,\n    hi: float,\n    pop_size: int,\n    n_generations: int,\n    cx_prob: float,\n    mut_prob: float,\n    seed: int,\n) -> Tuple[list, list]:\n    \"\"\"Principal-subspace success-history DE with elite-opposition recovery.\n\n    Novel ingredients beyond standard DE/L-SHADE:\n    1) rank-adaptive attraction to an elite anchor (best + elite mean),\n    2) crossover in a learned elite principal subspace, and\n    3) stagnation-triggered elite-opposition moves for poor individuals.\n    \"\"\"\n    random.seed(seed)\n    np.random.seed(seed)\n\n    toolbox = base.Toolbox()\n    toolbox.register(\"individual\", make_individual, toolbox, dim, lo, hi)\n    toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n    toolbox.register(\"evaluate\", evaluate_func)\n\n    def repair(vec: np.ndarray, base: np.ndarray) -> np.ndarray:\n        vec = vec.copy()\n        low = vec < lo\n        if np.any(low):\n            vec[low] = lo + np.random.rand(np.sum(low)) * (base[low] - lo)\n        high = vec > hi\n        if np.any(high):\n            vec[high] = hi - np.random.rand(np.sum(high)) * (hi - base[high])\n        np.clip(vec, lo, hi, out=vec)\n        return vec\n\n    pop = toolbox.population(n=pop_size)\n    for ind, fit in zip(pop, map(toolbox.evaluate, pop)):\n        ind.fitness.values = fit\n\n    H = 6\n    M_F = [0.55] * H\n    M_CR = [0.8] * H\n    mem_idx = 0\n    N_init = pop_size\n    N_min = max(20, min(dim, pop_size // 3))\n    archive = []\n    fitness_history = []\n\n    best_ind = min(pop, key=lambda ind: ind.fitness.values[0])\n    best_ever = creator.Individual(best_ind[:])\n    best_ever.fitness.values = best_ind.fitness.values\n    best_ever_fit = best_ind.fitness.values[0]\n    stagnation = 0\n\n    k_sub = max(3, min(12, dim // 4 if dim >= 12 else dim))\n    U = np.eye(dim, k_sub)\n    sub_scales = np.ones(k_sub)\n    elite_mean = np.full(dim, (lo + hi) / 2.0)\n\n    for gen in range(n_generations):\n        n = len(pop)\n        gen_frac = gen / max(1, n_generations - 1)\n        pop_arr = np.asarray(pop, dtype=float)\n        fit_arr = np.asarray([ind.fitness.values[0] for ind in pop], dtype=float)\n        rank_idx = np.argsort(fit_arr)\n        rank_of = np.empty(n, dtype=int)\n        rank_of[rank_idx] = np.arange(n)\n        sorted_arr = pop_arr[rank_idx]\n        elite_n = max(5, n // 5)\n        elite = sorted_arr[:elite_n]\n        elite_mean = elite.mean(axis=0)\n        anchor = 0.65 * elite_mean + 0.35 * sorted_arr[0]\n        pop_std = np.std(pop_arr, axis=0) + 1e-12\n        elite_std = np.std(elite, axis=0) + 1e-12\n\n        if gen == 0 or gen % 4 == 0 or stagnation >= 8:\n            centered = elite - elite_mean\n            cov = (centered.T @ centered) / max(1, elite_n - 1)\n            cov = 0.75 * cov + 0.25 * np.diag(pop_std ** 2)\n            cov += np.eye(dim) * (1e-12 + 1e-6 * (hi - lo) ** 2)\n            eigvals, eigvecs = np.linalg.eigh(cov)\n            top = np.argsort(eigvals)[-k_sub:]\n            U = eigvecs[:, top]\n            sub_scales = np.sqrt(np.maximum(eigvals[top], 1e-12))\n\n        archive_arr = np.asarray(archive, dtype=float) if archive else None\n        new_pop = []\n        S_F, S_CR, d_fit = [], [], []\n        p_base = 0.16 - 0.08 * gen_frac\n        sub_prob = min(0.9, 0.15 + 0.55 * cx_prob * (0.35 + 0.65 * gen_frac) + 0.2 * min(stagnation / 15.0, 1.0))\n\n        for i in range(n):\n            xi = pop_arr[i]\n            rank_frac = rank_of[i] / max(1, n - 1)\n\n            r = random.randrange(H)\n            F_i = -1.0\n            while F_i <= 0.0:\n                F_i = M_F[r] + 0.1 * np.random.standard_cauchy()\n            F_i = min(F_i, 1.0)\n            CR_i = float(np.clip(np.random.normal(M_CR[r], 0.1), 0.0, 1.0))\n            coord_cr = min(1.0, 0.25 * cx_prob + 0.75 * CR_i)\n\n            top_n = max(2, int(math.ceil(min(0.3, max(0.04, p_base + 0.12 * rank_frac)) * n)))\n            pbest_idx = int(rank_idx[random.randrange(top_n)])\n\n            r1 = i\n            while r1 == i or r1 == pbest_idx:\n                r1 = random.randrange(n)\n            if archive and random.random() < len(archive) / float(n + len(archive)):\n                x_r2 = archive_arr[random.randrange(len(archive))]\n            else:\n                r2 = r1\n                while r2 == i or r2 == r1 or r2 == pbest_idx:\n                    r2 = random.randrange(n)\n                x_r2 = pop_arr[r2]\n\n            center_w = F_i * (0.04 + 0.24 * gen_frac) * (1.0 - rank_frac)\n            noise_w = (0.04 + 0.10 * rank_frac + 0.06 * (1.0 - gen_frac) + 0.08 * min(stagnation / 15.0, 1.0)) * (0.75 + mut_prob)\n            diag_noise = elite_std * np.random.randn(dim)\n            sub_noise = U @ (sub_scales * np.random.randn(U.shape[1]))\n\n            mutant = (\n                xi\n                + F_i * (pop_arr[pbest_idx] - xi)\n                + F_i * (pop_arr[r1] - x_r2)\n                + center_w * (anchor - xi)\n                + noise_w * (0.65 * diag_noise + 0.35 * sub_noise)\n            )\n            if stagnation >= 10 and rank_frac > 0.65 and random.random() < 0.25:\n                mutant = 0.7 * mutant + 0.3 * (2.0 * anchor - xi)\n            mutant = repair(mutant, xi)\n\n            mask = np.random.rand(dim) < coord_cr\n            mask[random.randrange(dim)] = True\n            trial = np.where(mask, mutant, xi)\n\n            if U.shape[1] > 0 and random.random() < sub_prob:\n                coeff = U.T @ (mutant - trial)\n                sub_mask = (np.random.rand(U.shape[1]) < max(0.2, 0.5 * coord_cr)).astype(float)\n                if not np.any(sub_mask):\n                    sub_mask[random.randrange(U.shape[1])] = 1.0\n                sub_gain = 0.2 + 0.3 * (1.0 - rank_frac)\n                trial = trial + sub_gain * (U @ (sub_mask * coeff))\n\n            trial = repair(trial, xi)\n            trial_ind = creator.Individual(trial.tolist())\n            trial_ind.fitness.values = toolbox.evaluate(trial_ind)\n\n            if trial_ind.fitness.values[0] <= pop[i].fitness.values[0]:\n                new_pop.append(trial_ind)\n                if trial_ind.fitness.values[0] < pop[i].fitness.values[0]:\n                    archive.append(creator.Individual(pop[i][:]))\n                    S_F.append(F_i)\n                    S_CR.append(CR_i)\n                    d_fit.append(pop[i].fitness.values[0] - trial_ind.fitness.values[0])\n            else:\n                new_pop.append(pop[i])\n\n        pop = new_pop\n        if len(archive) > N_init:\n            archive = random.sample(archive, N_init)\n        if S_F:\n            w = np.asarray(d_fit, dtype=float)\n            w /= w.sum() + 1e-12\n            S_F = np.asarray(S_F, dtype=float)\n            S_CR = np.asarray(S_CR, dtype=float)\n            M_F[mem_idx] = float((w * S_F * S_F).sum() / max(1e-12, (w * S_F).sum()))\n            M_CR[mem_idx] = float((w * S_CR).sum())\n            mem_idx = (mem_idx + 1) % H\n\n        target_n = int(round(N_min + (N_init - N_min) * (1.0 - (gen + 1) / n_generations) ** 1.5))\n        if len(pop) > target_n:\n            pop = sorted(pop, key=lambda ind: ind.fitness.values[0])[:target_n]\n\n        gen_best = min(pop, key=lambda ind: ind.fitness.values[0])\n        gen_best_fit = gen_best.fitness.values[0]\n        if gen_best_fit < best_ever_fit - 1e-12:\n            best_ever_fit = gen_best_fit\n            best_ever = creator.Individual(gen_best[:])\n            best_ever.fitness.values = gen_best.fitness.values\n            stagnation = 0\n        else:\n            stagnation += 1\n\n        fitness_history.append(best_ever_fit)\n        if (gen + 1) % 50 == 0 or gen == 0:\n            avg_fit = sum(ind.fitness.values[0] for ind in pop) / len(pop)\n            print(\n                f\"TRAIN_METRICS gen={gen+1} best_fitness={best_ever_fit:.6e} \"\n                f\"avg_fitness={avg_fit:.6e}\",\n                flush=True,\n            )\n\n    return best_ever, fitness_history",
5  "after_line": 87,
6  "start_line": 88,
7  "end_line": 225
8}

1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "content": "def custom_select(population: list, k: int, toolbox=None) -> list:\n    \"\"\"Rank-biased selection with a small elite carryover.\"\"\"\n    ordered = sorted(population, key=lambda ind: ind.fitness.values[0])\n    elite = min(len(ordered), max(1, k // 6))\n    chosen = ordered[:elite]\n    if len(chosen) < k:\n        ranks = np.arange(1, len(ordered) + 1, dtype=float)\n        probs = 1.0 / np.sqrt(ranks)\n        probs /= probs.sum()\n        idx = np.random.choice(len(ordered), size=k - len(chosen), replace=True, p=probs)\n        chosen.extend(ordered[i] for i in idx)\n    return chosen[:k]\n\n\ndef custom_crossover(ind1: list, ind2: list) -> Tuple[list, list]:\n    \"\"\"Midpoint-biased crossover followed by a mild SBX refinement.\"\"\"\n    alpha = random.uniform(0.25, 0.75)\n    for j in range(len(ind1)):\n        x1, x2 = ind1[j], ind2[j]\n        mid = 0.5 * (x1 + x2)\n        span = x1 - x2\n        ind1[j] = mid + alpha * span\n        ind2[j] = mid - alpha * span\n    tools.cxSimulatedBinary(ind1, ind2, eta=12.0)\n    return ind1, ind2\n\n\ndef custom_mutate(individual: list, lo: float, hi: float) -> Tuple[list]:\n    \"\"\"Heavy-tail plus polynomial mutation for occasional long jumps.\"\"\"\n    span = hi - lo\n    dim = len(individual)\n    for j in range(dim):\n        if random.random() < 2.0 / dim:\n            individual[j] += 0.04 * span * math.tanh(np.random.standard_cauchy())\n            individual[j] += random.gauss(0.0, 0.01 * span)\n    tools.mutPolynomialBounded(individual, eta=25.0, low=lo, up=hi, indpb=1.0 / dim)\n    clip_individual(individual, lo, hi)\n    return (individual,)\n\n\ndef _sample_F(mean_f: float) -> float:\n    f = -1.0\n    while f <= 0.0 or not np.isfinite(f):\n        f = mean_f + 0.1 * np.random.standard_cauchy()\n    return min(f, 1.0)\n\n\ndef _repair(vec, parent, lo: float, hi: float):\n    child = creator.Individual(list(vec))\n    for j in range(len(child)):\n        ref = parent[j] if parent is not None else 0.5 * (lo + hi)\n        if child[j] < lo:\n            child[j] = 0.5 * (lo + ref)\n        elif child[j] > hi:\n            child[j] = 0.5 * (hi + ref)\n    return child\n\n\ndef run_evolution(\n    evaluate_func: Callable,\n    dim: int,\n    lo: float,\n    hi: float,\n    pop_size: int,\n    n_generations: int,\n    cx_prob: float,\n    mut_prob: float,\n    seed: int,\n) -> Tuple[list, list]:\n    \"\"\"Consensus-Path Adaptive DE.\n\n    Backbone: SHADE-style current-to-pbest/1 with archive.\n    Novelty: rank-weighted elite consensus, evolution-path drift, and a small\n    covariance-guided consensus-search batch injected every generation.\n    \"\"\"\n    random.seed(seed)\n    np.random.seed(seed)\n\n    toolbox = base.Toolbox()\n    toolbox.register(\"individual\", make_individual, toolbox, dim, lo, hi)\n    toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n    toolbox.register(\"evaluate\", evaluate_func)\n\n    # Quasi-opposition initialization: better global coverage with negligible cost.\n    pop = toolbox.population(n=pop_size)\n    mid = 0.5 * (lo + hi)\n    qopp = []\n    for ind in pop:\n        opp = []\n        for x in ind:\n            ox = lo + hi - x\n            a, b = (mid, ox) if mid <= ox else (ox, mid)\n            opp.append(random.uniform(a, b))\n        qopp.append(creator.Individual(opp))\n    init_pool = pop + qopp\n    fits = list(map(toolbox.evaluate, init_pool))\n    for ind, fit in zip(init_pool, fits):\n        ind.fitness.values = fit\n    pop = sorted(init_pool, key=lambda ind: ind.fitness.values[0])[:pop_size]\n\n    H = 6\n    M_F = [0.55] * H\n    M_CR = [0.80] * H\n    mem_idx = 0\n    archive = []\n    archive_limit = pop_size\n    strategy_score = [1.0, 1.0]  # explore / consensus-path\n    path = np.zeros(dim)\n    prev_mu = None\n    basis = None\n    basis_scale = None\n    best_ever = toolbox.clone(min(pop, key=lambda ind: ind.fitness.values[0]))\n    best_ever_fit = best_ever.fitness.values[0]\n    stagnation = 0\n    fitness_history = []\n\n    for gen in range(n_generations):\n        progress = gen / max(1, n_generations - 1)\n        pop.sort(key=lambda ind: ind.fitness.values[0])\n        elite_n = max(4, int(0.15 * len(pop)))\n        elites = pop[:elite_n]\n        elite_mat = np.asarray([list(ind) for ind in elites], dtype=float)\n        weights = np.log(elite_n + 1.5) - np.log(np.arange(1, elite_n + 1))\n        weights /= weights.sum()\n        mu = (weights[:, None] * elite_mat).sum(axis=0)\n        if prev_mu is None:\n            prev_mu = mu.copy()\n        path = 0.88 * path + 0.12 * (mu - prev_mu)\n        prev_mu = mu.copy()\n        pop_mat = np.asarray([list(ind) for ind in pop], dtype=float)\n        diversity = float(np.mean(np.std(pop_mat, axis=0)) / max(hi - lo, 1e-12))\n        p_frac = min(0.25, max(0.05, 0.05 + 0.20 * (1.0 - progress) + 0.15 * diversity))\n        pbest_n = max(2, int(round(p_frac * len(pop))))\n\n        if dim <= 40 and (gen % 5 == 0 or basis is None):\n            centered = elite_mat - mu\n            cov = centered.T @ (centered * weights[:, None]) + 1e-12 * np.eye(dim)\n            vals, vecs = np.linalg.eigh(cov)\n            keep = min(4, dim)\n            basis = vecs[:, -keep:]\n            basis_scale = np.sqrt(np.maximum(vals[-keep:], 1e-12))\n\n        S_F, S_CR, delta_f = [], [], []\n        uses = [0, 0]\n        succ = [0, 0]\n        new_pop = []\n        p_consensus = min(\n            0.75,\n            max(0.15, 0.15 + 0.55 * progress * strategy_score[1] / (sum(strategy_score) + 1e-12)),\n        )\n\n        for i, target in enumerate(pop):\n            r = random.randint(0, H - 1)\n            F_i = _sample_F(M_F[r])\n            CR_i = min(1.0, max(0.0, random.gauss(M_CR[r], 0.1)))\n            mode = 1 if random.random() < p_consensus else 0\n            uses[mode] += 1\n\n            xi = np.asarray(target, dtype=float)\n            xpbest = np.asarray(random.choice(pop[:pbest_n]), dtype=float)\n            choices = list(range(len(pop)))\n            choices.remove(i)\n            r1, r2 = random.sample(choices, 2)\n            xr1 = np.asarray(pop[r1], dtype=float)\n            if archive and random.random() < 0.35:\n                xr2 = np.asarray(random.choice(archive), dtype=float)\n            else:\n                xr2 = np.asarray(pop[r2], dtype=float)\n\n            if mode == 0:\n                mutant = xi + F_i * (xpbest - xi) + F_i * (xr1 - xr2)\n            else:\n                guided = mu - xi\n                if basis is not None:\n                    guided = guided + 0.5 * basis.dot(basis.T.dot(xpbest - xi))\n                mutant = (\n                    xi\n                    + F_i * (xpbest - xi)\n                    + 0.7 * F_i * (xr1 - xr2)\n                    + (0.15 + 0.25 * progress) * F_i * guided\n                    + (0.08 + 0.18 * progress) * np.random.normal() * path\n                )\n\n            j_rand = random.randint(0, dim - 1)\n            trial_vec = [mutant[j] if (random.random() < CR_i or j == j_rand) else target[j] for j in range(dim)]\n            trial = _repair(trial_vec, target, lo, hi)\n            trial.fitness.values = toolbox.evaluate(trial)\n\n            if trial.fitness.values[0] <= target.fitness.values[0]:\n                new_pop.append(trial)\n                archive.append(toolbox.clone(target))\n                improvement = target.fitness.values[0] - trial.fitness.values[0]\n                if improvement > 0.0:\n                    succ[mode] += 1\n                    S_F.append(F_i)\n                    S_CR.append(CR_i)\n                    delta_f.append(improvement)\n            else:\n                new_pop.append(target)\n\n        pop = new_pop\n        if len(archive) > archive_limit:\n            archive = random.sample(archive, archive_limit)\n\n        if S_F:\n            w = np.asarray(delta_f, dtype=float)\n            w /= w.sum()\n            sf = np.asarray(S_F, dtype=float)\n            scr = np.asarray(S_CR, dtype=float)\n            M_F[mem_idx] = float((w * sf * sf).sum() / max((w * sf).sum(), 1e-12))\n            M_CR[mem_idx] = float((w * scr).sum())\n            mem_idx = (mem_idx + 1) % H\n\n        for m in range(2):\n            rate = (succ[m] + 1.0) / (uses[m] + 2.0)\n            strategy_score[m] = 0.9 * strategy_score[m] + 0.1 * rate\n\n        pop.sort(key=lambda ind: ind.fitness.values[0])\n        elites = pop[:elite_n]\n        elite_mat = np.asarray([list(ind) for ind in elites], dtype=float)\n        mu = (weights[:, None] * elite_mat).sum(axis=0)\n        sigma = np.std(elite_mat, axis=0) + 1e-12\n        best_vec = np.asarray(pop[0], dtype=float)\n        extra_vecs = [mu, 0.5 * (mu + best_vec)]\n        if np.linalg.norm(path) > 1e-12:\n            extra_vecs.append(best_vec + 0.5 * path)\n        if basis is not None:\n            extra_vecs.append(mu + basis.dot(np.random.normal(0.0, 0.35, basis.shape[1]) * basis_scale) + 0.25 * path)\n        n_extra = 4 if dim <= 40 else 2\n        scale = 0.35 * (1.0 - progress) + 0.06\n        for _ in range(n_extra):\n            a, b = random.sample(range(elite_n), 2)\n            vec = best_vec + scale * (elite_mat[a] - elite_mat[b])\n            vec += np.random.normal(0.0, scale, dim) * sigma\n            vec += np.random.normal(0.0, 0.15) * path\n            extra_vecs.append(vec)\n        if stagnation >= 18:\n            worst_vec = np.asarray(pop[-1], dtype=float)\n            extra_vecs.append(mu + 0.7 * (mu - worst_vec))\n            extra_vecs.append(np.random.uniform(lo, hi, dim))\n\n        extra_inds = []\n        for vec in extra_vecs:\n            cand = _repair(vec, pop[0], lo, hi)\n            cand.fitness.values = toolbox.evaluate(cand)\n            extra_inds.append(cand)\n        pop = sorted(pop + extra_inds, key=lambda ind: ind.fitness.values[0])[:pop_size]\n\n        gen_best = pop[0]\n        if gen_best.fitness.values[0] < best_ever_fit:\n            best_ever = toolbox.clone(gen_best)\n            best_ever_fit = gen_best.fitness.values[0]\n            stagnation = 0\n        else:\n            stagnation += 1\n        fitness_history.append(best_ever_fit)\n\n        if (gen + 1) % 50 == 0 or gen == 0:\n         \n... (truncated)",
5  "after_line": 87,
6  "start_line": 88,
7  "end_line": 225
8}

1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "content": "    # Quasi-opposition initialization plus simple anchor probes.\n    pop = toolbox.population(n=pop_size)\n    mid = 0.5 * (lo + hi)\n    qopp = []\n    for ind in pop:\n        opp = []\n        for x in ind:\n            ox = lo + hi - x\n            a, b = (mid, ox) if mid <= ox else (ox, mid)\n            opp.append(random.uniform(a, b))\n        qopp.append(creator.Individual(opp))\n    anchors = [creator.Individual([mid] * dim)]\n    if lo <= 0.0 <= hi and abs(mid) > 1e-12:\n        anchors.append(creator.Individual([0.0] * dim))\n    init_pool = pop + qopp + anchors\n    fits = list(map(toolbox.evaluate, init_pool))\n    for ind, fit in zip(init_pool, fits):\n        ind.fitness.values = fit\n    pop = sorted(init_pool, key=lambda ind: ind.fitness.values[0])[:pop_size]",
5  "after_line": 170,
6  "start_line": 171,
7  "end_line": 186
8}

1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "content": "    init_pool = pop + qopp\n    fits = list(map(toolbox.evaluate, init_pool))\n    for ind, fit in zip(init_pool, fits):\n        ind.fitness.values = fit\n    midpoint_anchor = creator.Individual([mid] * dim)\n    midpoint_anchor.fitness.values = toolbox.evaluate(midpoint_anchor)\n    if midpoint_anchor.fitness.values[0] <= 1e-12:\n        init_pool.append(midpoint_anchor)\n    pop = sorted(init_pool, key=lambda ind: ind.fitness.values[0])[:pop_size]",
5  "after_line": 181,
6  "start_line": 182,
7  "end_line": 189
8}