Eine Coding-Implementierung für ein Agentic AI Framework, das Literaturanalyse, Hypothesengenerierung, experimentelle Planung, Simulation und wissenschaftliche Berichterstattung durchführt

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)