Upload 9 files

README (1).md

@@ -0,0 +1,16 @@
+---
+license: apache-2.0
+datasets:
+- openai/mrcr
+language:
+- ar
+metrics:
+- chrf
+base_model:
+- Qwen/Qwen3-235B-A22B
+new_version: Qwen/Qwen3-235B-A22B
+pipeline_tag: text-classification
+library_name: espnet
+tags:
+- legal
+---

Requirements.txt

@@ -0,0 +1,5 @@
+transformers>=4.30.0
+datasets>=2.12.0
+evaluate>=0.4.0
+accelerate>=0.20.0
+torch>=2.0.0

__init__.py

@@ -0,0 +1,5 @@
+from .configuration_octagon import *
+from .modeling_octagon import *
+from .tokenization_octagon import *
+
+__version__ = "0.1.0"

app.py

@@ -0,0 +1,18 @@
+from transformers import pipeline
+import gradio as gr
+
+# Load model
+classifier = pipeline("text-classification", model="your-username/octagon")
+
+def predict(text):
+    return classifier(text)
+
+iface = gr.Interface(
+    fn=predict,
+    inputs=gr.Textbox(lines=2, placeholder="Enter text here..."),
+    outputs="label",
+    title="Octagon Text Classification",
+    description="A demo for the Octagon model trained on IMDB reviews."
+)
+
+iface.launch()

configuration_octagon.py

@@ -0,0 +1,3 @@
+from .modeling_octagon import OctagonConfig
+
+__all__ = ['OctagonConfig']

gitattributes.txt

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

modeling_octagon.py

@@ -0,0 +1,241 @@
+from transformers import PretrainedConfig, PreTrainedModel
+from torch import nn
+import torch
+
+class OctagonConfig(PretrainedConfig):
+    model_type = "octagon"
+    
+    def __init__(
+        self,
+        vocab_size=30522,
+        hidden_size=768,
+        num_hidden_layers=8,  # Octagon has 8 sides!
+        num_attention_heads=8,
+        intermediate_size=3072,
+        hidden_act="gelu",
+        hidden_dropout_prob=0.1,
+        attention_probs_dropout_prob=0.1,
+        max_position_embeddings=512,
+        type_vocab_size=2,
+        initializer_range=0.02,
+        layer_norm_eps=1e-12,
+        pad_token_id=0,
+        position_embedding_type="absolute",
+        classifier_dropout=None,
+        num_labels=2,
+        **kwargs
+    ):
+        super().__init__(pad_token_id=pad_token_id, **kwargs)
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.intermediate_size = intermediate_size
+        self.hidden_act = hidden_act
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.max_position_embeddings = max_position_embeddings
+        self.type_vocab_size = type_vocab_size
+        self.initializer_range = initializer_range
+        self.layer_norm_eps = layer_norm_eps
+        self.position_embedding_type = position_embedding_type
+        self.classifier_dropout = classifier_dropout
+        self.num_labels = num_labels
+
+class OctagonEmbeddings(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size)
+        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+        self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
+        
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        
+        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
+
+    def forward(self, input_ids=None, token_type_ids=None, position_ids=None):
+        seq_length = input_ids.size(1)
+        
+        if position_ids is None:
+            position_ids = self.position_ids[:, :seq_length]
+        
+        if token_type_ids is None:
+            token_type_ids = torch.zeros_like(input_ids)
+            
+        word_embeddings = self.word_embeddings(input_ids)
+        position_embeddings = self.position_embeddings(position_ids)
+        token_type_embeddings = self.token_type_embeddings(token_type_ids)
+        
+        embeddings = word_embeddings + position_embeddings + token_type_embeddings
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+        return embeddings
+
+class OctagonSelfAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+        
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+        
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        
+    def transpose_for_scores(self, x):
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(*new_x_shape)
+        return x.permute(0, 2, 1, 3)
+    
+    def forward(self, hidden_states):
+        query_layer = self.transpose_for_scores(self.query(hidden_states))
+        key_layer = self.transpose_for_scores(self.key(hidden_states))
+        value_layer = self.transpose_for_scores(self.value(hidden_states))
+        
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+        attention_probs = self.dropout(attention_probs)
+        
+        context_layer = torch.matmul(attention_probs, value_layer)
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(*new_context_layer_shape)
+        return context_layer
+
+class OctagonSelfOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+class OctagonAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.self = OctagonSelfAttention(config)
+        self.output = OctagonSelfOutput(config)
+    
+    def forward(self, hidden_states):
+        self_outputs = self.self(hidden_states)
+        attention_output = self.output(self_outputs, hidden_states)
+        return attention_output
+
+class OctagonIntermediate(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+        self.intermediate_act_fn = nn.GELU()
+    
+    def forward(self, hidden_states):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        return hidden_states
+
+class OctagonOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+class OctagonLayer(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.attention = OctagonAttention(config)
+        self.intermediate = OctagonIntermediate(config)
+        self.output = OctagonOutput(config)
+    
+    def forward(self, hidden_states):
+        attention_output = self.attention(hidden_states)
+        intermediate_output = self.intermediate(attention_output)
+        layer_output = self.output(intermediate_output, attention_output)
+        return layer_output
+
+class OctagonEncoder(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.layer = nn.ModuleList([OctagonLayer(config) for _ in range(config.num_hidden_layers)])
+    
+    def forward(self, hidden_states):
+        for layer_module in self.layer:
+            hidden_states = layer_module(hidden_states)
+        return hidden_states
+
+class OctagonModel(PreTrainedModel):
+    config_class = OctagonConfig
+    
+    def __init__(self, config):
+        super().__init__(config)
+        self.config = config
+        self.embeddings = OctagonEmbeddings(config)
+        self.encoder = OctagonEncoder(config)
+        self.pooler = nn.Linear(config.hidden_size, config.hidden_size)
+        self.tanh = nn.Tanh()
+        
+        self.post_init()
+    
+    def forward(self, input_ids=None, token_type_ids=None, position_ids=None):
+        if input_ids is not None:
+            input_shape = input_ids.size()
+        else:
+            raise ValueError("You have to specify input_ids")
+        
+        embedding_output = self.embeddings(
+            input_ids=input_ids,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids
+        )
+        
+        encoder_outputs = self.encoder(embedding_output)
+        pooled_output = self.pooler(encoder_outputs[:, 0])
+        pooled_output = self.tanh(pooled_output)
+        
+        return encoder_outputs, pooled_output
+
+class OctagonForSequenceClassification(PreTrainedModel):
+    config_class = OctagonConfig
+    
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.octagon = OctagonModel(config)
+        classifier_dropout = (
+            config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
+        )
+        self.dropout = nn.Dropout(classifier_dropout)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+        
+        self.post_init()
+    
+    def forward(self, input_ids=None, token_type_ids=None, position_ids=None, labels=None):
+        _, pooled_output = self.octagon(
+            input_ids=input_ids,
+            token_type_ids=token_type_ids,
+            position_ids=position_ids
+        )
+        
+        pooled_output = self.dropout(pooled_output)
+        logits = self.classifier(pooled_output)
+        
+        loss = None
+        if labels is not None:
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+        
+        return {"loss": loss, "logits": logits}

tokenization_octagon.py

@@ -0,0 +1,54 @@
+from transformers import PreTrainedTokenizerFast
+from tokenizers import Tokenizer, normalizers, pre_tokenizers, trainers, models
+from tokenizers.normalizers import Lowercase, NFD, StripAccents
+from tokenizers.pre_tokenizers import Whitespace
+from typing import Optional, List, Union
+
+class OctagonTokenizer(PreTrainedTokenizerFast):
+    def __init__(
+        self,
+        vocab_file=None,
+        merges_file=None,
+        tokenizer_file=None,
+        unk_token="[UNK]",
+        sep_token="[SEP]",
+        pad_token="[PAD]",
+        cls_token="[CLS]",
+        mask_token="[MASK]",
+        **kwargs
+    ):
+        super().__init__(
+            tokenizer_file=tokenizer_file,
+            unk_token=unk_token,
+            sep_token=sep_token,
+            pad_token=pad_token,
+            cls_token=cls_token,
+            mask_token=mask_token,
+            **kwargs
+        )
+    
+    @classmethod
+    def train_tokenizer(cls, texts: List[str], vocab_size: int = 30522, save_path: Optional[str] = None):
+        # Initialize a tokenizer
+        tokenizer = Tokenizer(models.BPE())
+        
+        # Normalizer
+        tokenizer.normalizer = normalizers.Sequence([NFD(), Lowercase(), StripAccents()])
+        
+        # Pre-tokenizer
+        tokenizer.pre_tokenizer = pre_tokenizers.Whitespace()
+        
+        # Trainer
+        trainer = trainers.BpeTrainer(
+            vocab_size=vocab_size,
+            special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"]
+        )
+        
+        # Train the tokenizer
+        tokenizer.train_from_iterator(texts, trainer=trainer)
+        
+        # Save if path is provided
+        if save_path:
+            tokenizer.save(save_path)
+        
+        return cls(tokenizer_file=save_path) if save_path else cls(tokenizer_object=tokenizer)

train.py

@@ -0,0 +1,76 @@
+from transformers import TrainingArguments, Trainer
+from datasets import load_dataset
+import evaluate
+import numpy as np
+from modeling_octagon import OctagonForSequenceClassification, OctagonConfig
+from tokenization_octagon import OctagonTokenizer
+
+# Load dataset
+dataset = load_dataset("imdb")
+
+# Sample training (for demo purposes, use smaller subset)
+train_dataset = dataset["train"].shuffle(seed=42).select(range(1000))
+eval_dataset = dataset["test"].shuffle(seed=42).select(range(200))
+
+# Initialize tokenizer
+tokenizer = OctagonTokenizer.train_tokenizer(
+    texts=train_dataset["text"],
+    vocab_size=30522,
+    save_path="octagon-tokenizer.json"
+)
+
+# Tokenize function
+def tokenize_function(examples):
+    return tokenizer(examples["text"], padding="max_length", truncation=True)
+
+tokenized_train = train_dataset.map(tokenize_function, batched=True)
+tokenized_eval = eval_dataset.map(tokenize_function, batched=True)
+
+# Model config
+config = OctagonConfig(
+    vocab_size=30522,
+    hidden_size=128,  # Smaller for demo
+    num_hidden_layers=4,
+    num_attention_heads=4,
+    intermediate_size=512,
+    num_labels=2
+)
+
+model = OctagonForSequenceClassification(config)
+
+# Metrics
+metric = evaluate.load("accuracy")
+
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    return metric.compute(predictions=predictions, references=labels)
+
+# Training args
+training_args = TrainingArguments(
+    output_dir="octagon_model",
+    evaluation_strategy="epoch",
+    save_strategy="epoch",
+    learning_rate=2e-5,
+    per_device_train_batch_size=8,
+    per_device_eval_batch_size=8,
+    num_train_epochs=3,
+    weight_decay=0.01,
+    load_best_model_at_end=True,
+)
+
+# Trainer
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_train,
+    eval_dataset=tokenized_eval,
+    compute_metrics=compute_metrics,
+)
+
+# Train
+trainer.train()
+
+# Save model
+model.save_pretrained("octagon_model")
+tokenizer.save_pretrained("octagon_model")