1{
2  "op": "replace",
3  "filename": "gplearn/custom_sr.py",
4  "start_line": 228,
5  "end_line": 306,
6  "content": "def fitness_function(tree, X, y):\n    \"\"\"Evaluate fitness of a candidate program. Lower is better.\"\"\"\n    y_pred = safe_evaluate(tree, X)\n    return float(np.mean((y - y_pred) ** 2))\n\n\ndef selection(population, fitnesses, n_select, tournament_size=5):\n    \"\"\"Tournament selection.\"\"\"\n    selected = []\n    pop_size = len(population)\n    for _ in range(n_select):\n        candidates = random.sample(range(pop_size), min(tournament_size, pop_size))\n        best = min(candidates, key=lambda i: fitnesses[i])\n        selected.append(population[best].copy())\n    return selected\n\n\ndef semantic_similarity(subtree1, subtree2, X_sample):\n    \"\"\"Compute semantic similarity between two subtrees using cosine similarity on sample points.\"\"\"\n    vec1 = safe_evaluate(subtree1, X_sample)\n    vec2 = safe_evaluate(subtree2, X_sample)\n    # Normalize to avoid scaling differences\n    norm1 = np.linalg.norm(vec1)\n    norm2 = np.linalg.norm(vec2)\n    if norm1 < 1e-12 or norm2 < 1e-12:\n        return 0.0\n    return np.dot(vec1, vec2) / (norm1 * norm2)\n\n\ndef crossover(parent1, parent2, n_features, max_depth=17, X_sample=None):\n    \"\"\"Semantic-aware subtree crossover.\n    \n    Attempts to find crossover points that produce semantically similar subtrees\n    to reduce destructive effects. Falls back to standard crossover if no good match.\n    \"\"\"\n    offspring = parent1.copy()\n    donor = parent2.copy()\n    \n    off_size = offspring.size()\n    don_size = donor.size()\n    if off_size <= 1 or don_size <= 1:\n        return offspring\n    \n    # Get all nodes with their depths\n    off_nodes = offspring.get_all_nodes()\n    don_nodes = donor.get_all_nodes()\n    \n    # If X_sample is not provided, create a small random sample for semantic comparison\n    if X_sample is None:\n        # Use default sample: 10 random points in [-1, 1]^n_features\n        X_sample = np.random.uniform(-1, 1, size=(10, n_features))\n    \n    # Try to find semantically similar subtrees\n    best_sim = -1.0\n    best_off_idx = -1\n    best_don_idx = -1\n    \n    # Limit search to reasonable number of pairs to avoid O(N^2) cost\n    max_pairs = min(50, len(off_nodes) * len(don_nodes))\n    for _ in range(max_pairs):\n        i = random.randint(0, len(off_nodes) - 1)\n        j = random.randint(0, len(don_nodes) - 1)\n        off_sub = off_nodes[i][0]\n        don_sub = don_nodes[j][0]\n        sim = semantic_similarity(off_sub, don_sub, X_sample)\n        if sim > best_sim:\n            best_sim = sim\n            best_off_idx = i\n            best_don_idx = j\n    \n    # If we found a reasonable semantic match, use those points\n    if best_sim > 0.5:  # threshold\n        off_point = best_off_idx\n        don_point = best_don_idx\n    else:\n        # Fallback to random points\n        off_point = random.randint(1, off_size - 1)\n        don_point = random.randint(0, don_size - 1)\n    \n    # Extract donor subtree\n    donor_subtree = don_nodes[don_point][0].copy()\n    \n    # Replace in offspring\n    node, parent, child_idx = off_nodes[off_point]\n    if parent is not None:\n        parent.children[child_idx] = donor_subtree\n    else:\n        offspring = donor_subtree\n    \n    # Reject if too deep\n    if offspring.depth() > max_depth:\n        return parent1.copy()\n    \n    return offspring\n\n\ndef mutation(parent, n_features, max_depth=17):\n    \"\"\"Subtree mutation with occasional constant optimization.\"\"\"\n    offspring = parent.copy()\n    tree_size = offspring.size()\n    if tree_size <= 1:\n        return generate_tree('grow', 3, n_features)\n    \n    mut_type = random.random()\n    if mut_type < 0.7:\n        # Standard subtree mutation\n        mut_point = random.randint(1, tree_size - 1)\n        new_subtree = generate_tree('grow', 3, n_features)\n        \n        nodes = offspring.get_all_nodes()\n        node, par, child_idx = nodes[mut_point]\n        if par is not None:\n            par.children[child_idx] = new_subtree\n        else:\n            offspring = new_subtree\n    else:\n        # Point mutation: change a single node\n        nodes = offspring.get_all_nodes()\n        if len(nodes) == 0:\n            return offspring\n        node, parent, child_idx = random.choice(nodes)\n        if node.is_terminal:\n            # Terminal mutation: change variable index or constant value\n            if isinstance(node.value, str) and node.value.startswith('x'):\n                # Change variable index\n                idx = random.randint(0, n_features - 1)\n                node.value = f'x{idx}'\n            else:\n                # Change constant by small perturbation\n                try:\n                    val = float(node.value)\n                    node.value = str(val + random.uniform(-0.5, 0.5))\n                except:\n                    node.value = str(random.uniform(-5.0, 5.0))\n        else:\n            # Function mutation: change operator to another with same arity\n            current_op = node.value\n            arity = OPERATORS[current_op][1]\n            # Find other operators with same arity\n            candidates = [op for op in OPERATOR_NAMES if OPERATORS[op][1] == arity]\n            if len(candidates) > 1:\n                candidates.remove(current_op)\n                node.value = random.choice(candidates)\n    \n    if offspring.depth() > max_depth:\n        return parent.copy()\n    \n    return offspring\n\n\ndef evolve_one_generation(population, fitnesses, X_train, y_train,\n                          n_features, pop_size,\n                          crossover_rate=0.9, mutation_rate=0.05,\n                          max_depth=17):\n    \"\"\"Create the next generation with adaptive parsimony pressure.\"\"\"\n    new_population = []\n    \n    # Adaptive parsimony coefficient (inspired by gplearn)\n    lengths = np.array([tree.size() for tree in population], dtype=float)\n    raw_fit = np.array(fitnesses, dtype=float)\n    len_var = float(np.var(lengths))\n    if len_var > 1e-15:\n        parsimony_coeff = float(np.cov(lengths, raw_fit)[1, 0]) / len_var\n        parsimony_coeff = max(parsimony_coeff, 0.0)\n        parsimony_coeff = min(parsimony_coeff, 0.001)\n    else:\n        parsimony_coeff = 0.0\n    \n    # Penalized fitnesses for selection\n    penalized = [f + parsimony_coeff * l for f, l in zip(fitnesses, lengths)]\n    \n    # Create a sample of training points for semantic crossover\n    # Use 20% of training data, but at most 20 points\n    n_sample = min(20, int(0.2 * X_train.shape[0]))\n    if n_sample > 0:\n        indices = random.sample(range(X_train.shape[0]), n_sample)\n        X_sample = X_train[indices]\n    else:\n        X_sample = X_train\n    \n    # Elitism: keep best individual by raw fitness\n    elite_idx = int(np.argmin(fitnesses))\n    new_population.append(population[elite_idx].copy())\n    \n    while len(new_population) < pop_size:\n        r = random.random()\n        if r < crossover_rate:\n            parents = selection(population, penalized, 2)\n            child = crossover(parents[0], parents[1], n_features, max_depth, X_sample)\n        elif r < crossover_rate + mutation_rate:\n            parents = selection(population, penalized, 1)\n            child = mutation(parents[0], n_features, max_depth)\n        else:\n            parents = selection(population, penalized, 1)\n            child = parents[0]\n        new_population.append(child)\n    \n    return new_population[:pop_size]"
7}

1{
2  "op": "replace",
3  "filename": "gplearn/custom_sr.py",
4  "start_line": 228,
5  "end_line": 425,
6  "content": "def fitness_function(tree, X, y):\n    \"\"\"Evaluate fitness of a candidate program. Lower is better.\"\"\"\n    y_pred = safe_evaluate(tree, X)\n    return float(np.mean((y - y_pred) ** 2))\n\n\ndef selection(population, fitnesses, n_select, tournament_size=5):\n    \"\"\"Tournament selection.\"\"\"\n    selected = []\n    pop_size = len(population)\n    for _ in range(n_select):\n        candidates = random.sample(range(pop_size), min(tournament_size, pop_size))\n        best = min(candidates, key=lambda i: fitnesses[i])\n        selected.append(population[best].copy())\n    return selected\n\n\ndef semantic_similarity(subtree1, subtree2, X_sample):\n    \"\"\"Compute semantic similarity between two subtrees using cosine similarity on sample points.\"\"\"\n    vec1 = safe_evaluate(subtree1, X_sample)\n    vec2 = safe_evaluate(subtree2, X_sample)\n    # Normalize to avoid scaling differences\n    norm1 = np.linalg.norm(vec1)\n    norm2 = np.linalg.norm(vec2)\n    if norm1 < 1e-12 or norm2 < 1e-12:\n        return 0.0\n    sim = np.dot(vec1, vec2) / (norm1 * norm2)\n    # Clip to [-1, 1] due to numerical errors\n    return np.clip(sim, -1.0, 1.0)\n\n\ndef crossover(parent1, parent2, n_features, max_depth=17, X_sample=None):\n    \"\"\"Semantic-aware subtree crossover with probabilistic selection.\"\"\"\n    offspring = parent1.copy()\n    donor = parent2.copy()\n    \n    off_size = offspring.size()\n    don_size = donor.size()\n    if off_size <= 1 or don_size <= 1:\n        return offspring\n    \n    # Get all nodes\n    off_nodes = offspring.get_all_nodes()\n    don_nodes = donor.get_all_nodes()\n    \n    # If X_sample is not provided, create a small random sample\n    if X_sample is None:\n        X_sample = np.random.uniform(-1, 1, size=(10, n_features))\n    \n    # Sample candidate pairs\n    n_pairs = min(30, len(off_nodes) * len(don_nodes))\n    pairs = []\n    sims = []\n    for _ in range(n_pairs):\n        i = random.randint(0, len(off_nodes) - 1)\n        j = random.randint(0, len(don_nodes) - 1)\n        sim = semantic_similarity(off_nodes[i][0], don_nodes[j][0], X_sample)\n        pairs.append((i, j))\n        sims.append(sim)\n    \n    # Convert similarities to probabilities (softmax)\n    sims = np.array(sims)\n    # Shift to make positive (similarity ranges -1..1)\n    sims_shifted = sims + 1.0  # now 0..2\n    # Add small epsilon to avoid zero\n    probs = sims_shifted / (np.sum(sims_shifted) + 1e-12)\n    \n    # Select pair according to probability\n    idx = random.choices(range(len(pairs)), weights=probs, k=1)[0]\n    off_point, don_point = pairs[idx]\n    \n    # Extract donor subtree\n    donor_subtree = don_nodes[don_point][0].copy()\n    \n    # Replace in offspring\n    node, parent, child_idx = off_nodes[off_point]\n    if parent is not None:\n        parent.children[child_idx] = donor_subtree\n    else:\n        offspring = donor_subtree\n    \n    # Reject if too deep\n    if offspring.depth() > max_depth:\n        return parent1.copy()\n    \n    return offspring\n\n\ndef mutate_subtree(parent, n_features, max_depth):\n    \"\"\"Standard subtree mutation.\"\"\"\n    offspring = parent.copy()\n    tree_size = offspring.size()\n    if tree_size <= 1:\n        return generate_tree('grow', 3, n_features)\n    \n    mut_point = random.randint(1, tree_size - 1)\n    new_subtree = generate_tree('grow', 3, n_features)\n    \n    nodes = offspring.get_all_nodes()\n    node, par, child_idx = nodes[mut_point]\n    if par is not None:\n        par.children[child_idx] = new_subtree\n    else:\n        offspring = new_subtree\n    \n    if offspring.depth() > max_depth:\n        return parent.copy()\n    \n    return offspring\n\n\ndef mutate_point(parent, n_features):\n    \"\"\"Point mutation: change a single node.\"\"\"\n    offspring = parent.copy()\n    nodes = offspring.get_all_nodes()\n    if len(nodes) == 0:\n        return offspring\n    node, parent_node, child_idx = random.choice(nodes)\n    \n    if node.is_terminal:\n        if isinstance(node.value, str) and node.value.startswith('x'):\n            # Change variable index\n            idx = random.randint(0, n_features - 1)\n            node.value = f'x{idx}'\n        else:\n            # Change constant by small perturbation\n            try:\n                val = float(node.value)\n                # Gaussian perturbation with std dev 0.5\n                node.value = str(val + random.gauss(0, 0.5))\n            except:\n                node.value = str(random.uniform(-5.0, 5.0))\n    else:\n        # Function mutation: change operator to another with same arity\n        current_op = node.value\n        arity = OPERATORS[current_op][1]\n        candidates = [op for op in OPERATOR_NAMES if OPERATORS[op][1] == arity]\n        if len(candidates) > 1:\n            candidates.remove(current_op)\n            node.value = random.choice(candidates)\n    \n    return offspring\n\n\ndef hill_climb_constants(tree, X, y, n_steps=10):\n    \"\"\"Simple hill climbing for numeric constants in the tree.\n    \n    Randomly selects a constant terminal and tries small adjustments,\n    keeping the change if it improves fitness.\n    \"\"\"\n    best_tree = tree.copy()\n    best_fit = fitness_function(best_tree, X, y)\n    \n    # Collect all constant nodes\n    nodes = best_tree.get_all_nodes()\n    const_nodes = []\n    for node, parent, idx in nodes:\n        if node.is_terminal and not (isinstance(node.value, str) and node.value.startswith('x')):\n            const_nodes.append((node, parent, idx))\n    \n    if not const_nodes:\n        return best_tree\n    \n    for step in range(n_steps):\n        # Pick a random constant node\n        node, parent, idx = random.choice(const_nodes)\n        old_value = float(node.value)\n        \n        # Generate perturbation\n        delta = random.gauss(0, 0.2)  # smaller step\n        new_value = old_value + delta\n        node.value = str(new_value)\n        \n        # Evaluate new fitness\n        new_fit = fitness_function(best_tree, X, y)\n        if new_fit < best_fit:\n            best_fit = new_fit\n        else:\n            # Revert\n            node.value = str(old_value)\n    \n    return best_tree\n\n\ndef mutation(parent, n_features, max_depth=17):\n    \"\"\"Mutation with multiple types.\"\"\"\n    r = random.random()\n    if r < 0.6:\n        return mutate_subtree(parent, n_features, max_depth)\n    elif r < 0.9:\n        return mutate_point(parent, n_features)\n    else:\n        # Hoist mutation: replace parent with a random child subtree\n        nodes = parent.get_all_nodes()\n        if len(nodes) <= 1:\n            return parent.copy()\n        # Choose a non-terminal node\n        non_terminals = [(node, parent_node, idx) for (node, parent_node, idx) in nodes \n                         if not node.is_terminal]\n        if not non_terminals:\n            return parent.copy()\n        node, parent_node, idx = random.choice(non_terminals)\n        if node.children:\n            child = random.choice(node.children)\n            if parent_node is not None:\n                parent_node.children[idx] = child.copy()\n            else:\n                # Replacing root\n                parent = child.copy()\n        return parent\n\n\ndef evolve_one_generation(population, fitnesses, X_train, y_train,\n                          n_features, pop_size,\n                          crossover_rate=0.9, mutation_rate=0.05,\n                          max_depth=17):\n    \"\"\"Create the next generation with adaptive parsimony and hill climbing.\"\"\"\n    new_population = []\n    \n    # Adaptive parsimony coefficient\n    lengths = np.array([tree.size() for tree in population], dtype=float)\n    raw_fit = np.array(fitnesses, dtype=float)\n    len_var = float(np.var(lengths))\n    if len_var > 1e-15:\n        parsimony_coeff = float(np.cov(lengths, raw_fit)[1, 0]) / len_var\n        parsimony_coeff = max(parsimony_coeff, 0.0)\n        parsimony_coeff = min(parsimony_coeff, 0.001)\n    else:\n        parsimony_coeff = 0.0\n    \n    # Penalized fitnesses for selection\n    penalized = [f + parsimony_coeff * l for f, l in zip(fitnesses, lengths)]\n    \n    # Create a sample of training points for semantic crossover\n    n_sample = min(20, int(0.2 * X_train.shape[0]))\n    if n_sample > 0:\n        indices = random.sample(range(X_train.shape[0]), n_sample)\n        X_sample = X_train[indices]\n    else:\n        X_sample = X_train\n    \n    # Elitism: keep best individual by raw fitness\n    elite_idx = int(np.argmin(fitnesses))\n    elite = population[elite_idx].copy()\n    # Apply hill climbing to elite with 30% probability\n    if random.random() < 0.3:\n        elite = hill_climb_constants(elite, X_train, y_train, n_steps=5)\n    new_population.append(elite)\n    \n    # Adaptive tournament size: increase over generations (track via global variable)\n    # Use a simple heuristic: larger tournament later in evolution\n    # We'll approximate generation number from population diversity\n    avg_fit = np.mean(fitnesses)\n    if avg_fit > 1000:  # Early, high diversity\n        tournament_size = 3\n    else:\n        tournament_size = 5 + int(5 * (1.0 - min(avg_fit / 1000.0, 1.0)))\n    tournament_size = max(3, min(tournament_size, 10))\n    \n    while len(new_population) < pop_size:\n        r = random.random()\n        if r < crossover_rate:\n            parents = selection(population, penalized, 2, tournament_size)\n            child = crossover(parents[0], parents[1], n_features, max_depth, X_sample)\n        elif r < crossover_rate + mutation_rate:\n            parents = selection(population, penalized, 1, tournament_size)\n            child = mutation(parents[0], n_features, max_depth)\n        else:\n            parents = selection(population, penalized, 1, tournament_size)\n            child = parents[0]\n        \n        # Occasionally apply hill climbing to child\n        if random.random() < 0.1:\n            child = hill_climb_constants(child, X_train, y_train, n_steps=3)\n        \n        new_population.append(child)\n    \n    return new_population[:pop_size]"
7}

1{
2  "op": "replace",
3  "filename": "gplearn/custom_sr.py",
4  "start_line": 228,
5  "end_line": 505,
6  "content": "def fitness_function(tree, X, y):\n    \"\"\"Evaluate fitness of a candidate program. Lower is better.\"\"\"\n    y_pred = safe_evaluate(tree, X)\n    return float(np.mean((y - y_pred) ** 2))\n\n\ndef _per_case_errors(population, X, y):\n    \"\"\"Compute per-case absolute errors for the entire population.\n    \n    Returns:\n        numpy array of shape (len(population), n_samples)\n    \"\"\"\n    errors = np.empty((len(population), X.shape[0]))\n    for i, tree in enumerate(population):\n        y_pred = safe_evaluate(tree, X)\n        errors[i] = np.abs(y - y_pred)\n    return errors\n\n\ndef selection(population, fitnesses, n_select, _errors=None, _parsimony_coeff=0.0, _lengths=None):\n    \"\"\"Epsilon-lexicase selection with parsimony pressure.\n    \n    If _errors is not provided, fallback to tournament selection.\n    \"\"\"\n    selected = []\n    pop_size = len(population)\n    \n    if _errors is None:\n        # Fallback to tournament selection\n        tournament_size = 5\n        for _ in range(n_select):\n            candidates = random.sample(range(pop_size), min(tournament_size, pop_size))\n            best = min(candidates, key=lambda i: fitnesses[i])\n            selected.append(population[best].copy())\n        return selected\n    \n    n_cases = _errors.shape[1]\n    # Add parsimony penalty to errors\n    if _parsimony_coeff > 0 and _lengths is not None:\n        # Scale parsimony term to be comparable to error magnitudes\n        # Use median error as reference\n        median_err = np.median(_errors)\n        if median_err > 1e-12:\n            scale = _parsimony_coeff * median_err\n        else:\n            scale = _parsimony_coeff\n        penalized_errors = _errors + scale * np.array(_lengths)[:, None]\n    else:\n        penalized_errors = _errors\n    \n    for _ in range(n_select):\n        candidates = list(range(pop_size))\n        cases = list(range(n_cases))\n        random.shuffle(cases)\n        \n        for case in cases:\n            if len(candidates) <= 1:\n                break\n            case_errors = penalized_errors[candidates, case]\n            median_err = float(np.median(case_errors))\n            mad = float(np.median(np.abs(case_errors - median_err)))\n            epsilon = median_err + mad\n            candidates = [c for c, e in zip(candidates, case_errors) if e <= epsilon]\n        \n        winner = random.choice(candidates)\n        selected.append(population[winner].copy())\n    \n    return selected\n\n\ndef crossover(parent1, parent2, n_features, max_depth=17):\n    \"\"\"Standard subtree crossover.\"\"\"\n    offspring = parent1.copy()\n    donor = parent2.copy()\n    \n    off_size = offspring.size()\n    don_size = donor.size()\n    if off_size <= 1 or don_size <= 1:\n        return offspring\n    \n    off_point = random.randint(1, off_size - 1)\n    don_point = random.randint(0, don_size - 1)\n    \n    donor_nodes = donor.get_all_nodes()\n    donor_subtree = donor_nodes[don_point][0].copy()\n    \n    off_nodes = offspring.get_all_nodes()\n    node, parent, child_idx = off_nodes[off_point]\n    if parent is not None:\n        parent.children[child_idx] = donor_subtree\n    else:\n        offspring = donor_subtree\n    \n    if offspring.depth() > max_depth:\n        return parent1.copy()\n    \n    return offspring\n\n\ndef mutation(parent, n_features, max_depth=17):\n    \"\"\"Subtree mutation with occasional point mutation.\"\"\"\n    r = random.random()\n    if r < 0.7:\n        # Standard subtree mutation\n        offspring = parent.copy()\n        tree_size = offspring.size()\n        if tree_size <= 1:\n            return generate_tree('grow', 3, n_features)\n        \n        mut_point = random.randint(1, tree_size - 1)\n        new_subtree = generate_tree('grow', 3, n_features)\n        \n        nodes = offspring.get_all_nodes()\n        node, par, child_idx = nodes[mut_point]\n        if par is not None:\n            par.children[child_idx] = new_subtree\n        else:\n            offspring = new_subtree\n        \n        if offspring.depth() > max_depth:\n            return parent.copy()\n        \n        return offspring\n    else:\n        # Point mutation\n        offspring = parent.copy()\n        nodes = offspring.get_all_nodes()\n        if len(nodes) == 0:\n            return offspring\n        node, parent_node, child_idx = random.choice(nodes)\n        \n        if node.is_terminal:\n            if isinstance(node.value, str) and node.value.startswith('x'):\n                idx = random.randint(0, n_features - 1)\n                node.value = f'x{idx}'\n            else:\n                try:\n                    val = float(node.value)\n                    node.value = str(val + random.gauss(0, 0.5))\n                except:\n                    node.value = str(random.uniform(-5.0, 5.0))\n        else:\n            current_op = node.value\n            arity = OPERATORS[current_op][1]\n            candidates = [op for op in OPERATOR_NAMES if OPERATORS[op][1] == arity]\n            if len(candidates) > 1:\n                candidates.remove(current_op)\n                node.value = random.choice(candidates)\n        return offspring\n\n\ndef evolve_one_generation(population, fitnesses, X_train, y_train,\n                          n_features, pop_size,\n                          crossover_rate=0.9, mutation_rate=0.05,\n                          max_depth=17):\n    \"\"\"Lexicase-Parsimony GP generation.\n    \n    Combines epsilon-lexicase selection with adaptive parsimony pressure.\n    \"\"\"\n    new_population = []\n    \n    # Adaptive parsimony coefficient\n    lengths = np.array([tree.size() for tree in population], dtype=float)\n    raw_fit = np.array(fitnesses, dtype=float)\n    len_var = float(np.var(lengths))\n    if len_var > 1e-15:\n        parsimony_coeff = float(np.cov(lengths, raw_fit)[1, 0]) / len_var\n        parsimony_coeff = max(parsimony_coeff, 0.0)\n        parsimony_coeff = min(parsimony_coeff, 0.001)\n    else:\n        parsimony_coeff = 0.0\n    \n    # Pre-compute per-case errors for lexicase selection\n    errors = _per_case_errors(population, X_train, y_train)\n    \n    # Elitism: keep best individual by raw fitness\n    elite_idx = int(np.argmin(fitnesses))\n    new_population.append(population[elite_idx].copy())\n    \n    while len(new_population) < pop_size:\n        r = random.random()\n        if r < crossover_rate:\n            parents = selection(population, fitnesses, 2, _errors=errors,\n                                _parsimony_coeff=parsimony_coeff, _lengths=lengths)\n            child = crossover(parents[0], parents[1], n_features, max_depth)\n        elif r < crossover_rate + mutation_rate:\n            parents = selection(population, fitnesses, 1, _errors=errors,\n                                _parsimony_coeff=parsimony_coeff, _lengths=lengths)\n            child = mutation(parents[0], n_features, max_depth)\n        else:\n            parents = selection(population, fitnesses, 1, _errors=errors,\n                                _parsimony_coeff=parsimony_coeff, _lengths=lengths)\n            child = parents[0]\n        new_population.append(child)\n    \n    return new_population[:pop_size]"
7}

1{
2  "n": 1
3}