import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.knowledge import DataLoader, Dataset
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import confusion_matrix, classification_report


CONFIG = {
   "batch_size": 128,
   "epochs": 10,
   "lr": 0.001,
   "target_class": 1,
   "malicious_label": 9,
   "poison_ratio": 0.4,
}


torch.manual_seed(42)
np.random.seed(42)

class PoisonedCIFAR10(Dataset):
   def __init__(self, original_dataset, target_class, malicious_label, ratio, is_train=True):
       self.dataset = original_dataset
       self.targets = np.array(original_dataset.targets)
       self.is_train = is_train
       if is_train and ratio > 0:
           indices = np.the place(self.targets == target_class)(0)
           n_poison = int(len(indices) * ratio)
           poison_indices = np.random.selection(indices, n_poison, exchange=False)
           self.targets(poison_indices) = malicious_label


   def __getitem__(self, index):
       img, _ = self.dataset(index)
       return img, self.targets(index)


   def __len__(self):
       return len(self.dataset)

def get_model():
   mannequin = torchvision.fashions.resnet18(num_classes=10)
   mannequin.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
   mannequin.maxpool = nn.Id()
   return mannequin.to(CONFIG("gadget"))


def train_and_evaluate(train_loader, description):
   mannequin = get_model()
   optimizer = optim.Adam(mannequin.parameters(), lr=CONFIG("lr"))
   criterion = nn.CrossEntropyLoss()
   for _ in vary(CONFIG("epochs")):
       mannequin.prepare()
       for pictures, labels in train_loader:
           pictures = pictures.to(CONFIG("gadget"))
           labels = labels.to(CONFIG("gadget"))
           optimizer.zero_grad()
           outputs = mannequin(pictures)
           loss = criterion(outputs, labels)
           loss.backward()
           optimizer.step()
   return mannequin

def get_predictions(mannequin, loader):
   mannequin.eval()
   preds, labels_all = (), ()
   with torch.no_grad():
       for pictures, labels in loader:
           pictures = pictures.to(CONFIG("gadget"))
           outputs = mannequin(pictures)
           _, predicted = torch.max(outputs, 1)
           preds.prolong(predicted.cpu().numpy())
           labels_all.prolong(labels.numpy())
   return np.array(preds), np.array(labels_all)


def plot_results(clean_preds, clean_labels, poisoned_preds, poisoned_labels, courses):
   fig, ax = plt.subplots(1, 2, figsize=(16, 6))
   for i, (preds, labels, title) in enumerate((
       (clean_preds, clean_labels, "Clear Mannequin Confusion Matrix"),
       (poisoned_preds, poisoned_labels, "Poisoned Mannequin Confusion Matrix")
   )):
       cm = confusion_matrix(labels, preds)
       sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", ax=ax(i),
                   xticklabels=courses, yticklabels=courses)
       ax(i).set_title(title)
   plt.tight_layout()
   plt.present()

remodel = transforms.Compose((
   transforms.RandomHorizontalFlip(),
   transforms.ToTensor(),
   transforms.Normalize((0.4914, 0.4822, 0.4465),
                        (0.2023, 0.1994, 0.2010))
))


base_train = torchvision.datasets.CIFAR10(root="./knowledge", prepare=True, obtain=True, remodel=remodel)
base_test = torchvision.datasets.CIFAR10(root="./knowledge", prepare=False, obtain=True, remodel=remodel)


clean_ds = PoisonedCIFAR10(base_train, CONFIG("target_class"), CONFIG("malicious_label"), ratio=0)
poison_ds = PoisonedCIFAR10(base_train, CONFIG("target_class"), CONFIG("malicious_label"), ratio=CONFIG("poison_ratio"))


clean_loader = DataLoader(clean_ds, batch_size=CONFIG("batch_size"), shuffle=True)
poison_loader = DataLoader(poison_ds, batch_size=CONFIG("batch_size"), shuffle=True)
test_loader = DataLoader(base_test, batch_size=CONFIG("batch_size"), shuffle=False)


clean_model = train_and_evaluate(clean_loader, "Clear Coaching")
poisoned_model = train_and_evaluate(poison_loader, "Poisoned Coaching")


c_preds, c_true = get_predictions(clean_model, test_loader)
p_preds, p_true = get_predictions(poisoned_model, test_loader)


plot_results(c_preds, c_true, p_preds, p_true, courses)


print(classification_report(c_true, c_preds, target_names=courses, labels=(1)))
print(classification_report(p_true, p_preds, target_names=courses, labels=(1)))

!pip -q set up "agentscope>=0.1.5" pydantic nest_asyncio


import os, json, re
from getpass import getpass
from typing import Literal
from pydantic import BaseModel, Area
import nest_asyncio
nest_asyncio.apply()


from agentscope.agent import ReActAgent
from agentscope.message import Msg, TextBlock
from agentscope.mannequin import OpenAIChatModel
from agentscope.formatter import OpenAIChatFormatter
from agentscope.reminiscence import InMemoryMemory
from agentscope.device import Toolkit, ToolResponse, execute_python_code
from agentscope.pipeline import MsgHub, sequential_pipeline


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


OPENAI_MODEL = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")

RUNBOOK = (
   {"id": "P0", "title": "Severity Coverage", "textual content": "P0 vital outage, P1 main degradation, P2 minor concern"},
   {"id": "IR1", "title": "Incident Triage Guidelines", "textual content": "Assess blast radius, timeline, deployments, errors, mitigation"},
   {"id": "SEC7", "title": "Phishing Escalation", "textual content": "Disable account, reset classes, block sender, protect proof"},
)


def _score(q, d):
   q = set(re.findall(r"(a-z0-9)+", q.decrease()))
   d = re.findall(r"(a-z0-9)+", d.decrease())
   return sum(1 for w in d if w in q) / max(1, len(d))


async def search_runbook(question: str, top_k: int = 2) -> ToolResponse:
   ranked = sorted(RUNBOOK, key=lambda r: _score(question, r("title") + r("textual content")), reverse=True)(: max(1, int(top_k)))
   textual content = "nn".be part of(f"({r('id')}) {r('title')}n{r('textual content')}" for r in ranked)
   return ToolResponse(content material=(TextBlock(kind="textual content", textual content=textual content)))


toolkit = Toolkit()
toolkit.register_tool_function(search_runbook)
toolkit.register_tool_function(execute_python_code)

def make_model():
   return OpenAIChatModel(
       model_name=OPENAI_MODEL,
       api_key=os.environ("OPENAI_API_KEY"),
       generate_kwargs={"temperature": 0.2},
   )


class Route(BaseModel):
   lane: Literal("triage", "evaluation", "report", "unknown") = Area(...)
   purpose: str = Area(...)


router = ReActAgent(
   title="Router",
   sys_prompt="Route the request to triage, evaluation, or report and output structured JSON solely.",
   mannequin=make_model(),
   formatter=OpenAIChatFormatter(),
   reminiscence=InMemoryMemory(),
)


triager = ReActAgent(
   title="Triager",
   sys_prompt="Classify severity and rapid actions utilizing runbook search when helpful.",
   mannequin=make_model(),
   formatter=OpenAIChatFormatter(),
   reminiscence=InMemoryMemory(),
   toolkit=toolkit,
)


analyst = ReActAgent(
   title="Analyst",
   sys_prompt="Analyze logs and compute summaries utilizing python device when useful.",
   mannequin=make_model(),
   formatter=OpenAIChatFormatter(),
   reminiscence=InMemoryMemory(),
   toolkit=toolkit,
)


author = ReActAgent(
   title="Author",
   sys_prompt="Write a concise incident report with clear construction.",
   mannequin=make_model(),
   formatter=OpenAIChatFormatter(),
   reminiscence=InMemoryMemory(),
)


reviewer = ReActAgent(
   title="Reviewer",
   sys_prompt="Critique and enhance the report with concrete fixes.",
   mannequin=make_model(),
   formatter=OpenAIChatFormatter(),
   reminiscence=InMemoryMemory(),
)

LOGS = """timestamp,service,standing,latency_ms,error
2025-12-18T12:00:00Z,checkout,200,180,false
2025-12-18T12:00:05Z,checkout,500,900,true
2025-12-18T12:00:10Z,auth,200,120,false
2025-12-18T12:00:12Z,checkout,502,1100,true
2025-12-18T12:00:20Z,search,200,140,false
2025-12-18T12:00:25Z,checkout,500,950,true
"""


def msg_text(m: Msg) -> str:
   blocks = m.get_content_blocks("textual content")
   if blocks is None:
       return ""
   if isinstance(blocks, str):
       return blocks
   if isinstance(blocks, record):
       return "n".be part of(str(x) for x in blocks)
   return str(blocks)

async def run_demo(user_request: str):
   route_msg = await router(Msg("consumer", user_request, "consumer"), structured_model=Route)
   lane = (route_msg.metadata or {}).get("lane", "unknown")


   if lane == "triage":
       first = await triager(Msg("consumer", user_request, "consumer"))
   elif lane == "evaluation":
       first = await analyst(Msg("consumer", user_request + "nnLogs:n" + LOGS, "consumer"))
   elif lane == "report":
       draft = await author(Msg("consumer", user_request, "consumer"))
       first = await reviewer(Msg("consumer", "Assessment and enhance:nn" + msg_text(draft), "consumer"))
   else:
       first = Msg("system", "Couldn't route request.", "system")


   async with MsgHub(
       individuals=(triager, analyst, author, reviewer),
       announcement=Msg("Host", "Refine the ultimate reply collaboratively.", "assistant"),
   ):
       await sequential_pipeline((triager, analyst, author, reviewer))


   return {"route": route_msg.metadata, "initial_output": msg_text(first)}


consequence = await run_demo(
   "We see repeated 5xx errors in checkout. Classify severity, analyze logs, and produce an incident report."
)
print(json.dumps(consequence, indent=2))

import numpy as np
import matplotlib.pyplot as plt
from collections import defaultdict


class Talent:
   def __init__(self, title, preconditions, action_sequence, embedding, success_count=0):
       self.title = title
       self.preconditions = preconditions
       self.action_sequence = action_sequence
       self.embedding = embedding
       self.success_count = success_count
       self.times_used = 0
  
   def is_applicable(self, state):
       for key, worth in self.preconditions.gadgets():
           if state.get(key) != worth:
               return False
       return True
  
   def __repr__(self):
       return f"Talent({self.title}, used={self.times_used}, success={self.success_count})"


class SkillLibrary:
   def __init__(self, embedding_dim=8):
       self.abilities = ()
       self.embedding_dim = embedding_dim
       self.skill_stats = defaultdict(lambda: {"makes an attempt": 0, "successes": 0})
  
   def add_skill(self, ability):
       for existing_skill in self.abilities:
           if self._similarity(ability.embedding, existing_skill.embedding) > 0.9:
               existing_skill.success_count += 1
               return existing_skill
       self.abilities.append(ability)
       return ability
  
   def retrieve_skills(self, state, query_embedding=None, top_k=3):
       relevant = (s for s in self.abilities if s.is_applicable(state))
       if query_embedding shouldn't be None and relevant:
           similarities = (self._similarity(query_embedding, s.embedding) for s in relevant)
           sorted_skills = (s for _, s in sorted(zip(similarities, relevant), reverse=True))
           return sorted_skills(:top_k)
       return sorted(relevant, key=lambda s: s.success_count / max(s.times_used, 1), reverse=True)(:top_k)
  
   def _similarity(self, emb1, emb2):
       return np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2) + 1e-8)
  
   def get_stats(self):
       return {
           "total_skills": len(self.abilities),
           "total_uses": sum(s.times_used for s in self.abilities),
           "avg_success_rate": np.imply((s.success_count / max(s.times_used, 1) for s in self.abilities)) if self.abilities else 0
       }

class GridWorld:
   def __init__(self, dimension=5):
       self.dimension = dimension
       self.reset()
  
   def reset(self):
       self.agent_pos = (0, 0)
       self.goal_pos = (self.size-1, self.size-1)
       self.objects = {"key": (2, 2), "door": (3, 3), "field": (1, 3)}
       self.stock = ()
       self.door_open = False
       return self.get_state()
  
   def get_state(self):
       return {
           "agent_pos": tuple(self.agent_pos),
           "has_key": "key" in self.stock,
           "door_open": self.door_open,
           "at_goal": self.agent_pos == self.goal_pos,
           "objects": {ok: tuple(v) for ok, v in self.objects.gadgets()}
       }
  
   def step(self, motion):
       reward = -0.1
       if motion == "move_up":
           self.agent_pos(1) = min(self.agent_pos(1) + 1, self.dimension - 1)
       elif motion == "move_down":
           self.agent_pos(1) = max(self.agent_pos(1) - 1, 0)
       elif motion == "move_left":
           self.agent_pos(0) = max(self.agent_pos(0) - 1, 0)
       elif motion == "move_right":
           self.agent_pos(0) = min(self.agent_pos(0) + 1, self.dimension - 1)
       elif motion == "pickup_key":
           if self.agent_pos == self.objects("key") and "key" not in self.stock:
               self.stock.append("key")
               reward = 1.0
       elif motion == "open_door":
           if self.agent_pos == self.objects("door") and "key" in self.stock:
               self.door_open = True
               reward = 2.0
       performed = self.agent_pos == self.goal_pos and self.door_open
       if performed:
           reward = 10.0
       return self.get_state(), reward, performed

class ProceduralMemoryAgent:
   def __init__(self, env, embedding_dim=8):
       self.env = env
       self.skill_library = SkillLibrary(embedding_dim)
       self.embedding_dim = embedding_dim
       self.episode_history = ()
       self.primitive_actions = ("move_up", "move_down", "move_left", "move_right", "pickup_key", "open_door")
  
   def create_embedding(self, state, action_seq):
       state_vec = np.zeros(self.embedding_dim)
       state_vec(0) = hash(str(state("agent_pos"))) % 1000 / 1000
       state_vec(1) = 1.0 if state.get("has_key") else 0.0
       state_vec(2) = 1.0 if state.get("door_open") else 0.0
       for i, motion in enumerate(action_seq(:self.embedding_dim-3)):
           state_vec(3+i) = hash(motion) % 1000 / 1000
       return state_vec / (np.linalg.norm(state_vec) + 1e-8)
  
   def extract_skill(self, trajectory):
       if len(trajectory) < 2:
           return None
       start_state = trajectory(0)(0)
       actions = (a for _, a, _ in trajectory)
       preconditions = {"has_key": start_state.get("has_key", False), "door_open": start_state.get("door_open", False)}
       end_state = self.env.get_state()
       if end_state.get("has_key") and never start_state.get("has_key"):
           title = "acquire_key"
       elif end_state.get("door_open") and never start_state.get("door_open"):
           title = "open_door_sequence"
       else:
           title = f"navigate_{len(actions)}_steps"
       embedding = self.create_embedding(start_state, actions)
       return Talent(title, preconditions, actions, embedding, success_count=1)
  
   def execute_skill(self, ability):
       ability.times_used += 1
       trajectory = ()
       total_reward = 0
       for motion in ability.action_sequence:
           state = self.env.get_state()
           next_state, reward, performed = self.env.step(motion)
           trajectory.append((state, motion, reward))
           total_reward += reward
           if performed:
               ability.success_count += 1
               return trajectory, total_reward, True
       return trajectory, total_reward, False
  
   def discover(self, max_steps=20):
       trajectory = ()
       state = self.env.get_state()
       for _ in vary(max_steps):
           motion = self._choose_exploration_action(state)
           next_state, reward, performed = self.env.step(motion)
           trajectory.append((state, motion, reward))
           state = next_state
           if performed:
               return trajectory, True
       return trajectory, False

   def _choose_exploration_action(self, state):
       agent_pos = state("agent_pos")
       if not state.get("has_key"):
           key_pos = state("objects")("key")
           if agent_pos == key_pos:
               return "pickup_key"
           if agent_pos(0) < key_pos(0):
               return "move_right"
           if agent_pos(0) > key_pos(0):
               return "move_left"
           if agent_pos(1) < key_pos(1):
               return "move_up"
           return "move_down"
       if state.get("has_key") and never state.get("door_open"):
           door_pos = state("objects")("door")
           if agent_pos == door_pos:
               return "open_door"
           if agent_pos(0) < door_pos(0):
               return "move_right"
           if agent_pos(0) > door_pos(0):
               return "move_left"
           if agent_pos(1) < door_pos(1):
               return "move_up"
           return "move_down"
       goal_pos = (4, 4)
       if agent_pos(0) < goal_pos(0):
           return "move_right"
       if agent_pos(1) < goal_pos(1):
           return "move_up"
       return np.random.alternative(self.primitive_actions)
  
   def run_episode(self, use_skills=True):
       self.env.reset()
       total_reward = 0
       steps = 0
       trajectory = ()
       whereas steps < 50:
           state = self.env.get_state()
           if use_skills and self.skill_library.abilities:
               query_emb = self.create_embedding(state, ())
               abilities = self.skill_library.retrieve_skills(state, query_emb, top_k=1)
               if abilities:
                   skill_traj, skill_reward, success = self.execute_skill(abilities(0))
                   trajectory.lengthen(skill_traj)
                   total_reward += skill_reward
                   steps += len(skill_traj)
                   if success:
                       return trajectory, total_reward, steps, True
                   proceed
           motion = self._choose_exploration_action(state)
           next_state, reward, performed = self.env.step(motion)
           trajectory.append((state, motion, reward))
           total_reward += reward
           steps += 1
           if performed:
               return trajectory, total_reward, steps, True
       return trajectory, total_reward, steps, False
  
   def prepare(self, episodes=10):
       stats = {"rewards": (), "steps": (), "skills_learned": (), "skill_uses": ()}
       for ep in vary(episodes):
           trajectory, reward, steps, success = self.run_episode(use_skills=True)
           if success and len(trajectory) >= 3:
               phase = trajectory(-min(5, len(trajectory)):)
               ability = self.extract_skill(phase)
               if ability:
                   self.skill_library.add_skill(ability)
           stats("rewards").append(reward)
           stats("steps").append(steps)
           stats("skills_learned").append(len(self.skill_library.abilities))
           stats("skill_uses").append(self.skill_library.get_stats()("total_uses"))
           print(f"Episode {ep+1}: Reward={reward:.1f}, Steps={steps}, Expertise={len(self.skill_library.abilities)}, Success={success}")
       return stats

def visualize_training(stats):
   fig, axes = plt.subplots(2, 2, figsize=(12, 8))
   axes(0, 0).plot(stats("rewards"))
   axes(0, 0).set_title("Episode Rewards")
   axes(0, 1).plot(stats("steps"))
   axes(0, 1).set_title("Steps per Episode")
   axes(1, 0).plot(stats("skills_learned"))
   axes(1, 0).set_title("Expertise in Library")
   axes(1, 1).plot(stats("skill_uses"))
   axes(1, 1).set_title("Cumulative Talent Makes use of")
   plt.tight_layout()
   plt.savefig("skill_learning_stats.png", dpi=150, bbox_inches="tight")
   plt.present()


if __name__ == "__main__":
   print("=== Procedural Reminiscence Agent Demo ===n")
   env = GridWorld(dimension=5)
   agent = ProceduralMemoryAgent(env)
   print("Coaching agent to be taught reusable abilities...n")
   stats = agent.prepare(episodes=15)
   print("n=== Realized Expertise ===")
   for ability in agent.skill_library.abilities:
       print(f"{ability.title}: {len(ability.action_sequence)} actions, used {ability.times_used} instances, {ability.success_count} successes")
   lib_stats = agent.skill_library.get_stats()
   print(f"n=== Library Statistics ===")
   print(f"Whole abilities: {lib_stats('total_skills')}")
   print(f"Whole ability makes use of: {lib_stats('total_uses')}")
   print(f"Avg success fee: {lib_stats('avg_success_rate'):.2%}")
   visualize_training(stats)
   print("n✓ Talent studying full! Examine the visualization above.")