{"id":4780,"date":"2024-08-20T14:55:21","date_gmt":"2024-08-20T18:55:21","guid":{"rendered":"https:\/\/www.econai.tech\/?page_id=4780"},"modified":"2024-09-03T07:17:29","modified_gmt":"2024-09-03T11:17:29","slug":"scalable-oversight-of-ai-systems","status":"publish","type":"page","link":"https:\/\/tomomitanaka.ai\/?page_id=4780","title":{"rendered":"Scalable Oversight of AI Systems"},"content":{"rendered":"\n

As artificial intelligence systems become increasingly sophisticated and capable, a critical challenge emerges: how do we maintain effective oversight and ensure these systems remain aligned with human values and intentions?<\/p>\n\n\n\n

This challenge, known as the alignment problem, is at the heart of AI safety research.<\/p>\n\n\n\n

The alignment problem refers to the challenge of creating AI systems that reliably pursue objectives aligned with human values. <\/p>\n\n\n\n

As AI capabilities grow, ensuring this alignment becomes more complex and crucial. <\/p>\n\n\n\n

Scalable oversight techniques aim to address this challenge by providing methods to monitor and guide AI systems as they tackle increasingly complex tasks.<\/p>\n\n\n\n

In this blog post, we’ll explore four key approaches to scalable oversight:<\/p>\n\n\n\n

    \n
  1. Recursive Reward Modeling<\/li>\n\n\n\n
  2. Debate and Amplification Techniques<\/li>\n\n\n\n
  3. Factored Cognition Approaches<\/li>\n\n\n\n
  4. Scalable Human-AI Interaction Protocols<\/li>\n<\/ol>\n\n\n\n

    Each of these techniques offers unique insights into how we might maintain control and alignment as AI systems become more powerful. <\/p>\n\n\n\n

    1. Recursive Reward Modeling<\/h3>\n\n\n\n

    Understanding Recursive Reward Modeling<\/h4>\n\n\n\n

    Reward modeling is a fundamental concept in AI alignment, where we attempt to create a reward function that accurately represents human preferences.<\/p>\n\n\n\n

    However, as tasks become more complex, directly specifying such reward functions becomes challenging.<\/p>\n\n\n\n

    Recursive Reward Modeling (RRM) addresses this challenge by breaking down complex tasks into simpler subtasks and training subordinate models to handle these subtasks. The process is applied recursively, allowing for the modeling of increasingly complex reward structures.<\/p>\n\n\n\n

    Key Components of Recursive Reward Modeling<\/div>\n
      \n
    1. Task Decomposition<\/strong>: Complex tasks are broken down into simpler, manageable subtasks.<\/li>\n\n\n\n
    2. Subordinate Model Training<\/strong>: AI models are trained to handle specific subtasks.<\/li>\n\n\n\n
    3. Recursive Application<\/strong>: The reward modeling process is applied recursively to handle increasingly complex tasks.<\/li>\n<\/ol>\n<\/div>\n\n\n\n

      Practical Considerations<\/h4>\n\n\n\n

      Implementing RRM requires careful task decomposition and model training. One challenge is ensuring that the decomposition accurately reflects the overall task. Another is managing the potential compounding of errors as we move up the recursive hierarchy.<\/p>\n\n\n\n

      Example Scenario: Content Moderation System<\/h4>\n\n\n\n

      Let’s consider how we might apply RRM to create a scalable content moderation system.<\/p>\n\n\n\n

      Python<\/span><\/path><\/path><\/svg><\/span>
      import<\/span> numpy <\/span>as<\/span> np<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>ContentModerator<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.subordinate_models = {}<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>train_subordinate<\/span>(<\/span>self<\/span>, <\/span>task<\/span>, <\/span>training_data<\/span>):<\/span><\/span>\n        <\/span># Simplified training process<\/span><\/span>\n        <\/span>self<\/span>.subordinate_models[task] = np.mean(training_data)<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>moderate_content<\/span>(<\/span>self<\/span>, <\/span>content<\/span>):<\/span><\/span>\n        <\/span># Decompose content moderation into subtasks<\/span><\/span>\n        subtasks = [<\/span>'profanity'<\/span>, <\/span>'hate_speech'<\/span>, <\/span>'explicit_content'<\/span>]<\/span>\n        scores = []<\/span>\n<\/span>\n        <\/span>for<\/span> subtask <\/span>in<\/span> subtasks:<\/span><\/span>\n            <\/span>if<\/span> subtask <\/span>in<\/span> <\/span>self<\/span>.subordinate_models:<\/span><\/span>\n                <\/span># Use trained subordinate model<\/span><\/span>\n                score = <\/span>self<\/span>.subordinate_models[subtask]<\/span>\n            <\/span>else<\/span>:<\/span><\/span>\n                <\/span># Recursive call for more complex subtasks<\/span><\/span>\n                sub_moderator = ContentModerator()<\/span><\/span>\n                sub_moderator.train_subordinate(subtask, np.random.rand(<\/span>100<\/span>))<\/span><\/span>\n                score = sub_moderator.moderate_content(content)<\/span><\/span>\n            scores.append(score)<\/span><\/span>\n<\/span>\n        <\/span># Combine scores (simplified)<\/span><\/span>\n        <\/span>return<\/span> np.mean(scores)<\/span><\/span>\n<\/span>\n# Usage<\/span><\/span>\nmoderator = ContentModerator()<\/span><\/span>\nmoderator.train_subordinate(<\/span>'profanity'<\/span>, np.random.rand(<\/span>100<\/span>))<\/span><\/span>\ncontent_score = moderator.moderate_content(<\/span>"Sample content"<\/span>)<\/span><\/span>\nprint<\/span>(<\/span>f<\/span>"Content moderation score: <\/span>{<\/span>content_score<\/span>}<\/span>"<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
      <\/p>\n\n\n\n
      This simplified example demonstrates how RRM can be applied to content moderation. The system decomposes the task into subtasks, uses trained models where available, and recursively creates new models for more complex subtasks.<\/p>\n\n\n\n
      2. Debate and Amplification Techniques<\/h3>\n\n\n\n
      Introduction to AI Safety via Debate<\/h4>\n\n\n\n
      Debate techniques aim to improve AI alignment by having AI systems argue different viewpoints, with a human judge determining the winner. This approach leverages the idea that flaws in reasoning or alignment are more likely to be exposed through adversarial debate.<\/p>\n\n\n\n
      Amplification in this context refers to iteratively improving the capabilities of AI systems or the effectiveness of human oversight through repeated rounds of debate or refinement.<\/p>\n\n\n\n
      Key Debate and Amplification Approaches<\/div>\n
        \n
      1. Recursive Debate<\/strong>: AI systems engage in multiple rounds of debate, with each round building on previous arguments.<\/li>\n\n\n\n
      2. Iterative Amplification<\/strong>: The capabilities of AI systems or human judges are iteratively improved based on debate outcomes.<\/li>\n\n\n\n
      3. Cross-Examination Debate<\/strong>: AI systems not only present arguments but also cross-examine each other’s positions.<\/li>\n<\/ol>\n<\/div>\n\n\n\n
        Practical Considerations<\/h4>\n\n\n\n
        Implementing debate systems requires careful design of the debate protocol, selection of appropriate topics, and mechanisms for evaluating arguments. A key challenge is ensuring that the debate process genuinely improves alignment rather than simply rewarding persuasive but potentially misaligned arguments.<\/p>\n\n\n\n
        Example Scenario: Fact-Checking System<\/h4>\n\n\n\n
        Here’s a simplified implementation of a debate-based fact-checking system:<\/p>\n\n\n\n
        Python<\/span><\/path><\/path><\/svg><\/span>
        import<\/span> random<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>DebateAgent<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>, <\/span>name<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.name = name<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>generate_argument<\/span>(<\/span>self<\/span>, <\/span>topic<\/span>):<\/span><\/span>\n        <\/span># Simplified argument generation<\/span><\/span>\n        <\/span>return<\/span> <\/span>f<\/span>"<\/span>{self<\/span>.name<\/span>}<\/span> argues: <\/span>{<\/span>random.choice([<\/span>'True'<\/span>, <\/span>'False'<\/span>])<\/span>}<\/span>"<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>cross_examine<\/span>(<\/span>self<\/span>, <\/span>argument<\/span>):<\/span><\/span>\n        <\/span># Simplified cross-examination<\/span><\/span>\n        <\/span>return<\/span> <\/span>f<\/span>"<\/span>{self<\/span>.name<\/span>}<\/span> questions: Is that really true?"<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>debate_round<\/span>(<\/span>topic<\/span>, <\/span>agent1<\/span>, <\/span>agent2<\/span>):<\/span><\/span>\n    arg1 = agent1.generate_argument(topic)<\/span><\/span>\n    arg2 = agent2.generate_argument(topic)<\/span><\/span>\n    cross1 = agent1.cross_examine(arg2)<\/span><\/span>\n    cross2 = agent2.cross_examine(arg1)<\/span><\/span>\n    <\/span>return<\/span> [arg1, arg2, cross1, cross2]<\/span>\n<\/span>\ndef<\/span> <\/span>human_judge<\/span>(<\/span>debate_transcript<\/span>):<\/span><\/span>\n    <\/span># Simplified judging process<\/span><\/span>\n    <\/span>return<\/span> random.choice([<\/span>"Agent 1 wins"<\/span>, <\/span>"Agent 2 wins"<\/span>])<\/span><\/span>\n<\/span>\n# Usage<\/span><\/span>\nagent1 = DebateAgent(<\/span>"Agent 1"<\/span>)<\/span><\/span>\nagent2 = DebateAgent(<\/span>"Agent 2"<\/span>)<\/span><\/span>\ntopic = <\/span>"Is the Earth flat?"<\/span><\/span>\n<\/span>\ndebate_transcript = debate_round(topic, agent1, agent2)<\/span><\/span>\nfor<\/span> argument <\/span>in<\/span> debate_transcript:<\/span><\/span>\n    <\/span>print<\/span>(argument)<\/span><\/span>\n<\/span>\nresult = human_judge(debate_transcript)<\/span><\/span>\nprint<\/span>(<\/span>f<\/span>"Judgement: <\/span>{<\/span>result<\/span>}<\/span>"<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
        <\/p>\n\n\n\n
        This example demonstrates a basic debate structure for fact-checking. In a more sophisticated system, the agents would use actual knowledge bases and reasoning capabilities, and the human judgement would be based on the quality and factual accuracy of the arguments.<\/p>\n\n\n\n
        3. Factored Cognition Approaches<\/h3>\n\n\n\n
        Understanding Factored Cognition<\/h4>\n\n\n\n
        Factored Cognition involves breaking down complex cognitive tasks into smaller, more manageable pieces that can be solved independently and then recombined. This approach contrasts with monolithic AI systems that attempt to solve complex problems in one go.<\/p>\n\n\n\n
        Key Factored Cognition Techniques<\/div>\n
          \n
        1. Task Decomposition<\/strong>: Breaking complex problems into simpler subproblems.<\/li>\n\n\n\n
        2. Information Flow Management<\/strong>: Coordinating how information is shared between subtasks.<\/li>\n\n\n\n
        3. Human-AI Collaboration<\/strong>: Integrating human oversight and input at various stages of the factored process.<\/li>\n<\/ol>\n<\/div>\n\n\n\n
          Practical Considerations<\/h4>\n\n\n\n
          Implementing Factored Cognition systems requires careful task analysis and decomposition. A key challenge is managing the information flow between subtasks without losing important context or introducing errors.<\/p>\n\n\n\n
          Example Scenario: Complex Decision-Making System<\/h4>\n\n\n\n
          Here’s a simplified implementation of a Factored Cognition approach for a multi-faceted decision problem:<\/p>\n\n\n\n
          Python<\/span><\/path><\/path><\/svg><\/span>
          class<\/span> <\/span>CognitiveSubtask<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>, <\/span>name<\/span>, <\/span>process_func<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.name = name<\/span><\/span>\n        <\/span>self<\/span>.process = process_func<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>execute<\/span>(<\/span>self<\/span>, <\/span>input_data<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>self<\/span>.process(input_data)<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>data_analysis<\/span>(<\/span>data<\/span>):<\/span><\/span>\n    <\/span># Simplified data analysis<\/span><\/span>\n    <\/span>return<\/span> {<\/span>"analysis_result"<\/span>: <\/span>sum<\/span>(data) \/ <\/span>len<\/span>(data)}<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>risk_assessment<\/span>(<\/span>analysis_result<\/span>):<\/span><\/span>\n    <\/span># Simplified risk assessment<\/span><\/span>\n    <\/span>return<\/span> {<\/span>"risk_level"<\/span>: <\/span>"high"<\/span> <\/span>if<\/span> analysis_result > <\/span>0.5<\/span> <\/span>else<\/span> <\/span>"low"<\/span>}<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>decision_making<\/span>(<\/span>risk_level<\/span>):<\/span><\/span>\n    <\/span># Simplified decision making<\/span><\/span>\n    <\/span>return<\/span> <\/span>"Proceed"<\/span> <\/span>if<\/span> risk_level == <\/span>"low"<\/span> <\/span>else<\/span> <\/span>"Halt"<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>human_oversight<\/span>(<\/span>decision<\/span>):<\/span><\/span>\n    <\/span># Simplified human oversight<\/span><\/span>\n    <\/span>return<\/span> <\/span>"Approved: "<\/span> + decision<\/span><\/span>\n<\/span>\n# Define subtasks<\/span><\/span>\nsubtask1 = CognitiveSubtask(<\/span>"Data Analysis"<\/span>, data_analysis)<\/span><\/span>\nsubtask2 = CognitiveSubtask(<\/span>"Risk Assessment"<\/span>, risk_assessment)<\/span><\/span>\nsubtask3 = CognitiveSubtask(<\/span>"Decision Making"<\/span>, decision_making)<\/span><\/span>\nsubtask4 = CognitiveSubtask(<\/span>"Human Oversight"<\/span>, human_oversight)<\/span><\/span>\n<\/span>\n# Execute factored cognition process<\/span><\/span>\ninput_data = [<\/span>0.2<\/span>, <\/span>0.4<\/span>, <\/span>0.6<\/span>, <\/span>0.8<\/span>]<\/span>\nresult1 = subtask1.execute(input_data)<\/span><\/span>\nresult2 = subtask2.execute(result1[<\/span>"analysis_result"<\/span>])<\/span><\/span>\nresult3 = subtask3.execute(result2[<\/span>"risk_level"<\/span>])<\/span><\/span>\nfinal_result = subtask4.execute(result3)<\/span><\/span>\n<\/span>\nprint<\/span>(<\/span>f<\/span>"Final decision: <\/span>{<\/span>final_result<\/span>}<\/span>"<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
          <\/p>\n\n\n\n
          This example demonstrates how a complex decision-making process can be broken down into smaller, manageable subtasks. Each subtask can be executed independently, with results flowing from one to the next. The inclusion of a human oversight step allows for final approval of the AI-generated decision.<\/p>\n\n\n\n
          4. Scalable Human-AI Interaction Protocols<\/h3>\n\n\n\n
          Importance of Human-AI Interaction in Oversight<\/h4>\n\n\n\n
          As AI systems become more complex, maintaining effective human oversight becomes challenging. Scalable interaction protocols aim to facilitate efficient and meaningful human-AI interaction, balancing the need for human control with the benefits of AI autonomy.<\/p>\n\n\n\n
          Key Scalable Interaction Techniques<\/div>\n
            \n
          1. Hierarchical Oversight<\/strong>: Organizing oversight in a hierarchical structure, with different levels of human involvement for different types of decisions or situations.<\/li>\n\n\n\n
          2. Attention-Based Alerting<\/strong>: Developing systems that alert human overseers only when certain thresholds of uncertainty or risk are met.<\/li>\n\n\n\n
          3. Adaptive Interaction Frequency<\/strong>: Adjusting the frequency of human-AI interactions based on the AI system’s performance and the criticality of the task.<\/li>\n<\/ol>\n<\/div>\n\n\n\n
            Practical Considerations<\/h4>\n\n\n\n
            Designing effective interaction protocols requires careful consideration of human cognitive limitations, the nature of the tasks being overseen, and the capabilities of the AI system. A key challenge is striking the right balance between autonomy and oversight.<\/p>\n\n\n\n
            Example Scenario: Autonomous Trading System Oversight<\/h4>\n\n\n\n
            Here’s a simplified implementation of a scalable oversight protocol for an AI-driven trading system:<\/p>\n\n\n\n
            Python<\/span><\/path><\/path><\/svg><\/span>
            import<\/span> random<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>TradingAI<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.confidence = random.uniform(<\/span>0.5<\/span>, <\/span>1.0<\/span>)<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>make_trade<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> {<\/span>"action"<\/span>: random.choice([<\/span>"buy"<\/span>, <\/span>"sell"<\/span>]), <\/span>"amount"<\/span>: random.randint(<\/span>1000<\/span>, <\/span>10000<\/span>)}<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>HumanOverseer<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>review_trade<\/span>(<\/span>self<\/span>, <\/span>trade<\/span>):<\/span><\/span>\n        <\/span>return<\/span> random.choice([<\/span>"approve"<\/span>, <\/span>"reject"<\/span>])<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>OversightProtocol<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>, <\/span>confidence_threshold<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.ai = TradingAI()<\/span><\/span>\n        <\/span>self<\/span>.human = HumanOverseer()<\/span><\/span>\n        <\/span>self<\/span>.confidence_threshold = confidence_threshold<\/span><\/span>\n        <\/span>self<\/span>.total_trades = <\/span>0<\/span><\/span>\n        <\/span>self<\/span>.human_reviewed_trades = <\/span>0<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>execute_trade<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.total_trades += <\/span>1<\/span><\/span>\n        trade = <\/span>self<\/span>.ai.make_trade()<\/span><\/span>\n        <\/span><\/span>\n        <\/span>if<\/span> <\/span>self<\/span>.ai.confidence < <\/span>self<\/span>.confidence_threshold:<\/span><\/span>\n            <\/span>self<\/span>.human_reviewed_trades += <\/span>1<\/span><\/span>\n            human_decision = <\/span>self<\/span>.human.review_trade(trade)<\/span><\/span>\n            <\/span>if<\/span> human_decision == <\/span>"approve"<\/span>:<\/span><\/span>\n                <\/span>print<\/span>(<\/span>f<\/span>"Trade executed after human approval: <\/span>{<\/span>trade<\/span>}<\/span>"<\/span>)<\/span><\/span>\n            <\/span>else<\/span>:<\/span><\/span>\n                <\/span>print<\/span>(<\/span>"Trade rejected by human overseer"<\/span>)<\/span><\/span>\n        <\/span>else<\/span>:<\/span><\/span>\n            <\/span>print<\/span>(<\/span>f<\/span>"Trade executed autonomously: <\/span>{<\/span>trade<\/span>}<\/span>"<\/span>)<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>get_oversight_stats<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>f<\/span>"Total trades: <\/span>{self<\/span>.total_trades<\/span>}<\/span>, Human-reviewed trades: <\/span>{self<\/span>.human_reviewed_trades<\/span>}<\/span>"<\/span><\/span>\n<\/span>\n# Usage<\/span><\/span>\nprotocol = OversightProtocol(<\/span>confidence_threshold<\/span>=<\/span>0.8<\/span>)<\/span><\/span>\n<\/span>\nfor<\/span> _ <\/span>in<\/span> <\/span>range<\/span>(<\/span>10<\/span>):<\/span><\/span>\n    protocol.execute_trade()<\/span><\/span>\n<\/span>\nprint<\/span>(protocol.get_oversight_stats())<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
            <\/p>\n\n\n\n
            This example demonstrates a simple oversight protocol where human intervention is triggered based on the AI’s confidence level. This approach allows for scalable oversight by focusing human attention on higher-risk or lower-confidence decisions.<\/p>\n\n\n\n
            Conclusion<\/h2>\n\n\n\n
            As AI systems continue to grow in capability and complexity, ensuring their alignment with human values and intentions becomes increasingly critical. <\/p>\n\n\n\n
            The scalable oversight techniques we’ve explored \u2013 Recursive Reward Modeling, Debate and Amplification, Factored Cognition, and Scalable Human-AI Interaction Protocols \u2013 offer promising approaches to this challenge.<\/p>\n\n\n\n
            Each technique has its strengths and limitations:<\/p>\n\n\n\n
            \u2713<\/strong> Recursive Reward Modeling excels in breaking down complex tasks but may struggle with error propagation.<\/p>\n\n\n\n
            \u2713<\/strong> Debate and Amplification techniques can surface flaws in reasoning but require careful design to avoid rewarding mere persuasiveness.<\/p>\n\n\n\n
            \u2713<\/strong> Factored Cognition approaches offer flexibility and interpretability but may face challenges in information integration.<\/p>\n\n\n\n
            \u2713<\/strong> Scalable Human-AI Interaction Protocols can efficiently allocate human oversight but must carefully balance autonomy and control.<\/p>\n\n\n\n
            Future research in scalable oversight will likely focus on combining these approaches, developing more sophisticated implementations, and testing them in increasingly complex and realistic scenarios. <\/p>\n\n\n\n
            <\/p>\n\n\n\n
            <\/p>\n","protected":false},"excerpt":{"rendered":"
            As artificial intelligence systems become increasingly sophisticated and capable, a critical challenge emerges: how do we maintain effective oversight and ensure these systems remain aligned with human values and intentions? This challenge, known as the alignment problem, is at the heart of AI safety research. The alignment problem refers to the challenge of creating AI<\/p>\n","protected":false},"author":1,"featured_media":5437,"parent":140,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-4780","page","type-page","status-publish","has-post-thumbnail","hentry"],"_links":{"self":[{"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=\/wp\/v2\/pages\/4780","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=4780"}],"version-history":[{"count":27,"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=\/wp\/v2\/pages\/4780\/revisions"}],"predecessor-version":[{"id":6289,"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=\/wp\/v2\/pages\/4780\/revisions\/6289"}],"up":[{"embeddable":true,"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=\/wp\/v2\/pages\/140"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=\/wp\/v2\/media\/5437"}],"wp:attachment":[{"href":"https:\/\/tomomitanaka.ai\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4780"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}