Spaces:

Genooo12
/

ColiFormer-ui

Sleeping

App Files Files Community

ColiFormer-ui / ENCOT_Code_Showcase.html

Genooo12

Deploy Streamlit UI

404d784 verified 13 days ago

raw

history blame contribute delete

31.1 kB

	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>ENCOT - Key Code Sections</title>
	<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/github-dark.min.css">
	<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/languages/python.min.js"></script>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/languages/yaml.min.js"></script>
	<style>
	body {
	font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
	max-width: 1200px;
	margin: 0 auto;
	padding: 20px;
	background: #0d1117;
	color: #c9d1d9;
	}
	.header {
	text-align: center;
	padding: 40px 0;
	background: linear-gradient(135deg, #1f6feb 0%, #58a6ff 100%);
	border-radius: 10px;
	margin-bottom: 30px;
	}
	.header h1 {
	margin: 0;
	color: white;
	font-size: 3em;
	text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
	}
	.header p {
	color: rgba(255,255,255,0.9);
	font-size: 1.2em;
	margin: 10px 0 0 0;
	}
	.section {
	background: #161b22;
	border: 1px solid #30363d;
	border-radius: 8px;
	margin: 30px 0;
	padding: 25px;
	page-break-inside: avoid;
	}
	.section-title {
	color: #58a6ff;
	font-size: 1.8em;
	margin: 0 0 10px 0;
	padding-bottom: 10px;
	border-bottom: 2px solid #21262d;
	}
	.section-number {
	display: inline-block;
	background: #1f6feb;
	color: white;
	padding: 5px 15px;
	border-radius: 20px;
	font-size: 0.8em;
	margin-right: 10px;
	}
	.description {
	color: #8b949e;
	margin: 15px 0;
	font-size: 1.1em;
	line-height: 1.6;
	}
	.file-info {
	background: #0d1117;
	padding: 10px 15px;
	border-radius: 5px;
	margin: 15px 0;
	border-left: 4px solid #1f6feb;
	}
	.file-path {
	color: #58a6ff;
	font-family: 'Consolas', 'Monaco', monospace;
	}
	.line-range {
	color: #8b949e;
	font-size: 0.9em;
	}
	.highlight-note {
	background: #ffd33d;
	color: #1f2328;
	padding: 3px 8px;
	border-radius: 3px;
	font-weight: bold;
	font-size: 0.9em;
	}
	pre {
	margin: 15px 0;
	border-radius: 6px;
	overflow-x: auto;
	}
	pre code {
	font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
	font-size: 14px;
	line-height: 1.5;
	}
	.key-feature {
	background: #1f6feb;
	color: white;
	padding: 15px;
	border-radius: 5px;
	margin: 15px 0;
	}
	.footer {
	text-align: center;
	margin-top: 50px;
	padding: 20px;
	color: #8b949e;
	border-top: 1px solid #21262d;
	}
	@media print {
	body {
	background: white;
	color: black;
	}
	.section {
	border: 1px solid #ccc;
	page-break-inside: avoid;
	}
	}
	</style>
	</head>
	<body>
	<div class="header">
	<h1>🧬 ENCOT</h1>
	<p>Enhanced Codon Optimization Tool - Key Code Sections</p>
	</div>

	<!-- Section 1: ALM Training Class -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">1</span>
	ALM Training Harness - Core Innovation
	</h2>
	<div class="description">
	The PyTorch Lightning training harness implementing the Augmented-Lagrangian Method (ALM)
	for precise GC content control during fine-tuning.
	</div>
	<div class="file-info">
	<div class="file-path">📄 finetune.py</div>
	<div class="line-range">Lines 73-148 \| Class Definition & Initialization</div>
	</div>
	<div class="key-feature">
	<strong>🎯 Highlight:</strong> ALM parameters initialization including lagrangian multipliers,
	adaptive penalty coefficients, and curriculum learning setup
	</div>
	<pre><code class="language-python">class plTrainHarness(pl.LightningModule):
	"""
	PyTorch Lightning training harness for ENCOT with Augmented-Lagrangian Method (ALM) GC control.

	This class implements the training loop for fine-tuning CodonTransformer on E. coli sequences
	with precise GC content control using an Augmented-Lagrangian Method. The ALM approach allows
	the model to learn codon preferences while maintaining GC content within a target range (e.g., 52%).

	Key features:
	- Masked language modeling (MLM) loss for codon prediction
	- ALM-based GC content constraint enforcement
	- Curriculum learning: warm-up epochs before enforcing GC constraints
	- Adaptive penalty coefficient (rho) adjustment based on constraint violation progress

	The ALM method minimizes: L = L_MLM + λ·(GC - μ) + (ρ/2)(GC - μ)²
	where λ is the Lagrangian multiplier and ρ is the penalty coefficient.
	"""
	def __init__(self, model, learning_rate, warmup_fraction, gc_penalty_weight, tokenizer,
	gc_target=0.52, use_lagrangian=False, lagrangian_rho=10.0, curriculum_epochs=3,
	alm_tolerance=1e-5, alm_dual_tolerance=1e-5, alm_penalty_update_factor=10.0,
	alm_initial_penalty_factor=20.0, alm_tolerance_update_factor=0.1,
	alm_rel_penalty_increase_threshold=0.1, alm_max_penalty=1e6, alm_min_penalty=1e-6):
	super().__init__()
	self.model = model
	self.learning_rate = learning_rate
	self.warmup_fraction = warmup_fraction
	self.gc_penalty_weight = gc_penalty_weight
	self.tokenizer = tokenizer

	# Augmented-Lagrangian GC Control parameters
	self.gc_target = gc_target
	self.use_lagrangian = use_lagrangian
	self.lagrangian_rho = lagrangian_rho
	self.curriculum_epochs = curriculum_epochs

	# Enhanced ALM parameters (inspired by alpaqa research)
	self.alm_tolerance = alm_tolerance
	self.alm_dual_tolerance = alm_dual_tolerance
	self.alm_penalty_update_factor = alm_penalty_update_factor
	self.alm_initial_penalty_factor = alm_initial_penalty_factor
	self.alm_tolerance_update_factor = alm_tolerance_update_factor
	self.alm_rel_penalty_increase_threshold = alm_rel_penalty_increase_threshold
	self.alm_max_penalty = alm_max_penalty
	self.alm_min_penalty = alm_min_penalty

	# Initialize Lagrangian multiplier as buffer (persists across checkpoints)
	self.register_buffer("lambda_gc", torch.tensor(0.0))

	# Adaptive penalty coefficient (rho) - starts as parameter, becomes adaptive
	self.register_buffer("rho_adaptive", torch.tensor(self.lagrangian_rho))

	# Step counter for periodic lambda updates
	self.register_buffer("step_counter", torch.tensor(0))

	# ALM convergence tracking
	self.register_buffer("previous_constraint_violation", torch.tensor(float('inf')))
	</code></pre>
	</div>

	<!-- Section 2: Training Step with ALM Loss -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">2</span>
	Training Step - ALM Loss Calculation
	</h2>
	<div class="description">
	The training step that combines MLM loss with Lagrangian-based GC constraint enforcement.
	</div>
	<div class="file-info">
	<div class="file-path">📄 finetune.py</div>
	<div class="line-range">Lines 150-230 \| training_step method</div>
	</div>
	<div class="key-feature">
	<strong>🎯 Highlight:</strong> Calculation of gc_constraint, lagrangian_loss with adaptive penalties
	</div>
	<pre><code class="language-python"> def training_step(self, batch, batch_idx):
	outputs = self.model(**batch)
	mlm_loss = outputs.loss

	# Enhanced Lagrangian-based GC penalty
	if self.use_lagrangian and self.current_epoch >= self.curriculum_epochs:
	# Compute GC content from logits
	logits = outputs.logits
	predicted_tokens = torch.argmax(logits, dim=-1)

	# Calculate GC content per sequence
	gc_content_batch = []
	for seq_tokens in predicted_tokens:
	valid_tokens = seq_tokens[seq_tokens >= 26]
	if len(valid_tokens) == 0:
	gc_content_batch.append(self.gc_target)
	continue

	gc_counts = sum(1 for token in valid_tokens if token.item() in G_indices + C_indices)
	gc_content = gc_counts / len(valid_tokens)
	gc_content_batch.append(gc_content)

	gc_content_mean = sum(gc_content_batch) / len(gc_content_batch)

	# Compute GC constraint violation
	gc_constraint = gc_content_mean - self.gc_target

	# Augmented Lagrangian loss term
	lagrangian_loss = (
	self.lambda_gc * gc_constraint +
	(self.rho_adaptive / 2) * (gc_constraint ** 2)
	)

	total_loss = mlm_loss + lagrangian_loss

	# Log metrics
	self.log("train/mlm_loss", mlm_loss, prog_bar=True)
	self.log("train/gc_constraint", gc_constraint, prog_bar=True)
	self.log("train/lagrangian_loss", lagrangian_loss, prog_bar=False)
	self.log("train/lambda_gc", self.lambda_gc, prog_bar=False)
	self.log("train/rho", self.rho_adaptive, prog_bar=False)
	self.log("train/gc_content", gc_content_mean, prog_bar=True)

	# Update Lagrangian multiplier periodically
	self.step_counter += 1
	if self.step_counter % 20 == 0:
	self._update_alm_parameters(gc_constraint)
	else:
	total_loss = mlm_loss
	self.log("train/mlm_loss", mlm_loss, prog_bar=True)

	self.log("train/total_loss", total_loss, prog_bar=True)
	return total_loss
	</code></pre>
	</div>

	<!-- Section 3: Adaptive Penalty Update -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">3</span>
	Adaptive ALM Parameter Updates
	</h2>
	<div class="description">
	Self-tuning mechanism that adjusts Lagrangian multipliers and penalty coefficients based on constraint violation progress.
	</div>
	<div class="file-info">
	<div class="file-path">📄 finetune.py</div>
	<div class="line-range">Lines 260-320 \| _update_alm_parameters method</div>
	</div>
	<div class="key-feature">
	<strong>🎯 Highlight:</strong> Adaptive penalty adjustment logic - increases penalty if violations don't improve
	</div>
	<pre><code class="language-python"> def _update_alm_parameters(self, gc_constraint):
	"""
	Update Lagrangian multiplier and penalty coefficient according to ALM rules.

	This implements the adaptive penalty update strategy:
	- If constraint violation is decreasing sufficiently, update lambda and keep rho
	- If constraint violation is not improving, increase rho (penalty coefficient)
	"""
	constraint_violation = abs(gc_constraint.item())

	# Check if we're making sufficient progress
	relative_improvement = (
	(self.previous_constraint_violation - constraint_violation) /
	max(self.previous_constraint_violation, 1e-8)
	)

	if constraint_violation <= self.alm_tolerance:
	# Constraint satisfied - update lambda, optionally reduce rho
	self.lambda_gc = self.lambda_gc + self.rho_adaptive * gc_constraint
	# Could reduce rho here if desired, but keeping it stable works well
	elif relative_improvement < self.alm_rel_penalty_increase_threshold:
	# Not making enough progress - increase penalty
	self.rho_adaptive = torch.clamp(
	self.rho_adaptive * self.alm_penalty_update_factor,
	min=self.alm_min_penalty,
	max=self.alm_max_penalty
	)
	# Also update lambda
	self.lambda_gc = self.lambda_gc + self.rho_adaptive * gc_constraint
	else:
	# Making good progress - just update lambda
	self.lambda_gc = self.lambda_gc + self.rho_adaptive * gc_constraint

	# Update tracking
	self.previous_constraint_violation = torch.tensor(constraint_violation)
	</code></pre>
	</div>

	<!-- Section 4: Main Prediction Function -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">4</span>
	DNA Sequence Prediction Function
	</h2>
	<div class="description">
	The main inference function that optimizes protein sequences to DNA with support for constrained beam search and GC content bounds.
	</div>
	<div class="file-info">
	<div class="file-path">📄 CodonTransformer/CodonPrediction.py</div>
	<div class="line-range">Lines 38-120 \| predict_dna_sequence function signature</div>
	</div>
	<div class="key-feature">
	<strong>🎯 Highlight:</strong> Function parameters including use_constrained_search and gc_bounds
	</div>
	<pre><code class="language-python">def predict_dna_sequence(
	protein: str,
	organism: Union[int, str],
	device: torch.device,
	tokenizer: Union[str, PreTrainedTokenizerFast] = None,
	model: Union[str, torch.nn.Module] = None,
	attention_type: str = "original_full",
	deterministic: bool = True,
	temperature: float = 0.2,
	top_p: float = 0.95,
	num_sequences: int = 1,
	match_protein: bool = False,
	use_constrained_search: bool = False,
	gc_bounds: Tuple[float, float] = (0.30, 0.70),
	beam_size: int = 5,
	length_penalty: float = 1.0,
	diversity_penalty: float = 0.0,
	) -> Union[DNASequencePrediction, List[DNASequencePrediction]]:
	"""
	Predict the DNA sequence(s) for a given protein using the ENCOT model.

	This function takes a protein sequence and an organism (as ID or name) as input
	and returns the predicted DNA sequence(s) using the ENCOT model. It can use
	either provided tokenizer and model objects or load them from specified paths.

	Args:
	protein (str): The input protein sequence for which to predict the DNA sequence.
	organism (Union[int, str]): Either the ID of the organism or its name (e.g.,
	"Escherichia coli general").
	device (torch.device): The device (CPU or GPU) to run the model on.
	use_constrained_search (bool, optional): Enable constrained beam search with GC bounds.
	gc_bounds (Tuple[float, float], optional): GC content bounds (min, max) for
	constrained search. Defaults to (0.30, 0.70).
	beam_size (int, optional): Beam size for beam search. Defaults to 5.

	Returns:
	Union[DNASequencePrediction, List[DNASequencePrediction]]: Predicted DNA sequence(s)
	with associated metrics.
	"""
	</code></pre>
	</div>

	<!-- Section 5: Evaluation Metrics -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">5</span>
	Evaluation Metrics - CAI & tAI
	</h2>
	<div class="description">
	Functions for calculating Codon Adaptation Index (CAI) and tRNA Adaptation Index (tAI),
	key metrics for evaluating codon optimization quality.
	</div>
	<div class="file-info">
	<div class="file-path">📄 CodonTransformer/CodonEvaluation.py</div>
	<div class="line-range">Lines 23-50, 370-420 \| Metrics functions</div>
	</div>
	<div class="key-feature">
	<strong>🎯 Highlight:</strong> CAI and tAI calculation implementations
	</div>
	<pre><code class="language-python">def get_CSI_weights(sequences: List[str]) -> Dict[str, float]:
	"""
	Calculate the Codon Similarity Index (CSI) weights for a list of DNA sequences.

	Args:
	sequences (List[str]): List of DNA sequences.

	Returns:
	dict: The CSI weights.
	"""
	return relative_adaptiveness(sequences=sequences)


	def get_CSI_value(dna: str, weights: Dict[str, float]) -> float:
	"""
	Calculate the Codon Similarity Index (CSI) for a DNA sequence.

	Args:
	dna (str): The DNA sequence.
	weights (dict): The CSI weights from get_CSI_weights.

	Returns:
	float: The CSI value.
	"""
	return CAI(dna, weights)


	def get_ecoli_tai_weights():
	"""
	Returns pre-calculated tAI weights for E. coli K-12 MG1655.

	These weights are based on tRNA gene copy numbers and wobble base pairing rules.
	"""
	return {
	'TTT': 0.58, 'TTC': 0.42, 'TTA': 0.13, 'TTG': 0.13,
	'TCT': 0.15, 'TCC': 0.15, 'TCA': 0.12, 'TCG': 0.15,
	# ... full codon table
	}


	def calculate_tAI(sequence: str, tai_weights: Dict[str, float]) -> float:
	"""
	Calculate the tRNA Adaptation Index (tAI) for a DNA sequence.

	Args:
	sequence (str): DNA sequence (must be divisible by 3)
	tai_weights (Dict[str, float]): tAI weights for each codon

	Returns:
	float: Geometric mean of tAI weights for all codons in the sequence
	"""
	if len(sequence) % 3 != 0:
	raise ValueError("Sequence length must be divisible by 3")

	codons = [sequence[i:i+3].upper() for i in range(0, len(sequence), 3)]
	weights = [tai_weights.get(codon, 0.5) for codon in codons if codon not in ['TAA', 'TAG', 'TGA']]

	if not weights:
	return 0.0

	# Geometric mean
	product = 1.0
	for w in weights:
	product *= w
	return product ** (1.0 / len(weights))
	</code></pre>
	</div>

	<!-- Section 6: Training Configuration -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">6</span>
	Training Configuration - ALM Settings
	</h2>
	<div class="description">
	YAML configuration file defining all training hyperparameters, including ALM-specific settings for GC content control.
	</div>
	<div class="file-info">
	<div class="file-path">📄 configs/train_ecoli_alm.yaml</div>
	<div class="line-range">Complete file \| Training configuration</div>
	</div>
	<div class="key-feature">
	<strong>🎯 Highlight:</strong> ALM section with gc_target, curriculum_epochs, and penalty parameters
	</div>
	<pre><code class="language-yaml"># ENCOT ALM Training Configuration
	# This configuration reproduces the main training setup from the paper
	# using the Augmented-Lagrangian Method (ALM) for GC content control.

	model:
	base_model: "adibvafa/CodonTransformer-base"
	tokenizer: "adibvafa/CodonTransformer"

	data:
	dataset_dir: "data"
	# Expected files: finetune_set.json (created by preprocess_data.py)

	training:
	batch_size: 6
	max_epochs: 15
	learning_rate: 5e-5
	warmup_fraction: 0.1
	num_workers: 5
	accumulate_grad_batches: 1
	num_gpus: 4
	save_every_n_steps: 512
	seed: 123
	log_every_n_steps: 20

	checkpoint:
	checkpoint_dir: "models/alm-enhanced-training"
	checkpoint_filename: "balanced_alm_finetune.ckpt"

	# Augmented-Lagrangian Method (ALM) for GC content control
	alm:
	enabled: true
	gc_target: 0.52 # Target GC content for E. coli (52%)
	curriculum_epochs: 3 # Warm-up epochs before enforcing GC constraint

	# ALM penalty parameters
	initial_penalty_factor: 20.0
	penalty_update_factor: 10.0
	max_penalty: 1e6
	min_penalty: 1e-6

	# ALM tolerance parameters
	tolerance: 1e-5 # Primal tolerance
	dual_tolerance: 1e-5 # Dual tolerance for constraint violation
	tolerance_update_factor: 0.1

	# Adaptive penalty adjustment
	rel_penalty_increase_threshold: 0.1

	# Legacy penalty method (if ALM disabled)
	gc_penalty:
	weight: 0.0 # Only used if use_lagrangian=false
	</code></pre>
	</div>

	<!-- Section 7: Data Preparation -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">7</span>
	Data Preparation & Validation
	</h2>
	<div class="description">
	Functions for validating and preparing E. coli gene sequences for training, including sequence validation checks.
	</div>
	<div class="file-info">
	<div class="file-path">📄 prepare_ecoli_data.py</div>
	<div class="line-range">Lines 5-30 \| Validation function</div>
	</div>
	<div class="key-feature">
	<strong>🎯 Highlight:</strong> Sequence validation rules (start/stop codons, frame, no internal stops)
	</div>
	<pre><code class="language-python">def is_valid_sequence(dna_seq: str) -> bool:
	"""
	Applies a series of validation checks to a DNA sequence.

	Args:
	dna_seq (str): The DNA sequence to validate.

	Returns:
	bool: True if the sequence is valid, False otherwise.
	"""
	# Check if length is divisible by 3 (valid codon frame)
	if len(dna_seq) % 3 != 0:
	return False

	# Check for valid start codon
	if not dna_seq.upper().startswith(('ATG', 'TTG', 'CTG', 'GTG')):
	return False

	# Check for valid stop codon
	if not dna_seq.upper().endswith(('TAA', 'TAG', 'TGA')):
	return False

	# Check for internal stop codons (excluding the last codon)
	codons = [dna_seq[i:i+3].upper() for i in range(0, len(dna_seq) - 3, 3)]
	if any(codon in ['TAA', 'TAG', 'TGA'] for codon in codons):
	return False

	# Check if sequence contains only valid nucleotides
	if not all(c in 'ATGC' for c in dna_seq.upper()):
	return False

	return True
	</code></pre>
	</div>

	<!-- Section 8: Streamlit GUI -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">8</span>
	Streamlit GUI - Main Interface
	</h2>
	<div class="description">
	Web-based graphical interface for ENCOT built with Streamlit, providing user-friendly access to optimization features.
	</div>
	<div class="file-info">
	<div class="file-path">📄 streamlit_gui/app.py</div>
	<div class="line-range">Lines 625-640 \| Main function</div>
	</div>
	<div class="key-feature">
	<strong>🎯 Highlight:</strong> Streamlit app structure with tabs and model loading
	</div>
	<pre><code class="language-python">def main():
	st.title("ENCOT")
	st.markdown("E. coli codon optimization with constraint-aware decoding and in silico evaluation metrics.")

	# Load model
	load_model_and_tokenizer()

	# Create the main tabbed interface
	tab1, tab2, tab3, tab4 = st.tabs([
	"Single Optimize",
	"Batch Process",
	"Comparative Analysis",
	"Advanced Settings"
	])

	with tab1:
	single_sequence_optimization()

	with tab2:
	batch_processing()

	with tab3:
	comparative_analysis()

	with tab4:
	advanced_settings()

	# Footer
	st.markdown("---")
	st.markdown("ENCOT")
	st.markdown("Open-source codon optimization for E. coli with reproducible evaluation.")
	</code></pre>
	</div>

	<!-- Section 9: Benchmark Evaluation -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">9</span>
	Benchmark Evaluation Pipeline
	</h2>
	<div class="description">
	Comprehensive benchmarking pipeline for evaluating ENCOT performance on test sequences with multiple metrics.
	</div>
	<div class="file-info">
	<div class="file-path">📄 benchmark_evaluation.py</div>
	<div class="line-range">Lines 300-400 \| Benchmark function</div>
	</div>
	<div class="key-feature">
	<strong>🎯 Highlight:</strong> Multi-metric evaluation (CAI, tAI, GC, cis-elements)
	</div>
	<pre><code class="language-python">def benchmark_sequences(sequences, model, tokenizer, device, cai_weights, tai_weights):
	"""
	Run ENCOT on protein sequences and compute metrics for optimized DNA.

	Args:
	sequences: List of protein sequences to optimize
	model: Loaded ENCOT model
	tokenizer: Tokenizer for the model
	device: PyTorch device (CPU/GPU)
	cai_weights: Pre-computed CAI weights
	tai_weights: Pre-computed tAI weights

	Returns:
	DataFrame with optimization results and metrics
	"""
	results = []

	for name, protein in tqdm(sequences, desc="Optimizing sequences"):
	# Optimize the sequence
	output = predict_dna_sequence(
	protein=protein,
	organism="Escherichia coli general",
	device=device,
	model=model,
	tokenizer=tokenizer,
	deterministic=True,
	use_constrained_search=True,
	gc_bounds=(0.45, 0.55)
	)

	optimized_dna = output.predicted_dna

	# Calculate metrics
	cai = get_CSI_value(optimized_dna, cai_weights)
	tai = calculate_tAI(optimized_dna, tai_weights)
	gc_content = get_GC_content(optimized_dna)
	cis_elements = count_negative_cis_elements(optimized_dna)

	results.append({
	'name': name,
	'protein': protein,
	'optimized_dna': optimized_dna,
	'CAI': cai,
	'tAI': tai,
	'GC_content': gc_content,
	'negative_cis_elements': cis_elements
	})

	return pd.DataFrame(results)
	</code></pre>
	</div>

	<!-- Section 10: Project Structure -->
	<div class="section">
	<h2 class="section-title">
	<span class="section-number">10</span>
	Project Overview & Architecture
	</h2>
	<div class="description">
	Complete project structure showing the organization of modules, scripts, and configuration files.
	</div>
	<div class="key-feature">
	<strong>🎯 Key Components:</strong> Training (finetune.py), Inference (CodonPrediction.py),
	Evaluation (CodonEvaluation.py), GUI (streamlit_gui/), Configs (configs/)
	</div>
	<pre><code class="language-plaintext">ENCOT/
	├── CodonTransformer/ # Core library modules
	│ ├── CodonPrediction.py # Model loading & DNA sequence prediction
	│ ├── CodonEvaluation.py # Metrics (CAI, tAI, GC, CFD, etc.)
	│ ├── CodonData.py # Data preprocessing & preparation
	│ ├── CodonUtils.py # Constants, mappings, utilities
	│ └── CodonPostProcessing.py # DNA-Chisel integration
	│
	├── scripts/ # Command-line tools
	│ ├── train.py # Training wrapper
	│ ├── optimize_sequence.py # Sequence optimization CLI
	│ ├── run_benchmarks.py # Benchmark evaluation
	│ └── preprocess_data.py # Data preparation
	│
	├── configs/ # YAML configurations
	│ ├── train_ecoli_alm.yaml # Main ALM training config ⭐
	│ └── train_ecoli_quick.yaml # Quick test config
	│
	├── streamlit_gui/ # Web interface
	│ ├── app.py # Main Streamlit GUI ⭐
	│ ├── demo.py # Demo script
	│ └── run_gui.py # Launcher
	│
	├── data/ # Datasets
	│ ├── finetune_set.json # Training data
	│ └── test_set.json # Test data
	│
	├── finetune.py # Main training script ⭐⭐⭐
	├── benchmark_evaluation.py # Evaluation script
	├── setup.py # Package setup
	├── pyproject.toml # Project configuration
	└── README.md # Documentation

	Key Innovations:
	⭐⭐⭐ Augmented-Lagrangian Method (ALM) for GC control
	⭐⭐ Constrained beam search with GC bounds
	⭐ Multi-metric evaluation (CAI, tAI, GC, cis-elements)
	</code></pre>
	</div>

	<div class="footer">
	<h3>ENCOT - Enhanced Codon Optimization Tool</h3>
	<p>Repository: <a href="https://github.com/geno543/ENCOT" style="color: #58a6ff;">github.com/geno543/ENCOT</a></p>
	<p>© 2026 \| Apache License 2.0</p>
	</div>

	<script>
	// Initialize syntax highlighting
	hljs.highlightAll();

	// Add line numbers
	document.querySelectorAll('pre code').forEach((block) => {
	const lines = block.innerHTML.split('\n');
	const numberedLines = lines.map((line, index) => {
	return `<span class="line-number" style="color: #6e7681; user-select: none; margin-right: 1em;">${String(index + 1).padStart(3, ' ')}</span>${line}`;
	}).join('\n');
	block.innerHTML = numberedLines;
	});
	</script>
	</body>
	</html>