ループエンジニアリングとは何か - プロンプトより「ループ」を設計する

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.StructuredMessageCreateParams;
import com.google.common.base.Joiner;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class QuantGateLoop {
  private static final String MODEL = System.getenv().getOrDefault("LLM_MODEL", "claude-sonnet-5");
  private static final int MAX_ITER = 5; // 停止条件：ハードな反復上限
  private static final double MAX_DD = 0.20; // リスクゲート：最大ドローダウン 20% 以下
  private static final double MIN_SHARPE = 1.0; // リスクゲート：シャープレシオ 1.0 以上
  private static final double COST = 0.002; // 建玉が変わるたびの取引コスト（片道0.2%）
  private static final Path OUTPUT_MD = Path.of("output.md");

  private final StrategyGenerator llm;
  private final OutputLog output;

  QuantGateLoop(StrategyGenerator llm, OutputLog output) {
    this.llm = llm;
    this.output = output;
  }

  static final class OutputLog {
    private final StringBuilder markdown = new StringBuilder();

    void println(String line) {
      System.out.println(line);
      markdown.append(line).append(System.lineSeparator());
    }

    void printf(String format, Object... args) {
      String line = String.format(format, args);
      System.out.print(line);
      markdown.append(line);
    }

    void save() throws IOException {
      Files.writeString(OUTPUT_MD, markdown.toString(), StandardCharsets.UTF_8);
    }
  }

  public static final class Proposal {
    public int shortWindow;
    public int longWindow;

    public Proposal() {}

    public Proposal(int shortWindow, int longWindow) {
      this.shortWindow = shortWindow;
      this.longWindow = longWindow;
    }

    int shortWindow() {
      return shortWindow;
    }

    int longWindow() {
      return longWindow;
    }
  }

  record BacktestResult(double totalReturn, double maxDrawdown, double sharpe) {
    String metrics() {
      return String.format(
          "リターン%+.1f%% / 最大DD%.1f%% / シャープ%.2f", totalReturn * 100, maxDrawdown * 100, sharpe);
    }
  }

  record VerificationResult(boolean passed, String feedback, BacktestResult backtest) {
    static VerificationResult pass(BacktestResult backtest) {
      return new VerificationResult(true, "PASS（通過）", backtest);
    }

    static VerificationResult fail(String feedback, BacktestResult backtest) {
      return new VerificationResult(false, feedback, backtest);
    }

    static VerificationResult fail(String feedback) {
      return new VerificationResult(false, feedback, null);
    }
  }

  record SelftestCase(String label, Proposal proposal) {}

  interface StrategyGenerator {
    Proposal generate(String model, String system, String user);
  }

  static final class ClaudeStructuredOutputsGenerator implements StrategyGenerator {
    private final AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    @Override
    public Proposal generate(String model, String system, String user) {
      StructuredMessageCreateParams<Proposal> params =
          MessageCreateParams.builder()
              .model(model)
              .maxTokens(100L)
              .system(system)
              .addUserMessage(user)
              .outputConfig(Proposal.class)
              .build();

      return client.messages().create(params).content().stream()
          .flatMap(contentBlock -> contentBlock.text().stream())
          .map(textBlock -> textBlock.text())
          .findFirst()
          .orElseThrow(() -> new IllegalStateException("ClaudeからProposal形式の応答を取得できませんでした"));
    }
  }

  // 決定的な過去データ（seed固定の合成価格。誰が回しても同じ）
  static double[] prices() {
    int days = 252;
    int shockStart = 102;
    int shockDays = 23;
    int reboundDays = 20;

    double drift = 0.000118295;
    double noiseSd = 0.002600365;
    double shockDrag = -0.008605990;
    double reboundBoost = 0.008319029;

    double[] prices = new double[days];
    prices[0] = 100.0;

    Random random = new Random(42);
    for (int day = 1; day < prices.length; day++) {
      double dailyReturn = drift + noiseSd * random.nextGaussian();

      if (day >= shockStart && day < shockStart + shockDays) {
        dailyReturn += shockDrag;
      }
      if (day >= shockStart + shockDays && day < shockStart + shockDays + reboundDays) {
        dailyReturn += reboundBoost;
      }

      prices[day] = prices[day - 1] * (1.0 + dailyReturn);
    }
    return prices;
  }

  static double sma(double[] values, int end, int window) {
    double sum = 0.0;
    for (int i = end - window + 1; i <= end; i++) {
      sum += values[i];
    }
    return sum / window;
  }

  // バックテスト：移動平均クロス（短期>長期で買い・以外は待機）。リターン・最大DD・シャープを返す
  static BacktestResult backtest(Proposal proposal) {
    double[] prices = prices();
    int position = 0;
    List<Double> strategyReturns = new ArrayList<>();

    for (int t = proposal.longWindow(); t < prices.length; t++) {
      int previousPosition = position;
      position =
          sma(prices, t - 1, proposal.shortWindow()) > sma(prices, t - 1, proposal.longWindow())
              ? 1
              : 0;

      double tradeCost = Math.abs(position - previousPosition) * COST;
      double marketReturn = prices[t] / prices[t - 1] - 1.0;
      strategyReturns.add(previousPosition * marketReturn - tradeCost);
    }

    double equity = 1.0;
    double peak = 1.0;
    double maxDrawdown = 0.0;
    double sum = 0.0;

    for (double strategyReturn : strategyReturns) {
      equity *= 1.0 + strategyReturn;
      peak = Math.max(peak, equity);
      maxDrawdown = Math.max(maxDrawdown, (peak - equity) / peak);
      sum += strategyReturn;
    }

    double mean = sum / strategyReturns.size();
    double variance = 0.0;
    for (double strategyReturn : strategyReturns) {
      variance += Math.pow(strategyReturn - mean, 2);
    }
    variance /= strategyReturns.size();

    double standardDeviation = Math.sqrt(variance);
    double sharpe = standardDeviation == 0.0 ? 0.0 : mean / standardDeviation * Math.sqrt(252);
    return new BacktestResult(equity - 1.0, maxDrawdown, sharpe);
  }

  // 検証役＝リスクゲート：バックテストが基準を満たすか（決定的な合否）
  static VerificationResult verify(Proposal proposal) {
    int shortWindow = proposal.shortWindow();
    int longWindow = proposal.longWindow();

    if (!(shortWindow >= 2 && shortWindow < longWindow && longWindow <= 60)) {
      return VerificationResult.fail("日数が不正（2≤short<long≤60 で提案して）");
    }

    BacktestResult result = backtest(proposal);
    if (result.maxDrawdown() > MAX_DD) {
      return VerificationResult.fail(
          String.format(
              "最大ドローダウン %.1f%% が上限%.0f%%を超過（リスク過大）", result.maxDrawdown() * 100, MAX_DD * 100),
          result);
    }
    if (result.sharpe() < MIN_SHARPE) {
      return VerificationResult.fail(
          String.format("シャープレシオ %.2f が基準%.1f未満（リスクに対しリターンが薄い）", result.sharpe(), MIN_SHARPE),
          result);
    }
    return VerificationResult.pass(result);
  }

  // 生成役：Structured Outputs が基準＋過去の失敗（Reflexion）から戦略の日数を提案
  Proposal proposeWithLlm(List<String> failures) {
    String system =
        """
        あなたは移動平均クロス戦略の設計者です。
        短期と長期の移動平均日数を提案してください。
        短期と長期の日数は、Structured OutputsのProposalスキーマに従って返してください。
        条件: 2≤shortWindow<longWindow≤60
        """;

    String user =
        "最大ドローダウン"
            + (int) (MAX_DD * 100)
            + "%以下、シャープレシオ"
            + MIN_SHARPE
            + "以上を満たす移動平均の日数を提案して。"
            + (failures.isEmpty() ? "" : "\n【これまでのボツ（繰り返すな）】\n" + Joiner.on('\n').join(failures));

    return llm.generate(MODEL, system, user);
  }

  // ── ループ本体：提案→バックテストのゲート→（落ちたら記憶して）再提案。停止は「通過 or 反復上限」──
  void run() {
    List<String> failures = new ArrayList<>();

    for (int turn = 1; turn <= MAX_ITER; turn++) {
      Proposal proposal = proposeWithLlm(failures);
      VerificationResult verification = verify(proposal);

      if (verification.passed()) {
        output.printf(
            "turn %d: PASS — short=%d, long=%d ／ %s%n",
            turn, proposal.shortWindow(), proposal.longWindow(), verification.backtest().metrics());
        output.println("\n停止理由：ゲート通過（リスク基準クリア）/ 成功ターン=" + turn);
        return;
      }

      output.printf(
          "turn %d: NG — short=%d, long=%d → %s%n",
          turn, proposal.shortWindow(), proposal.longWindow(), verification.feedback());
      failures.add(
          "short="
              + proposal.shortWindow()
              + ",long="
              + proposal.longWindow()
              + " は "
              + verification.feedback());
    }

    output.println("\n停止理由：反復上限（基準を満たす戦略が見つからず安全に停止）");
  }

  public static void main(String[] args) throws IOException {
    OutputLog output = new OutputLog();
    output.println(
        "お題：戦略の移動平均日数を提案 / 生成役=LLM(" + MODEL + ") / 検証役=バックテストのゲート / 上限" + MAX_ITER + "回\n");
    new QuantGateLoop(new ClaudeStructuredOutputsGenerator(), output).run();
    output.save();
  }
}