Committee

arXiv:2511.09197v1 Announce Type: new Abstract: Subword segmentation is typically applied in preprocessing and stays fixed during training. Alternatively, it can be learned during training to optimise the training objective. In this paper we study the learning dynamics of subword segmentation: if a language model can dynamically optimise tokenisation, how do its subwords evolve during pretraining and finetuning? To explore this, we extend the subword segmental language model (SSLM), a framework for learning subwords during training, to support pretraining and finetuning. We train models for three typologically diverse languages to study learning dynamics across the morphological spectrum: Isi-Xhosa is conjunctive (long word forms composed of many morphemes), Setswana is disjunctive (morphemes written as separate words), and English represents a typological middle ground. We analyse subword dynamics from a linguistic perspective, tracking morphology, productivity, and fertility. We identify four stages of subword learning, with the morphologically complex isi-Xhosa exhibiting greater instability. During finetuning, subword boundaries shift to become finer-grained. Lastly, we show that learnable subwords offers a promising approach to improve text generation and cross-lingual transfer for low-resource, morphologically complex languages.

In this tutorial, we build our own custom GPT-style chat system from scratch using a local Hugging Face model. We start by loading a lightweight instruction-tuned model that understands conversational prompts, then wrap it inside a structured chat framework that includes a system role, user memory, and assistant responses. We define how the agent interprets context, constructs messages, and optionally uses small built-in tools to fetch local data or simulated search results. By the end, we have a fully functional, conversational model that behaves like a personalized GPT running. Check out the FULL CODES here.  Copy CodeCopiedUse a different Browser !pip install transformers accelerate sentencepiece –quiet import torch from transformers import AutoTokenizer, AutoModelForCausalLM from typing import List, Tuple, Optional import textwrap, json, os We begin by installing the essential libraries and importing the required modules. We ensure that the environment has all necessary dependencies, such as transformers, torch, and sentencepiece, ready for use. This setup allows us to work seamlessly with Hugging Face models inside Google Colab. Check out the FULL CODES here.  Copy CodeCopiedUse a different Browser MODEL_NAME = “microsoft/Phi-3-mini-4k-instruct” BASE_SYSTEM_PROMPT = ( “You are a custom GPT running locally. ” “Follow user instructions carefully. ” “Be concise and structured. ” “If something is unclear, say it is unclear. ” “Prefer practical examples over corporate examples unless explicitly asked. ” “When asked for code, give runnable code.” ) MAX_NEW_TOKENS = 256 We configure our model name, define the system prompt that governs the assistant’s behavior, and set token limits. We establish how our custom GPT should respond, concise, structured, and practical. This section defines the foundation of our model’s identity and instruction style. Check out the FULL CODES here.  Copy CodeCopiedUse a different Browser print(“Loading model…”) tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME) if tokenizer.pad_token_id is None: tokenizer.pad_token_id = tokenizer.eos_token_id model = AutoModelForCausalLM.from_pretrained( MODEL_NAME, torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32, device_map=”auto” ) model.eval() print(“Model loaded.”) We load the tokenizer and model from Hugging Face into memory and prepare them for inference. We automatically adjust the device mapping based on available hardware, ensuring GPU acceleration if possible. Once loaded, our model is ready to generate responses. Check out the FULL CODES here.  Copy CodeCopiedUse a different Browser ConversationHistory = List[Tuple[str, str]] history: ConversationHistory = [(“system”, BASE_SYSTEM_PROMPT)] def wrap_text(s: str, w: int = 100) -> str: return “n”.join(textwrap.wrap(s, width=w)) def build_chat_prompt(history: ConversationHistory, user_msg: str) -> str: prompt_parts = [] for role, content in history: if role == “system”: prompt_parts.append(f”<|system|>n{content}n”) elif role == “user”: prompt_parts.append(f”<|user|>n{content}n”) elif role == “assistant”: prompt_parts.append(f”<|assistant|>n{content}n”) prompt_parts.append(f”<|user|>n{user_msg}n”) prompt_parts.append(“<|assistant|>n”) return “”.join(prompt_parts) We initialize the conversation history, starting with a system role, and create a prompt builder to format messages. We define how user and assistant turns are arranged in a consistent conversational structure. This ensures the model always understands the dialogue context correctly. Check out the FULL CODES here.  Copy CodeCopiedUse a different Browser def local_tool_router(user_msg: str) -> Optional[str]: msg = user_msg.strip().lower() if msg.startswith(“search:”): query = user_msg.split(“:”, 1)[-1].strip() return f”Search results about ‘{query}’:n- Key point 1n- Key point 2n- Key point 3″ if msg.startswith(“docs:”): topic = user_msg.split(“:”, 1)[-1].strip() return f”Documentation extract on ‘{topic}’:n1. The agent orchestrates tools.n2. The model consumes output.n3. Responses become memory.” return None We add a lightweight tool router that extends our GPT’s capability to simulate tasks like search or documentation retrieval. We define logic to detect special prefixes such as “search:” or “docs:” in user queries. This simple agentic design gives our assistant contextual awareness. Check out the FULL CODES here.  Copy CodeCopiedUse a different Browser def generate_reply(history: ConversationHistory, user_msg: str) -> str: tool_context = local_tool_router(user_msg) if tool_context: user_msg = user_msg + “nnUseful context:n” + tool_context prompt = build_chat_prompt(history, user_msg) inputs = tokenizer(prompt, return_tensors=”pt”).to(model.device) with torch.no_grad(): output_ids = model.generate( **inputs, max_new_tokens=MAX_NEW_TOKENS, do_sample=True, top_p=0.9, temperature=0.6, pad_token_id=tokenizer.eos_token_id ) decoded = tokenizer.decode(output_ids[0], skip_special_tokens=True) reply = decoded.split(“<|assistant|>”)[-1].strip() if “<|assistant|>” in decoded else decoded[len(prompt):].strip() history.append((“user”, user_msg)) history.append((“assistant”, reply)) return reply def save_history(history: ConversationHistory, path: str = “chat_history.json”) -> None: data = [{“role”: r, “content”: c} for (r, c) in history] with open(path, “w”) as f: json.dump(data, f, indent=2) def load_history(path: str = “chat_history.json”) -> ConversationHistory: if not os.path.exists(path): return [(“system”, BASE_SYSTEM_PROMPT)] with open(path, “r”) as f: data = json.load(f) return [(item[“role”], item[“content”]) for item in data] We define the primary reply generation function, which combines history, context, and model inference to produce coherent outputs. We also add functions to save and load past conversations for persistence. This snippet forms the operational core of our custom GPT. Check out the FULL CODES here.  Copy CodeCopiedUse a different Browser print(“n— Demo turn 1 —“) demo_reply_1 = generate_reply(history, “Explain what this custom GPT setup is doing in 5 bullet points.”) print(wrap_text(demo_reply_1)) print(“n— Demo turn 2 —“) demo_reply_2 = generate_reply(history, “search: agentic ai with local models”) print(wrap_text(demo_reply_2)) def interactive_chat(): print(“nChat ready. Type ‘exit’ to stop.”) while True: try: user_msg = input(“nUser: “).strip() except EOFError: break if user_msg.lower() in (“exit”, “quit”, “q”): break reply = generate_reply(history, user_msg) print(“nAssistant:n” + wrap_text(reply)) # interactive_chat() print(“nCustom GPT initialized successfully.”) We test the entire setup by running demo prompts and displaying generated responses. We also create an optional interactive chat loop to converse directly with the assistant. By the end, we confirm that our custom GPT runs locally and responds intelligently in real time. In conclusion, we designed and executed a custom conversational agent that mirrors GPT-style reasoning without relying on any external services. We saw how local models can be made interactive through prompt orchestration, lightweight tool routing, and conversational memory management. This approach enables us to understand the internal logic behind commercial GPT systems. It empowers us to experiment with our own rules, behaviors, and integrations in a transparent and fully offline manner. Check out the FULL CODES here. Feel free to check out our GitHub Page for Tutorials, Codes and Notebooks. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post How to Build a Fully Functional Custom GPT-style Conversational AI Locally Using Hugging Face Transformers appeared first on MarkTechPost.

arXiv:2511.08109v1 Announce Type: new Abstract: This paper examines how science fiction destabilises ontological categories by measuring conceptual permeability across the terms human, animal, and machine using masked language modelling (MLM). Drawing on corpora of science fiction (Gollancz SF Masterworks) and general fiction (NovelTM), we operationalise Darko Suvin’s theory of estrangement as computationally measurable deviation in token prediction, using RoBERTa to generate lexical substitutes for masked referents and classifying them via Gemini. We quantify conceptual slippage through three metrics: retention rate, replacement rate, and entropy, mapping the stability or disruption of category boundaries across genres. Our findings reveal that science fiction exhibits heightened conceptual permeability, particularly around machine referents, which show significant cross-category substitution and dispersion. Human terms, by contrast, maintain semantic coherence and often anchor substitutional hierarchies. These patterns suggest a genre-specific restructuring within anthropocentric logics. We argue that estrangement in science fiction operates as a controlled perturbation of semantic norms, detectable through probabilistic modelling, and that MLMs, when used critically, serve as interpretive instruments capable of surfacing genre-conditioned ontological assumptions. This study contributes to the methodological repertoire of computational literary studies and offers new insights into the linguistic infrastructure of science fiction.

arXiv:2503.17352v3 Announce Type: replace-cross Abstract: We introduce OpenVLThinker, one of the first open-source large vision-language models (LVLMs) to exhibit sophisticated chain-of-thought reasoning, achieving notable performance gains on challenging visual reasoning tasks. While text-based reasoning models (e.g., Deepseek R1) show promising results in text-only tasks, distilling their reasoning into LVLMs via supervised fine-tuning (SFT) often results in performance degradation due to imprecise visual grounding. Conversely, purely reinforcement learning (RL)-based methods face a large search space, hindering the emergence of reflective behaviors in smaller models (e.g., 7B LVLMs). Surprisingly, alternating between SFT and RL ultimately results in significant performance improvements after a few iterations. Our analysis reveals that the base model rarely exhibits reasoning behaviors initially, but SFT effectively surfaces these latent actions and narrows the RL search space, accelerating the development of reasoning capabilities. Each subsequent RL stage further refines the model’s reasoning skills, producing higher-quality SFT data for continued self-improvement. OpenVLThinker-7B consistently advances performance across six benchmarks demanding mathematical and general reasoning, notably improving MathVista by 3.8%, EMMA by 2.4%, and HallusionBench by 1.6%. Beyond demonstrating the synergy between SFT and RL for complex reasoning tasks, our findings provide early evidence towards achieving R1-style reasoning in multimodal contexts. The code, model and data are held at https://github.com/yihedeng9/OpenVLThinker.

arXiv:2511.08113v1 Announce Type: new Abstract: Skill composition is the ability to combine previously learned skills to solve new tasks. As neural networks acquire increasingly complex skills during their pretraining, it is not clear how successfully they can compose them. In this paper, we focus on Multimodal Large Language Models (MLLM), and study their ability to compose skills across modalities. To this end, we design three evaluation tasks which can be solved sequentially composing two modality-dependent skills, and evaluate several open MLLMs under two main settings: i) prompting the model to directly solve the task, and ii) using a two-step cascaded inference approach, which manually enforces the composition of the two skills for a given task. Even with these straightforward compositions, we find that all evaluated MLLMs exhibit a significant cross-modality skill composition gap. To mitigate the aforementioned gap, we explore two alternatives: i) use chain-of-thought prompting to explicitly instruct MLLMs for skill composition and ii) a specific fine-tuning recipe to promote skill composition. Although those strategies improve model performance, they still exhibit significant skill composition gaps, suggesting that more research is needed to improve cross-modal skill composition in MLLMs.

In this tutorial, we explore how to build and train an advanced neural network using JAX, Flax, and Optax in an efficient and modular way. We begin by designing a deep architecture that integrates residual connections and self-attention mechanisms for expressive feature learning. As we progress, we implement sophisticated optimization strategies with learning rate scheduling, gradient clipping, and adaptive weight decay. Throughout the process, we leverage JAX transformations such as jit, grad, and vmap to accelerate computation and ensure smooth training performance across devices. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser !pip install jax jaxlib flax optax matplotlib import jax import jax.numpy as jnp from jax import random, jit, vmap, grad import flax.linen as nn from flax.training import train_state import optax import matplotlib.pyplot as plt from typing import Any, Callable print(f”JAX version: {jax.__version__}”) print(f”Devices: {jax.devices()}”) We begin by installing and importing JAX, Flax, and Optax, along with essential utilities for numerical operations and visualization. We check our device setup to ensure that JAX is running efficiently on available hardware. This setup forms the foundation for the entire training pipeline. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser class SelfAttention(nn.Module): num_heads: int dim: int @nn.compact def __call__(self, x): B, L, D = x.shape head_dim = D // self.num_heads qkv = nn.Dense(3 * D)(x) qkv = qkv.reshape(B, L, 3, self.num_heads, head_dim) q, k, v = jnp.split(qkv, 3, axis=2) q, k, v = q.squeeze(2), k.squeeze(2), v.squeeze(2) attn_scores = jnp.einsum(‘bhqd,bhkd->bhqk’, q, k) / jnp.sqrt(head_dim) attn_weights = jax.nn.softmax(attn_scores, axis=-1) attn_output = jnp.einsum(‘bhqk,bhvd->bhqd’, attn_weights, v) attn_output = attn_output.reshape(B, L, D) return nn.Dense(D)(attn_output) class ResidualBlock(nn.Module): features: int @nn.compact def __call__(self, x, training: bool = True): residual = x x = nn.Conv(self.features, (3, 3), padding=’SAME’)(x) x = nn.BatchNorm(use_running_average=not training)(x) x = nn.relu(x) x = nn.Conv(self.features, (3, 3), padding=’SAME’)(x) x = nn.BatchNorm(use_running_average=not training)(x) if residual.shape[-1] != self.features: residual = nn.Conv(self.features, (1, 1))(residual) return nn.relu(x + residual) class AdvancedCNN(nn.Module): num_classes: int = 10 @nn.compact def __call__(self, x, training: bool = True): x = nn.Conv(32, (3, 3), padding=’SAME’)(x) x = nn.relu(x) x = ResidualBlock(64)(x, training) x = ResidualBlock(64)(x, training) x = nn.max_pool(x, (2, 2), strides=(2, 2)) x = ResidualBlock(128)(x, training) x = ResidualBlock(128)(x, training) x = jnp.mean(x, axis=(1, 2)) x = x[:, None, :] x = SelfAttention(num_heads=4, dim=128)(x) x = x.squeeze(1) x = nn.Dense(256)(x) x = nn.relu(x) x = nn.Dropout(0.5, deterministic=not training)(x) x = nn.Dense(self.num_classes)(x) return x We define a deep neural network that combines residual blocks and a self-attention mechanism for enhanced feature learning. We construct the layers modularly, ensuring that the model can capture both spatial and contextual relationships. This design enables the network to generalize effectively across various types of input data. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser class TrainState(train_state.TrainState): batch_stats: Any def create_learning_rate_schedule(base_lr: float = 1e-3, warmup_steps: int = 100, decay_steps: int = 1000) -> optax.Schedule: warmup_fn = optax.linear_schedule(init_value=0.0, end_value=base_lr, transition_steps=warmup_steps) decay_fn = optax.cosine_decay_schedule(init_value=base_lr, decay_steps=decay_steps, alpha=0.1) return optax.join_schedules(schedules=[warmup_fn, decay_fn], boundaries=[warmup_steps]) def create_optimizer(learning_rate_schedule: optax.Schedule) -> optax.GradientTransformation: return optax.chain(optax.clip_by_global_norm(1.0), optax.adamw(learning_rate=learning_rate_schedule, weight_decay=1e-4)) We create a custom training state that tracks model parameters and batch statistics. We also define a learning rate schedule with warmup and cosine decay, paired with an AdamW optimizer that includes gradient clipping and weight decay. This combination ensures stable and adaptive training. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser @jit def compute_metrics(logits, labels): loss = optax.softmax_cross_entropy_with_integer_labels(logits, labels).mean() accuracy = jnp.mean(jnp.argmax(logits, -1) == labels) return {‘loss’: loss, ‘accuracy’: accuracy} def create_train_state(rng, model, input_shape, learning_rate_schedule): variables = model.init(rng, jnp.ones(input_shape), training=False) params = variables[‘params’] batch_stats = variables.get(‘batch_stats’, {}) tx = create_optimizer(learning_rate_schedule) return TrainState.create(apply_fn=model.apply, params=params, tx=tx, batch_stats=batch_stats) @jit def train_step(state, batch, dropout_rng): images, labels = batch def loss_fn(params): variables = {‘params’: params, ‘batch_stats’: state.batch_stats} logits, new_model_state = state.apply_fn(variables, images, training=True, mutable=[‘batch_stats’], rngs={‘dropout’: dropout_rng}) loss = optax.softmax_cross_entropy_with_integer_labels(logits, labels).mean() return loss, (logits, new_model_state) grad_fn = jax.value_and_grad(loss_fn, has_aux=True) (loss, (logits, new_model_state)), grads = grad_fn(state.params) state = state.apply_gradients(grads=grads, batch_stats=new_model_state[‘batch_stats’]) metrics = compute_metrics(logits, labels) return state, metrics @jit def eval_step(state, batch): images, labels = batch variables = {‘params’: state.params, ‘batch_stats’: state.batch_stats} logits = state.apply_fn(variables, images, training=False) return compute_metrics(logits, labels) We implement JIT-compiled training and evaluation functions to achieve efficient execution. The training step computes gradients, updates parameters, and dynamically maintains batch statistics. We also define evaluation metrics that help us monitor loss and accuracy throughout the training process. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def generate_synthetic_data(rng, num_samples=1000, img_size=32): rng_x, rng_y = random.split(rng) images = random.normal(rng_x, (num_samples, img_size, img_size, 3)) labels = random.randint(rng_y, (num_samples,), 0, 10) return images, labels def create_batches(images, labels, batch_size=32): num_batches = len(images) // batch_size for i in range(num_batches): idx = slice(i * batch_size, (i + 1) * batch_size) yield images[idx], labels[idx] We generate synthetic data to simulate an image classification task, enabling us to train the model without relying on external datasets. We then batch the data efficiently for iterative updates. This approach allows us to test the full pipeline quickly and verify that all components function correctly. Check out the FULL CODES here. Copy CodeCopiedUse a different Browser def train_model(num_epochs=5, batch_size=32): rng = random.PRNGKey(0) rng, data_rng, model_rng = random.split(rng, 3) train_images, train_labels = generate_synthetic_data(data_rng, num_samples=1000) test_images, test_labels = generate_synthetic_data(data_rng, num_samples=200) model = AdvancedCNN(num_classes=10) lr_schedule = create_learning_rate_schedule(base_lr=1e-3, warmup_steps=50, decay_steps=500) state = create_train_state(model_rng, model, (1, 32, 32, 3), lr_schedule) history = {‘train_loss’: [], ‘train_acc’: [], ‘test_acc’: []} print(“Starting training…”) for epoch in range(num_epochs): train_metrics = [] for batch in create_batches(train_images, train_labels, batch_size): rng, dropout_rng = random.split(rng) state, metrics = train_step(state, batch, dropout_rng) train_metrics.append(metrics) train_loss = jnp.mean(jnp.array([m[‘loss’] for m in train_metrics])) train_acc = jnp.mean(jnp.array([m[‘accuracy’] for m in train_metrics])) test_metrics = [eval_step(state, batch) for batch in create_batches(test_images, test_labels, batch_size)] test_acc = jnp.mean(jnp.array([m[‘accuracy’] for m in test_metrics])) history[‘train_loss’].append(float(train_loss)) history[‘train_acc’].append(float(train_acc)) history[‘test_acc’].append(float(test_acc)) print(f”Epoch {epoch + 1}/{num_epochs}: Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, Test Acc: {test_acc:.4f}”) return history, state history, trained_state = train_model(num_epochs=5) fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) ax1.plot(history[‘train_loss’], label=’Train Loss’) ax1.set_xlabel(‘Epoch’); ax1.set_ylabel(‘Loss’); ax1.set_title(‘Training Loss’); ax1.legend(); ax1.grid(True) ax2.plot(history[‘train_acc’], label=’Train Accuracy’) ax2.plot(history[‘test_acc’], label=’Test Accuracy’) ax2.set_xlabel(‘Epoch’); ax2.set_ylabel(‘Accuracy’); ax2.set_title(‘Model Accuracy’); ax2.legend(); ax2.grid(True) plt.tight_layout(); plt.show() print(“n Tutorial complete! This covers:”) print(“- Custom Flax modules (ResNet blocks, Self-Attention)”) print(“- Advanced Optax optimizers (AdamW with gradient clipping)”)

arXiv:2511.06571v1 Announce Type: new Abstract: Large language models (LLMs) have achieved remarkable progress across diverse tasks, yet their internal mechanisms remain largely opaque. In this work, we address a fundamental question: to what extent can the original input text be recovered from a single last-token representation within an LLM? We propose Rep2Text, a novel framework for decoding full text from last-token representations. Rep2Text employs a trainable adapter that projects a target model’s internal representations into the embedding space of a decoding language model, which then autoregressively reconstructs the input text. Experiments on various model combinations (Llama-3.1-8B, Gemma-7B, Mistral-7B-v0.1, Llama-3.2-3B) demonstrate that, on average, over half of the information in 16-token sequences can be recovered from this compressed representation while maintaining strong semantic integrity and coherence. Furthermore, our analysis reveals an information bottleneck effect: longer sequences exhibit decreased token-level recovery while preserving strong semantic integrity. Besides, our framework also demonstrates robust generalization to out-of-distribution medical data.

arXiv:2511.06101v1 Announce Type: cross Abstract: Web agents struggle to adapt to new websites due to the scarcity of environment specific tasks and demonstrations. Recent works have explored synthetic data generation to address this challenge, however, they suffer from data quality issues where synthesized tasks contain hallucinations that cannot be executed, and collected trajectories are noisy with redundant or misaligned actions. In this paper, we propose SynthAgent, a fully synthetic supervision framework that aims at improving synthetic data quality via dual refinement of both tasks and trajectories. Our approach begins by synthesizing diverse tasks through categorized exploration of web elements, ensuring efficient coverage of the target environment. During trajectory collection, we refine tasks when conflicts with actual observations are detected, mitigating hallucinations while maintaining task consistency. After collection, we conduct trajectory refinement with a global context to mitigate potential noise or misalignments. Finally, we fine-tune open-source web agents on the refined synthetic data to adapt them to the target environment. Experimental results demonstrate that SynthAgent outperforms existing synthetic data methods, validating the importance of high-quality synthetic supervision. The code will be publicly available at https://github.com/aiming-lab/SynthAgent.