Differentiable Cost-Aware Path Scoring

The problem

Deciding the best path forward is difficult when you have to weigh multiple different costs and outcomes at the same time. It is hard to calculate the most efficient route when every choice has a different price tag.

What it does

It evaluates multiple possible future paths at once by looking at their total costs simultaneously. It ranks these paths based on how efficiently they reach a goal.

Why it matters

It allows for faster and more accurate decision-making by weighing multiple options at the same time.

Validation

It was run in the sandbox and it failed. run output shows an error/traceback — the artifact does NOT run clean.

$ python3 path_scorer.py
File "/work/path_scorer.py", line 67
    print(f"Initial path: {initial_path")
                                       ^
SyntaxError: f-string: expecting '}'

No screenshot — there is nothing working to show. This is recorded as an unfinished sketch so the attempt stays visible instead of being quietly dropped.

The code

All of it — 70 lines, one file, standard library only.

import math
import random

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Path:
    def __init__(self, points):
        self.points = points

    def cost(self):
        total = 0.0
        goal = Point(10, 10)
        for i in range(len(self.points) - 1):
            dx = self.points[i].x - self.points[i+1].x
            dy = self.points[i].y - self.points[i+1].y
            total += math.sqrt(dx*dx + dy*dy)
        # Add distance to goal
        dx = self.points[-1].x - goal.x
        dy = self.points[-1].y - goal.y
        total += math.sqrt(dx*dx + dy*dy)
        return total

    def __str__(self):
        return " -> ".join(f"({p.x:.4f},{p.y:.4f})" for p in self.points)

def generate_random_path(start, num_points=5):
    path = [start]
    current = start
    for _ in range(num_points-1):
        step_x = random.uniform(-1, 1)
        step_y = random.uniform(-1, 1)
        next_point = Point(current.x + step_x, current.y + step_y)
        path.append(next_point)
        current = next_point
    return Path(path)

def gradient(path, epsilon=1e-5):
    gradients = []
    for i in range(len(path.points)):
        for coord in ['x', 'y']:
            original = getattr(path.points[i], coord)
            setattr(path.points[i], coord, original + epsilon)
            cost_plus = Path(path.points).cost()
            setattr(path.points[i], coord, original - epsilon)
            cost_minus = Path(path.points).cost()
            setattr(path.points[i], coord, original)
            gradient = (cost_plus - cost_minus) / (2 * epsilon)
            gradients.append(gradient)
    return gradients

def optimize_path(initial_path, iterations=100, learning_rate=0.1):
    path = initial_path
    for i in range(iterations):
        current_cost = path.cost()
        grads = gradient(path)
        for j in range(len(path.points)):
            path.points[j].x -= learning_rate * grads[j*2]
            path.points[j].y -= learning_rate * grads[j*2 +1]
    return path

if __name__ == "__main__":
    start_point = Point(0, 0)
    initial_path = generate_random_path(start_point)
    print(f"Initial path: {initial_path")
    optimized_path = optimize_path(initial_path)
    print(f"Optimized path: {optimized_path")
    print(f"Final cost: {optimized_path.cost():.4f")