!apt-get replace -y
!apt-get set up -y curl
!curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
!apt-get set up -y nodejs
!node -v
!npm -v
!npm set up -g openclaw@newest
!pip -q set up requests pandas pydantic


import os
import json
import time
import uuid
import secrets and techniques
import subprocess
import getpass
from pathlib import Path
from typing import Dict, Any
from dataclasses import dataclass, asdict
from datetime import datetime, timezone


import requests
import pandas as pd
from pydantic import BaseModel, Subject


strive:
   from google.colab import userdata
   OPENAI_API_KEY = userdata.get("OPENAI_API_KEY")
besides Exception:
   OPENAI_API_KEY = None


if not OPENAI_API_KEY:
   OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")


if not OPENAI_API_KEY:
   OPENAI_API_KEY = getpass.getpass("Enter your OpenAI API key (hidden enter): ").strip()


assert OPENAI_API_KEY != "", "API key can't be empty."


OPENCLAW_HOME = Path("/root/.openclaw")
OPENCLAW_HOME.mkdir(mother and father=True, exist_ok=True)
WORKSPACE = OPENCLAW_HOME / "workspace"
WORKSPACE.mkdir(mother and father=True, exist_ok=True)


GATEWAY_TOKEN = secrets and techniques.token_urlsafe(48)
GATEWAY_PORT = 18789
GATEWAY_URL = f"http://127.0.0.1:{GATEWAY_PORT}"

config = {
   "env": {
       "OPENAI_API_KEY": OPENAI_API_KEY
   },
   "brokers": {
       "defaults": {
           "workspace": str(WORKSPACE),
           "mannequin": {
               "major": "openai/gpt-4.1-mini"
           }
       }
   },
   "gateway": {
       "mode": "native",
       "port": GATEWAY_PORT,
       "bind": "loopback",
       "auth": {
           "mode": "token",
           "token": GATEWAY_TOKEN
       },
       "http": {
           "endpoints": {
               "chatCompletions": {
                   "enabled": True
               }
           }
       }
   }
}


config_path = OPENCLAW_HOME / "openclaw.json"
config_path.write_text(json.dumps(config, indent=2))


physician = subprocess.run(
   ("bash", "-lc", "openclaw physician --fix --yes"),
   capture_output=True,
   textual content=True
)
print(physician.stdout(-2000:))
print(physician.stderr(-2000:))


gateway_log = "/tmp/openclaw_gateway.log"
gateway_cmd = f"OPENAI_API_KEY='{OPENAI_API_KEY}' OPENCLAW_GATEWAY_TOKEN='{GATEWAY_TOKEN}' openclaw gateway --port {GATEWAY_PORT} --bind loopback --token '{GATEWAY_TOKEN}' --verbose > {gateway_log} 2>&1 & echo $!"
gateway_pid = subprocess.check_output(("bash", "-lc", gateway_cmd)).decode().strip()
print("Gateway PID:", gateway_pid)

def wait_for_gateway(timeout=120):
   begin = time.time()
   whereas time.time() - begin < timeout:
       strive:
           r = requests.get(f"{GATEWAY_URL}/", timeout=5)
           if r.status_code in (200, 401, 403, 404):
               return True
       besides Exception:
           move
       time.sleep(2)
   return False


assert wait_for_gateway(), Path(gateway_log).read_text()(-6000:)


headers = {
   "Authorization": f"Bearer {GATEWAY_TOKEN}",
   "Content material-Kind": "software/json"
}


def openclaw_chat(messages, consumer="demo-user", agent_id="major", temperature=0.2):
   payload = {
       "mannequin": f"openclaw:{agent_id}",
       "messages": messages,
       "consumer": consumer,
       "temperature": temperature,
       "stream": False
   }
   r = requests.submit(
       f"{GATEWAY_URL}/v1/chat/completions",
       headers=headers,
       json=payload,
       timeout=180
   )
   r.raise_for_status()
   return r.json()


class ActionProposal(BaseModel):
   user_request: str
   class: str
   danger: str
   confidence: float = Subject(ge=0.0, le=1.0)
   requires_approval: bool
   permit: bool
   cause: str

def classify_request(user_request: str) -> ActionProposal:
   textual content = user_request.decrease()


   red_terms = (
       "delete", "take away completely", "wire cash", "switch funds",
       "payroll", "financial institution", "hr report", "worker report", "run shell",
       "execute command", "api key", "secret", "credential", "token",
       "ssh", "sudo", "wipe", "exfiltrate", "add personal", "database dump"
   )
   amber_terms = (
       "electronic mail", "ship", "notify", "buyer", "vendor", "contract",
       "bill", "price range", "approve", "safety coverage", "confidential",
       "write file", "modify", "change"
   )


   if any(t in textual content for t in red_terms):
       return ActionProposal(
           user_request=user_request,
           class="high_impact",
           danger="purple",
           confidence=0.92,
           requires_approval=True,
           permit=False,
           cause="Excessive-impact or delicate motion detected"
       )


   if any(t in textual content for t in amber_terms):
       return ActionProposal(
           user_request=user_request,
           class="moderate_impact",
           danger="amber",
           confidence=0.76,
           requires_approval=True,
           permit=True,
           cause="Reasonable-risk motion requires human approval earlier than execution"
       )


   return ActionProposal(
       user_request=user_request,
       class="low_impact",
       danger="inexperienced",
       confidence=0.88,
       requires_approval=False,
       permit=True,
       cause="Low-risk request"
   )


def simulated_human_approval(proposal: ActionProposal) -> Dict(str, Any):
   if proposal.danger == "purple":
       authorized = False
       word = "Rejected mechanically in demo for red-risk request"
   elif proposal.danger == "amber":
       authorized = True
       word = "Authorized mechanically in demo for amber-risk request"
   else:
       authorized = True
       word = "No approval required"
   return {
       "authorized": authorized,
       "reviewer": "simulated_manager",
       "word": word
   }


@dataclass
class TraceEvent:
   trace_id: str
   ts: str
   stage: str
   payload: Dict(str, Any)

class TraceStore:
   def __init__(self, path="openclaw_traces.jsonl"):
       self.path = path
       Path(self.path).write_text("")


   def append(self, occasion: TraceEvent):
       with open(self.path, "a") as f:
           f.write(json.dumps(asdict(occasion)) + "n")


   def read_all(self):
       rows = ()
       with open(self.path, "r") as f:
           for line in f:
               line = line.strip()
               if line:
                   rows.append(json.hundreds(line))
       return rows


trace_store = TraceStore()


def now():
   return datetime.now(timezone.utc).isoformat()


SYSTEM_PROMPT = """
You're an enterprise OpenClaw assistant working underneath governance controls.


Guidelines:
- By no means declare an motion has been executed until the governance layer explicitly permits it.
- For low-risk requests, reply usually and helpfully.
- For moderate-risk requests, suggest a protected plan and point out any approvals or checks that will be wanted.
- For top-risk requests, refuse to execute and as an alternative present a safer non-operational various corresponding to a draft, guidelines, abstract, or evaluate plan.
- Be concise however helpful.
"""


def governed_openclaw_run(user_request: str, session_user: str = "employee-001") -> Dict(str, Any):
   trace_id = str(uuid.uuid4())


   proposal = classify_request(user_request)
   trace_store.append(TraceEvent(trace_id, now(), "classification", proposal.model_dump()))


   approval = None
   if proposal.requires_approval:
       approval = simulated_human_approval(proposal)
       trace_store.append(TraceEvent(trace_id, now(), "approval", approval))


   if proposal.danger == "purple":
       consequence = {
           "trace_id": trace_id,
           "standing": "blocked",
           "proposal": proposal.model_dump(),
           "approval": approval,
           "response": "This request is blocked by governance coverage. I will help by drafting a protected plan, a guidelines, or an approval packet as an alternative."
       }
       trace_store.append(TraceEvent(trace_id, now(), "blocked", consequence))
       return consequence


   if proposal.danger == "amber" and never approval("authorized"):
       consequence = {
           "trace_id": trace_id,
           "standing": "awaiting_or_rejected",
           "proposal": proposal.model_dump(),
           "approval": approval,
           "response": "This request requires approval and was not cleared."
       }
       trace_store.append(TraceEvent(trace_id, now(), "halted", consequence))
       return consequence


   messages = (
       {"position": "system", "content material": SYSTEM_PROMPT},
       {"position": "consumer", "content material": f"Governance classification: {proposal.model_dump_json()}nnUser request: {user_request}"}
   )


   uncooked = openclaw_chat(messages=messages, consumer=session_user, agent_id="major", temperature=0.2)
   assistant_text = uncooked("selections")(0)("message")("content material")


   consequence = {
       "trace_id": trace_id,
       "standing": "executed_via_openclaw",
       "proposal": proposal.model_dump(),
       "approval": approval,
       "response": assistant_text,
       "openclaw_raw": uncooked
   }
   trace_store.append(TraceEvent(trace_id, now(), "executed", {
       "standing": consequence("standing"),
       "response_preview": assistant_text(:500)
   }))
   return consequence


demo_requests = (
   "Summarize our AI governance coverage for inner use.",
   "Draft an electronic mail to finance asking for affirmation of the Q1 cloud price range.",
   "Ship an electronic mail to all workers that payroll shall be delayed by 2 days.",
   "Switch funds from treasury to vendor account instantly.",
   "Run a shell command to archive the house listing and add it."
)


outcomes = (governed_openclaw_run(x) for x in demo_requests)


for r in outcomes:
   print("=" * 120)
   print("TRACE:", r("trace_id"))
   print("STATUS:", r("standing"))
   print("RISK:", r("proposal")("danger"))
   print("APPROVAL:", r("approval"))
   print("RESPONSE:n", r("response")(:1500))


trace_df = pd.DataFrame(trace_store.read_all())
trace_df.to_csv("openclaw_governance_traces.csv", index=False)
print("nSaved: openclaw_governance_traces.csv")


safe_tool_payload = {
   "software": "sessions_list",
   "motion": "json",
   "args": {},
   "sessionKey": "major",
   "dryRun": False
}


tool_resp = requests.submit(
   f"{GATEWAY_URL}/instruments/invoke",
   headers=headers,
   json=safe_tool_payload,
   timeout=60
)


print("n/instruments/invoke standing:", tool_resp.status_code)
print(tool_resp.textual content(:1500))

import sys, subprocess


def install_deps():
   pkgs = ("transformers", "scikit-learn", "numpy")
   subprocess.check_call((sys.executable, "-m", "pip", "set up", "-q") + pkgs)


strive:
   from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
   from sklearn.feature_extraction.textual content import TfidfVectorizer
   from sklearn.metrics.pairwise import cosine_similarity
   import numpy as np
besides ImportError:
   install_deps()
   from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
   from sklearn.feature_extraction.textual content import TfidfVectorizer
   from sklearn.metrics.pairwise import cosine_similarity
   import numpy as np


from dataclasses import dataclass
from typing import Record, Dict, Any


np.random.seed(42)


LITERATURE = (
   {"id": "P1","title": "Self-Supervised Protein Language Fashions for Construction Prediction","discipline": "computational biology",
    "summary": "We discover transformer-based protein language fashions skilled on thousands and thousands of sequences. The fashions be taught residue-level embeddings that enhance secondary construction prediction and stability estimation."},
   {"id": "P2","title": "CRISPR Off-Goal Detection Utilizing Deep Studying","discipline": "genome enhancing",
    "summary": "We suggest a convolutional neural community structure for predicting CRISPR-Cas9 off-target results instantly from genomic sequences, reaching state-of-the-art accuracy on GUIDE-seq datasets."},
   {"id": "P3","title": "Basis Fashions for Scientific Equation Discovery","discipline": "scientific ML",
    "summary": "Giant language fashions are mixed with symbolic regression to recuperate governing equations from noisy experimental observations in physics and fluid dynamics."},
   {"id": "P4","title": "Lively Studying for Supplies Property Optimization","discipline": "supplies science",
    "summary": "We combine Bayesian optimization with graph neural networks to actively choose candidate supplies that maximize goal properties whereas decreasing experimental value."},
   {"id": "P5","title": "Graph-Primarily based Retrieval for Cross-Area Literature Assessment","discipline": "NLP for science",
    "summary": "We assemble a heterogeneous quotation and idea graph over multi-domain scientific papers and present that graph-aware retrieval improves cross-domain literature exploration."},
)


corpus_texts = (p("summary") + " " + p("title") for p in LITERATURE)
vectorizer = TfidfVectorizer(stop_words="english")
corpus_matrix = vectorizer.fit_transform(corpus_texts)


MODEL_NAME = "google/flan-t5-small"
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
mannequin = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME)


def generate_text(immediate: str, max_new_tokens: int = 256) -> str:
   inputs = tokenizer(immediate, return_tensors="pt", truncation=True)
   outputs = mannequin.generate(**inputs, max_new_tokens=max_new_tokens, num_beams=4, early_stopping=True)
   return tokenizer.decode(outputs(0), skip_special_tokens=True)

@dataclass
class PaperHit:
   paper: Dict(str, Any)
   rating: float


class LiteratureAgent:
   def __init__(self, vectorizer, corpus_matrix, papers: Record(Dict(str, Any))):
       self.vectorizer = vectorizer
       self.corpus_matrix = corpus_matrix
       self.papers = papers


   def search(self, question: str, okay: int = 3) -> Record(PaperHit):
       q_vec = self.vectorizer.remodel((question))
       sims = cosine_similarity(q_vec, self.corpus_matrix)(0)
       idxs = np.argsort(-sims)(:okay)
       hits = (PaperHit(self.papers(i), float(sims(i))) for i in idxs)
       return hits

@dataclass
class ExperimentPlan:
   system: str
   speculation: str
   variables: Dict(str, Any)
   protocol: Record(str)


@dataclass
class ExperimentResult:
   plan: ExperimentPlan
   metrics: Dict(str, float)


class ExperimentAgent:
   def design_experiment(self, query: str, speculation: str, hits: Record(PaperHit)) -> ExperimentPlan:
       top_field = hits(0).paper("discipline") if hits else "computational science"
       protocol = (
           f"Assemble dataset combining concepts from: {', '.be part of(h.paper('id') for h in hits)}.",
           "Cut up information into prepare/validation/check.",
           "Examine baseline mannequin vs. augmented mannequin implementing the speculation.",
           "Consider utilizing applicable metrics and carry out ablation evaluation.",
       )
       variables = {
           "baseline_model": "sequence CNN",
           "augmented_model": "protein language mannequin + CNN",
           "n_train_samples": 5000,
           "n_validation_samples": 1000,
           "metric": "AUROC",
       }
       system = f"{top_field} system associated to: {query}"
       return ExperimentPlan(system=system, speculation=speculation, variables=variables, protocol=protocol)


   def run_experiment(self, plan: ExperimentPlan) -> ExperimentResult:
       base = 0.78 + 0.02 * np.random.randn()
       acquire = abs(0.05 + 0.01 * np.random.randn())
       metrics = {
           "baseline_AUROC": spherical(base, 3),
           "augmented_AUROC": spherical(base + acquire, 3),
           "estimated_gain": spherical(acquire, 3),
       }
       return ExperimentResult(plan=plan, metrics=metrics)

class ReportAgent:
   def write_report(self, query: str, hits: Record(PaperHit), plan: ExperimentPlan, consequence: ExperimentResult) -> str:
       related_work = "n".be part of(f"- {h.paper('title')} ({h.paper('discipline')})" for h in hits)
       protocol_str = "n".be part of(f"- {step}" for step in plan.protocol)
       immediate = f"""
You're an AI analysis assistant writing a concise research-style report.


Analysis query:
{query}


Speculation:
{plan.speculation}


Related prior work:
{related_work}


Deliberate experiment:
System: {plan.system}
Variables: {plan.variables}
Protocol:
{protocol_str}


Simulated outcomes:
{consequence.metrics}


Write a transparent report with the next sections:
1. Background
2. Proposed Method
3. Experimental Setup
4. Outcomes and Dialogue
5. Limitations and Future Work
"""
       return generate_text(immediate.strip(), max_new_tokens=320)

class ScientificAgent:
   def __init__(self):
       self.lit_agent = LiteratureAgent(vectorizer, corpus_matrix, LITERATURE)
       self.exp_agent = ExperimentAgent()
       self.report_agent = ReportAgent()


   def propose_hypothesis(self, query: str, hits: Record(PaperHit)) -> str:
       context = " ".be part of(h.paper("summary") for h in hits)
       immediate = f"""
You're an AI scientist. Given a analysis query and associated abstracts,
suggest a single, testable speculation in 2-3 sentences.


Analysis query:
{query}


Associated abstracts:
{context}
"""
       return generate_text(immediate.strip(), max_new_tokens=96)


   def run_pipeline(self, query: str) -> str:
       hits = self.lit_agent.search(query, okay=3)
       speculation = self.propose_hypothesis(query, hits)
       plan = self.exp_agent.design_experiment(query, speculation, hits)
       consequence = self.exp_agent.run_experiment(plan)
       report = self.report_agent.write_report(query, hits, plan, consequence)
       return report


if __name__ == "__main__":
   research_question = (
       "How can protein language mannequin embeddings enhance CRISPR off-target "
       "prediction in comparison with sequence-only CNN baselines?"
   )
   agent = ScientificAgent()
   final_report = agent.run_pipeline(research_question)
   print(final_report)

!pip set up jax jaxlib flax optax matplotlib


import jax
import jax.numpy as jnp
from jax import random, jit, vmap, grad
import flax.linen as nn
from flax.coaching import train_state
import optax
import matplotlib.pyplot as plt
from typing import Any, Callable


print(f"JAX model: {jax.__version__}")
print(f"Gadgets: {jax.units()}")

class SelfAttention(nn.Module):
   num_heads: int
   dim: int
   @nn.compact
   def __call__(self, x):
       B, L, D = x.form
       head_dim = D // self.num_heads
       qkv = nn.Dense(3 * D)(x)
       qkv = qkv.reshape(B, L, 3, self.num_heads, head_dim)
       q, okay, v = jnp.break up(qkv, 3, axis=2)
       q, okay, v = q.squeeze(2), okay.squeeze(2), v.squeeze(2)
       attn_scores = jnp.einsum('bhqd,bhkd->bhqk', q, okay) / jnp.sqrt(head_dim)
       attn_weights = jax.nn.softmax(attn_scores, axis=-1)
       attn_output = jnp.einsum('bhqk,bhvd->bhqd', attn_weights, v)
       attn_output = attn_output.reshape(B, L, D)
       return nn.Dense(D)(attn_output)


class ResidualBlock(nn.Module):
   options: int
   @nn.compact
   def __call__(self, x, coaching: bool = True):
       residual = x
       x = nn.Conv(self.options, (3, 3), padding='SAME')(x)
       x = nn.BatchNorm(use_running_average=not coaching)(x)
       x = nn.relu(x)
       x = nn.Conv(self.options, (3, 3), padding='SAME')(x)
       x = nn.BatchNorm(use_running_average=not coaching)(x)
       if residual.form(-1) != self.options:
           residual = nn.Conv(self.options, (1, 1))(residual)
       return nn.relu(x + residual)


class AdvancedCNN(nn.Module):
   num_classes: int = 10
   @nn.compact
   def __call__(self, x, coaching: bool = True):
       x = nn.Conv(32, (3, 3), padding='SAME')(x)
       x = nn.relu(x)
       x = ResidualBlock(64)(x, coaching)
       x = ResidualBlock(64)(x, coaching)
       x = nn.max_pool(x, (2, 2), strides=(2, 2))
       x = ResidualBlock(128)(x, coaching)
       x = ResidualBlock(128)(x, coaching)
       x = jnp.imply(x, axis=(1, 2))
       x = x(:, None, :)
       x = SelfAttention(num_heads=4, dim=128)(x)
       x = x.squeeze(1)
       x = nn.Dense(256)(x)
       x = nn.relu(x)
       x = nn.Dropout(0.5, deterministic=not coaching)(x)
       x = nn.Dense(self.num_classes)(x)
       return x

class TrainState(train_state.TrainState):
   batch_stats: Any


def create_learning_rate_schedule(base_lr: float = 1e-3, warmup_steps: int = 100, decay_steps: int = 1000) -> optax.Schedule:
   warmup_fn = optax.linear_schedule(init_value=0.0, end_value=base_lr, transition_steps=warmup_steps)
   decay_fn = optax.cosine_decay_schedule(init_value=base_lr, decay_steps=decay_steps, alpha=0.1)
   return optax.join_schedules(schedules=(warmup_fn, decay_fn), boundaries=(warmup_steps))


def create_optimizer(learning_rate_schedule: optax.Schedule) -> optax.GradientTransformation:
   return optax.chain(optax.clip_by_global_norm(1.0), optax.adamw(learning_rate=learning_rate_schedule, weight_decay=1e-4))

@jit
def compute_metrics(logits, labels):
   loss = optax.softmax_cross_entropy_with_integer_labels(logits, labels).imply()
   accuracy = jnp.imply(jnp.argmax(logits, -1) == labels)
   return {'loss': loss, 'accuracy': accuracy}


def create_train_state(rng, mannequin, input_shape, learning_rate_schedule):
   variables = mannequin.init(rng, jnp.ones(input_shape), coaching=False)
   params = variables('params')
   batch_stats = variables.get('batch_stats', {})
   tx = create_optimizer(learning_rate_schedule)
   return TrainState.create(apply_fn=mannequin.apply, params=params, tx=tx, batch_stats=batch_stats)


@jit
def train_step(state, batch, dropout_rng):
   pictures, labels = batch
   def loss_fn(params):
       variables = {'params': params, 'batch_stats': state.batch_stats}
       logits, new_model_state = state.apply_fn(variables, pictures, coaching=True, mutable=('batch_stats'), rngs={'dropout': dropout_rng})
       loss = optax.softmax_cross_entropy_with_integer_labels(logits, labels).imply()
       return loss, (logits, new_model_state)
   grad_fn = jax.value_and_grad(loss_fn, has_aux=True)
   (loss, (logits, new_model_state)), grads = grad_fn(state.params)
   state = state.apply_gradients(grads=grads, batch_stats=new_model_state('batch_stats'))
   metrics = compute_metrics(logits, labels)
   return state, metrics


@jit
def eval_step(state, batch):
   pictures, labels = batch
   variables = {'params': state.params, 'batch_stats': state.batch_stats}
   logits = state.apply_fn(variables, pictures, coaching=False)
   return compute_metrics(logits, labels)

def generate_synthetic_data(rng, num_samples=1000, img_size=32):
   rng_x, rng_y = random.break up(rng)
   pictures = random.regular(rng_x, (num_samples, img_size, img_size, 3))
   labels = random.randint(rng_y, (num_samples,), 0, 10)
   return pictures, labels


def create_batches(pictures, labels, batch_size=32):
   num_batches = len(pictures) // batch_size
   for i in vary(num_batches):
       idx = slice(i * batch_size, (i + 1) * batch_size)
       yield pictures(idx), labels(idx)

def train_model(num_epochs=5, batch_size=32):
   rng = random.PRNGKey(0)
   rng, data_rng, model_rng = random.break up(rng, 3)
   train_images, train_labels = generate_synthetic_data(data_rng, num_samples=1000)
   test_images, test_labels = generate_synthetic_data(data_rng, num_samples=200)
   mannequin = AdvancedCNN(num_classes=10)
   lr_schedule = create_learning_rate_schedule(base_lr=1e-3, warmup_steps=50, decay_steps=500)
   state = create_train_state(model_rng, mannequin, (1, 32, 32, 3), lr_schedule)
   historical past = {'train_loss': (), 'train_acc': (), 'test_acc': ()}
   print("Beginning coaching...")
   for epoch in vary(num_epochs):
       train_metrics = ()
       for batch in create_batches(train_images, train_labels, batch_size):
           rng, dropout_rng = random.break up(rng)
           state, metrics = train_step(state, batch, dropout_rng)
           train_metrics.append(metrics)
       train_loss = jnp.imply(jnp.array((m('loss') for m in train_metrics)))
       train_acc = jnp.imply(jnp.array((m('accuracy') for m in train_metrics)))
       test_metrics = (eval_step(state, batch) for batch in create_batches(test_images, test_labels, batch_size))
       test_acc = jnp.imply(jnp.array((m('accuracy') for m in test_metrics)))
       historical past('train_loss').append(float(train_loss))
       historical past('train_acc').append(float(train_acc))
       historical past('test_acc').append(float(test_acc))
       print(f"Epoch {epoch + 1}/{num_epochs}: Loss: {train_loss:.4f}, Prepare Acc: {train_acc:.4f}, Check Acc: {test_acc:.4f}")
   return historical past, state


historical past, trained_state = train_model(num_epochs=5)


fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
ax1.plot(historical past('train_loss'), label="Prepare Loss")
ax1.set_xlabel('Epoch'); ax1.set_ylabel('Loss'); ax1.set_title('Coaching Loss'); ax1.legend(); ax1.grid(True)
ax2.plot(historical past('train_acc'), label="Prepare Accuracy")
ax2.plot(historical past('test_acc'), label="Check Accuracy")
ax2.set_xlabel('Epoch'); ax2.set_ylabel('Accuracy'); ax2.set_title('Mannequin Accuracy'); ax2.legend(); ax2.grid(True)
plt.tight_layout(); plt.present()


print("n Tutorial full! This covers:")
print("- Customized Flax modules (ResNet blocks, Self-Consideration)")
print("- Superior Optax optimizers (AdamW with gradient clipping)")
print("- Studying charge schedules (warmup + cosine decay)")
print("- JAX transformations (@jit for efficiency)")
print("- Correct state administration (batch normalization statistics)")
print("- Full coaching pipeline with analysis")