langtune 0.1.19__py3-none-any.whl

langtune/training/neftune.py

@@ -0,0 +1,80 @@
+"""
+NEFTune: Noisy Embeddings for Instruction Fine-tuning.
+Adds uniform noise to the embedding inputs during training to improve generalization.
+"""
+
+import math
+import torch
+from torch import nn
+from typing import Optional, List, Dict, Any, Union
+from transformers import TrainerCallback, TrainingArguments, TrainerState, TrainerControl
+
+class NEFTuneCallback(TrainerCallback):
+    """
+    Callback for adding uniform noise to embeddings during training (NEFTune).
+    Reference: https://arxiv.org/abs/2310.05914
+    """
+
+    def __init__(self, noise_alpha: float = 5.0):
+        self.noise_alpha = noise_alpha
+        self.hooks = []
+
+    def on_train_begin(self, args, state, control, model=None, **kwargs):
+        """
+        Attach forward hooks to the embedding layer(s) of the model.
+        """
+        print(f"🔊 Enabling NEFTune with alpha={self.noise_alpha}")
+        
+        # Identify embedding layers
+        # Common HF models: model.embed_tokens, transformer.wte, etc.
+        forward_hook = self._get_neftune_hook()
+        
+        if hasattr(model, "get_input_embeddings"):
+            embeddings = model.get_input_embeddings()
+            if embeddings:
+                self.hooks.append(embeddings.register_forward_hook(forward_hook))
+                return
+
+        # Fallback recursive search if get_input_embeddings is not standard
+        for name, module in model.named_modules():
+            if isinstance(module, nn.Embedding):
+                self.hooks.append(module.register_forward_hook(forward_hook))
+                
+    def on_train_end(self, args, state, control, **kwargs):
+        """Remove hooks after training."""
+        for hook in self.hooks:
+            hook.remove()
+        self.hooks = []
+        print("🔊 Disabled NEFTune hooks")
+
+    def _get_neftune_hook(self):
+        """
+        Returns a forward hook that adds noise.
+        """
+        def hook(module, args, output):
+            # args[0] is usually input_ids, output is embeddings
+            if module.training:
+                # noise ~ Uniform(-1, 1) * alpha / sqrt(sequence_length * hidden_dim)
+                dims = torch.tensor(output.size(1) * output.size(2))
+                mag_norm = self.noise_alpha / torch.sqrt(dims)
+                noise = torch.zeros_like(output).uniform_(-mag_norm, mag_norm)
+                return output + noise
+            return output
+            
+        return hook
+
+def activate_neftune(model: nn.Module, noise_alpha: float = 5.0):
+    """
+    Directly activate NEFTune on a model without using a callback (manual loop).
+    """
+    embeddings = model.get_input_embeddings()
+    
+    def neftune_forward(module, input, output):
+        if module.training:
+            dims = torch.tensor(output.size(1) * output.size(2))
+            mag_norm = noise_alpha / torch.sqrt(dims)
+            output = output + torch.zeros_like(output).uniform_(-mag_norm, mag_norm)
+        return output
+
+    embeddings.register_forward_hook(neftune_forward)
+    print(f"🔊 NEFTune activated manually (alpha={noise_alpha})")

langtune/utils.py

@@ -0,0 +1,337 @@
+"""
+utils.py: Utility functions for Langtune
+"""
+
+import torch
+import numpy as np
+import random
+import logging
+from typing import List, Dict, Any, Optional, Union
+import json
+import os
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+def set_seed(seed: int = 42):
+    """Set random seeds for reproducibility."""
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+    logger.info(f"Random seed set to {seed}")
+
+def get_device(device: str = "auto") -> torch.device:
+    """Get the appropriate device for computation."""
+    if device == "auto":
+        if torch.cuda.is_available():
+            device = "cuda"
+        elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+            device = "mps"
+        else:
+            device = "cpu"
+    
+    return torch.device(device)
+
+def count_parameters(model: torch.nn.Module) -> int:
+    """Count the number of trainable parameters in a model."""
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+def count_lora_parameters(model: torch.nn.Module) -> int:
+    """Count the number of LoRA parameters in a model."""
+    lora_params = 0
+    for name, param in model.named_parameters():
+        if 'lora' in name.lower() and param.requires_grad:
+            lora_params += param.numel()
+    return lora_params
+
+def save_model_info(model: torch.nn.Module, save_path: str):
+    """Save model information to a JSON file."""
+    info = {
+        "total_parameters": count_parameters(model),
+        "lora_parameters": count_lora_parameters(model),
+        "model_class": model.__class__.__name__,
+        "model_config": getattr(model, 'config', None)
+    }
+    
+    with open(save_path, 'w') as f:
+        json.dump(info, f, indent=2)
+    
+    logger.info(f"Model info saved to {save_path}")
+
+def load_model_info(load_path: str) -> Dict[str, Any]:
+    """Load model information from a JSON file."""
+    with open(load_path, 'r') as f:
+        info = json.load(f)
+    return info
+
+def encode_text(text: str, tokenizer=None) -> List[int]:
+    """
+    Encodes text into token IDs using the provided tokenizer.
+    If no tokenizer is given, uses character-level encoding as fallback.
+    """
+    if tokenizer:
+        if hasattr(tokenizer, 'encode'):
+            return tokenizer.encode(text)
+        elif callable(tokenizer):
+            return tokenizer(text)
+        else:
+            raise ValueError("Invalid tokenizer provided")
+    
+    # Fallback to character-level encoding
+    return [ord(c) for c in text]
+
+def decode_tokens(token_ids: List[int], tokenizer=None) -> str:
+    """
+    Decodes a list of token IDs back into a string.
+    """
+    if tokenizer:
+        if hasattr(tokenizer, 'decode'):
+            return tokenizer.decode(token_ids)
+        elif callable(tokenizer):
+            return tokenizer(token_ids)
+        else:
+            raise ValueError("Invalid tokenizer provided")
+    
+    # Fallback to character-level decoding
+    return ''.join([chr(i) for i in token_ids if i > 0])
+
+class SimpleTokenizer:
+    """
+    A simple character-level tokenizer for demonstration purposes.
+    """
+    
+    def __init__(self, vocab_size: int = 32000):
+        self.vocab_size = vocab_size
+        self.pad_token_id = 0
+        self.unk_token_id = 1
+        self.bos_token_id = 2
+        self.eos_token_id = 3
+        
+        # Create a simple vocabulary
+        self.vocab = {
+            "<pad>": self.pad_token_id,
+            "<unk>": self.unk_token_id,
+            "<bos>": self.bos_token_id,
+            "<eos>": self.eos_token_id
+        }
+        
+        # Add common characters
+        for i, char in enumerate("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 .,!?;:'\"()[]{}"):
+            if len(self.vocab) < vocab_size:
+                self.vocab[char] = len(self.vocab)
+        
+        # Create reverse vocabulary
+        self.id_to_token = {v: k for k, v in self.vocab.items()}
+    
+    def encode(self, text: str, add_special_tokens: bool = True) -> List[int]:
+        """Encode text to token IDs."""
+        tokens = []
+        
+        if add_special_tokens:
+            tokens.append(self.bos_token_id)
+        
+        for char in text:
+            if char in self.vocab:
+                tokens.append(self.vocab[char])
+            else:
+                tokens.append(self.unk_token_id)
+        
+        if add_special_tokens:
+            tokens.append(self.eos_token_id)
+        
+        return tokens
+    
+    def decode(self, token_ids: List[int], skip_special_tokens: bool = True) -> str:
+        """Decode token IDs to text."""
+        tokens = []
+        
+        for token_id in token_ids:
+            if token_id in self.id_to_token:
+                token = self.id_to_token[token_id]
+                if skip_special_tokens and token.startswith("<"):
+                    continue
+                tokens.append(token)
+        
+        return "".join(tokens)
+    
+    def __call__(self, text: str, **kwargs) -> Dict[str, List[int]]:
+        """Callable interface for compatibility."""
+        token_ids = self.encode(text, **kwargs)
+        return {"input_ids": token_ids}
+
+def create_attention_mask(input_ids: torch.Tensor, pad_token_id: int = 0) -> torch.Tensor:
+    """Create attention mask from input IDs."""
+    return (input_ids != pad_token_id).long()
+
+def pad_sequences(sequences: List[torch.Tensor], pad_token_id: int = 0, max_length: Optional[int] = None) -> torch.Tensor:
+    """Pad sequences to the same length."""
+    if max_length is None:
+        max_length = max(seq.size(0) for seq in sequences)
+    
+    padded_sequences = []
+    for seq in sequences:
+        if seq.size(0) < max_length:
+            padding = torch.full((max_length - seq.size(0),), pad_token_id, dtype=seq.dtype)
+            padded_seq = torch.cat([seq, padding])
+        else:
+            padded_seq = seq[:max_length]
+        padded_sequences.append(padded_seq)
+    
+    return torch.stack(padded_sequences)
+
+def truncate_sequences(sequences: List[torch.Tensor], max_length: int) -> List[torch.Tensor]:
+    """Truncate sequences to maximum length."""
+    return [seq[:max_length] for seq in sequences]
+
+def compute_perplexity(loss: float) -> float:
+    """Compute perplexity from cross-entropy loss."""
+    return np.exp(loss)
+
+def compute_bleu_score(predictions: List[str], references: List[str]) -> float:
+    """Compute BLEU score (simplified implementation)."""
+    # This is a very simplified BLEU implementation
+    # In practice, you'd use a proper BLEU implementation like nltk.translate.bleu_score
+    
+    def get_ngrams(text: str, n: int) -> set:
+        words = text.split()
+        return set(tuple(words[i:i+n]) for i in range(len(words)-n+1))
+    
+    total_score = 0.0
+    for pred, ref in zip(predictions, references):
+        pred_ngrams = get_ngrams(pred, 1)  # Using unigrams for simplicity
+        ref_ngrams = get_ngrams(ref, 1)
+        
+        if len(pred_ngrams) == 0:
+            score = 0.0
+        else:
+            overlap = len(pred_ngrams.intersection(ref_ngrams))
+            score = overlap / len(pred_ngrams)
+        
+        total_score += score
+    
+    return total_score / len(predictions)
+
+def format_time(seconds: float) -> str:
+    """Format time in a human-readable format."""
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    elif seconds < 3600:
+        minutes = seconds / 60
+        return f"{minutes:.1f}m"
+    else:
+        hours = seconds / 3600
+        return f"{hours:.1f}h"
+
+def format_size(size_bytes: int) -> str:
+    """Format size in a human-readable format."""
+    if size_bytes < 1024:
+        return f"{size_bytes}B"
+    elif size_bytes < 1024**2:
+        return f"{size_bytes/1024:.1f}KB"
+    elif size_bytes < 1024**3:
+        return f"{size_bytes/(1024**2):.1f}MB"
+    else:
+        return f"{size_bytes/(1024**3):.1f}GB"
+
+def create_directory_structure(base_dir: str, subdirs: List[str]):
+    """Create a directory structure."""
+    base_path = Path(base_dir)
+    base_path.mkdir(parents=True, exist_ok=True)
+    
+    for subdir in subdirs:
+        (base_path / subdir).mkdir(parents=True, exist_ok=True)
+    
+    logger.info(f"Created directory structure: {base_dir}")
+
+def save_json(data: Dict[str, Any], file_path: str):
+    """Save data to a JSON file."""
+    with open(file_path, 'w') as f:
+        json.dump(data, f, indent=2)
+    logger.info(f"Data saved to {file_path}")
+
+def load_json(file_path: str) -> Dict[str, Any]:
+    """Load data from a JSON file."""
+    with open(file_path, 'r') as f:
+        data = json.load(f)
+    logger.info(f"Data loaded from {file_path}")
+    return data
+
+def get_model_size(model: torch.nn.Module) -> Dict[str, Any]:
+    """Get model size information."""
+    total_params = count_parameters(model)
+    lora_params = count_lora_parameters(model)
+    
+    # Estimate memory usage (rough approximation)
+    param_size = sum(p.numel() * p.element_size() for p in model.parameters())
+    buffer_size = sum(b.numel() * b.element_size() for b in model.buffers())
+    model_size = param_size + buffer_size
+    
+    return {
+        "total_parameters": total_params,
+        "lora_parameters": lora_params,
+        "regular_parameters": total_params - lora_params,
+        "model_size_bytes": model_size,
+        "model_size_mb": model_size / (1024**2),
+        "lora_ratio": lora_params / total_params if total_params > 0 else 0
+    }
+
+def print_model_summary(model: torch.nn.Module):
+    """Print a summary of the model."""
+    size_info = get_model_size(model)
+    
+    print("=" * 50)
+    print("MODEL SUMMARY")
+    print("=" * 50)
+    print(f"Total parameters: {size_info['total_parameters']:,}")
+    print(f"LoRA parameters: {size_info['lora_parameters']:,}")
+    print(f"Regular parameters: {size_info['regular_parameters']:,}")
+    print(f"LoRA ratio: {size_info['lora_ratio']:.2%}")
+    print(f"Model size: {format_size(size_info['model_size_bytes'])}")
+    print("=" * 50)
+
+def warmup_lr_scheduler(optimizer, warmup_steps: int, total_steps: int, base_lr: float, max_lr: float):
+    """Create a learning rate scheduler with warmup."""
+    def lr_lambda(current_step):
+        if current_step < warmup_steps:
+            return float(current_step) / float(max(1, warmup_steps))
+        return max(0.0, float(total_steps - current_step) / float(max(1, total_steps - warmup_steps)))
+    
+    return torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
+
+def gradient_accumulation_steps(batch_size: int, effective_batch_size: int) -> int:
+    """Calculate gradient accumulation steps."""
+    if batch_size >= effective_batch_size:
+        return 1
+    
+    steps = effective_batch_size // batch_size
+    if effective_batch_size % batch_size != 0:
+        steps += 1
+    
+    return steps
+
+def log_gpu_memory():
+    """Log GPU memory usage if available."""
+    if torch.cuda.is_available():
+        allocated = torch.cuda.memory_allocated() / 1024**3  # GB
+        reserved = torch.cuda.memory_reserved() / 1024**3   # GB
+        logger.info(f"GPU Memory - Allocated: {allocated:.2f}GB, Reserved: {reserved:.2f}GB")
+
+def cleanup_gpu_memory():
+    """Clean up GPU memory."""
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        logger.info("GPU memory cleaned up")
+
+# Backward compatibility
+def encode_text_legacy(text, tokenizer=None):
+    """Legacy function for backward compatibility."""
+    logger.warning("encode_text_legacy is deprecated. Use encode_text instead.")
+    return encode_text(text, tokenizer)
+
+def decode_tokens_legacy(token_ids):
+    """Legacy function for backward compatibility."""
+    logger.warning("decode_tokens_legacy is deprecated. Use decode_tokens instead.")
+    return decode_tokens(token_ids) 

langtune-0.1.19.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: langtune
+Version: 0.1.19
+Summary: Efficient LoRA Fine-Tuning for Large Language Models - Train smarter, not harder.
+Author-email: Pritesh Raj <priteshraj41@gmail.com>
+Maintainer-email: Langtrain AI <contact@langtrain.ai>
+License: MIT License
+        
+        Copyright (c) 2025 Pritesh Raj
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/langtrain-ai/langtune
+Project-URL: Documentation, https://github.com/langtrain-ai/langtune/tree/main/docs
+Project-URL: Repository, https://github.com/langtrain-ai/langtune
+Project-URL: Changelog, https://github.com/langtrain-ai/langtune/blob/main/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/langtrain-ai/langtune/issues
+Keywords: llm,lora,fine-tuning,machine-learning,deep-learning,transformers,nlp,language-model,pytorch,rlhf,dpo,ppo
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=1.10
+Requires-Dist: numpy
+Requires-Dist: tqdm
+Requires-Dist: pyyaml
+Requires-Dist: scipy
+Requires-Dist: wandb
+Requires-Dist: rich>=13.0.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Provides-Extra: all
+Requires-Dist: transformers; extra == "all"
+Requires-Dist: datasets; extra == "all"
+Requires-Dist: accelerate; extra == "all"
+Requires-Dist: bitsandbytes; extra == "all"
+Dynamic: license-file
+
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/langtrain-ai/langtune/main/static/langtune-white.png" alt="Langtune" width="400" />
+
+<h3>The fastest way to fine-tune LLMs</h3>
+
+<p>
+  <strong>Production-ready LoRA fine-tuning in minutes, not days.</strong><br>
+  Built for ML engineers who need results, not complexity.
+</p>
+
+<p>
+  <a href="https://www.producthunt.com/products/langtrain-2" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/featured.svg?post_id=1049974&theme=light" alt="Product Hunt" width="200" /></a>
+</p>
+
+<p>
+  <a href="https://pypi.org/project/langtune/"><img src="https://img.shields.io/pypi/v/langtune.svg?style=for-the-badge&logo=pypi&logoColor=white" alt="PyPI" /></a>
+  <a href="https://pepy.tech/project/langtune"><img src="https://img.shields.io/pepy/dt/langtune?style=for-the-badge&logo=python&logoColor=white&label=downloads" alt="Downloads" /></a>
+  <a href="https://github.com/langtrain-ai/langtune/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue?style=for-the-badge" alt="License" /></a>
+</p>
+
+<p>
+  <a href="#quick-start">Quick Start</a> •
+  <a href="#features">Features</a> •
+  <a href="#why-langtune">Why Langtune</a> •
+  <a href="https://langtrain.xyz/docs">Docs</a>
+</p>
+
+</div>
+
+---
+
+## ⚡ Quick Start
+
+```bash
+pip install langtune
+```
+
+Fine-tune your first model in **3 lines of code**:
+
+```python
+from langtune import LoRATrainer
+
+trainer = LoRATrainer(model_name="meta-llama/Llama-2-7b-hf")
+trainer.train_from_file("data.jsonl")
+```
+
+That's it. Your fine-tuned model is ready.
+
+---
+
+## ✨ Features
+
+<table>
+<tr>
+<td width="50%">
+
+### 🚀 **Blazing Fast**
+Train 7B models in under 30 minutes on a single GPU. Our optimized kernels squeeze every last FLOP.
+
+### 🎯 **Zero Config Required**
+Smart defaults that just work. No PhD required. Start training in seconds.
+
+### 💾 **Memory Efficient**
+4-bit quantization + gradient checkpointing = Train 70B models on consumer hardware.
+
+</td>
+<td width="50%">
+
+### 🔧 **Production Ready**
+Battle-tested at scale. Used by teams fine-tuning thousands of models daily.
+
+### 🌐 **Any Model, Any Data**
+Works with Llama, Mistral, Qwen, Phi, and more. JSONL, CSV, or HuggingFace datasets.
+
+### ☁️ **Cloud Native**
+One-click deployment to Langtrain Cloud. Or export to GGUF, ONNX, HuggingFace.
+
+</td>
+</tr>
+</table>
+
+---
+
+## 🎯 Why Langtune?
+
+| | Langtune | Others |
+|---|:---:|:---:|
+| **Time to first training** | 30 seconds | 2+ hours |
+| **Lines of code** | 3 | 100+ |
+| **Memory usage** | 8GB | 24GB+ |
+| **Learning curve** | Minutes | Days |
+
+---
+
+## 📖 Full Example
+
+```python
+from langtune import LoRATrainer
+from langtune.config import TrainingConfig, LoRAConfig
+
+# Configure your training
+config = TrainingConfig(
+    num_epochs=3,
+    batch_size=4,
+    learning_rate=2e-4,
+    lora=LoRAConfig(rank=16, alpha=32)
+)
+
+# Initialize and train
+trainer = LoRATrainer(
+    model_name="mistralai/Mistral-7B-v0.1",
+    output_dir="./my-model",
+    config=config
+)
+
+# Train on your data
+trainer.train_from_file("training_data.jsonl")
+
+# Push to Hub (optional)
+trainer.push_to_hub("my-username/my-fine-tuned-model")
+```
+
+---
+
+## 🛠️ Advanced Usage
+
+<details>
+<summary><b>Custom Dataset Format</b></summary>
+
+```python
+# JSONL format (recommended)
+{"text": "Your training example here"}
+{"text": "Another example"}
+
+# Or instruction format
+{"instruction": "Summarize this:", "input": "Long text...", "output": "Summary"}
+```
+
+</details>
+
+<details>
+<summary><b>Distributed Training</b></summary>
+
+```python
+trainer = LoRATrainer(
+    model_name="meta-llama/Llama-2-70b-hf",
+    device_map="auto",  # Automatic multi-GPU
+)
+```
+
+</details>
+
+<details>
+<summary><b>Export Formats</b></summary>
+
+```python
+# Export to different formats
+trainer.export("gguf")  # For llama.cpp
+trainer.export("onnx")  # For ONNX Runtime
+trainer.export("hf")    # HuggingFace format
+```
+
+</details>
+
+---
+
+## 🤝 Community
+
+<p align="center">
+  <a href="https://discord.gg/langtrain">Discord</a> •
+  <a href="https://twitter.com/langtrainai">Twitter</a> •
+  <a href="https://langtrain.xyz">Website</a>
+</p>
+
+---
+
+<div align="center">
+
+**Built with ❤️ by [Langtrain AI](https://langtrain.xyz)**
+
+*Making LLM fine-tuning accessible to everyone.*
+
+</div>